Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / 935eda78fd1cca65e1b82872b5943ab8d30f94bf / . / CORE / WDA / src / wlan_qct_wda.c
blob: 786e7edf398ba0808d44c2473ed0e380b93eb773 [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
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1918 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1919#ifdef WLAN_DEBUG
1920 {
1921 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1922 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1923 "****** Dumping CFG TLV ***** ");
1924 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
1925 {
1926 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1927 "%02x %02x %02x %02x %02x %02x %02x %02x",
1928 tlvStructStart[i],
1929 tlvStructStart[i+1],
1930 tlvStructStart[i+2],
1931 tlvStructStart[i+3],
1932 tlvStructStart[i+4],
1933 tlvStructStart[i+5],
1934 tlvStructStart[i+6],
1935 tlvStructStart[i+7]);
1936 }
1937 /* Dump the bytes in the last line*/
1938 for (; i < wdiStartParams->usConfigBufferLen; i++)
1939 {
1940 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1941 "%02x ",tlvStructStart[i]);
1942 }
1943 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1944 "**************************** ");
1945 }
1946#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1947 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1948handle_failure:
1949 vos_mem_free(configParam);
1950 return VOS_STATUS_E_FAILURE;
1951}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1952/*
1953 * FUNCTION: WDA_wdiCompleteCB
1954 * call the voss call back function
1955 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1956void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1957{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1958 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
1959 tWDA_CbContext *wdaContext;
1960
1961 if(NULL == pWdaParams)
1962 {
1963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]1964 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1965 VOS_ASSERT(0) ;
1966 return ;
1967 }
1968
1969 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
1970
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1971 if (NULL == wdaContext)
1972 {
1973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]1974 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1975 return ;
1976 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1977
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1978 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1979 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1980 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1981 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1982 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1983 vos_mem_free(pWdaParams);
1984
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1985 if(WDI_STATUS_SUCCESS != status)
1986 {
1987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1988 "WDI stop callback returned failure" );
1989 VOS_ASSERT(0) ;
1990 }
1991 else
1992 {
1993 wdaContext->wdaState = WDA_STOP_STATE;
1994 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1995
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]1996 /* FTM Driver stop procedure should be synced.
1997 * Stop and Close will happen on same context */
1998 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
1999 {
2000 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2001 {
2002 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2003 "%s: FTM Stop Event Set Fail", __func__);
2004 VOS_ASSERT(0);
2005 }
2006 }
2007
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2008 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2009 vos_WDAComplete_cback(wdaContext->pVosContext);
2010
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2011 return ;
2012}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2013/*
2014 * FUNCTION: WDA_stop
2015 * call WDI_stop
2016 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2017VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2018{
2019 WDI_Status wdiStatus;
2020 VOS_STATUS status = VOS_STATUS_SUCCESS;
2021 WDI_StopReqParamsType *wdiStopReq;
2022 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2023 tWDA_ReqParams *pWdaParams ;
2024
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2025 if (NULL == pWDA)
2026 {
2027 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2028 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2029 VOS_ASSERT(0);
2030 return VOS_STATUS_E_FAILURE;
2031 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2032 if (pWDA->wdiFailed == true)
2033 {
2034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2035 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2036 return VOS_STATUS_E_ALREADY;
2037 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2038
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2039 /* FTM mode stay START_STATE */
2040 if( (WDA_READY_STATE != pWDA->wdaState) &&
2041 (WDA_INIT_STATE != pWDA->wdaState) &&
2042 (WDA_START_STATE != pWDA->wdaState) )
2043 {
2044 VOS_ASSERT(0);
2045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2046 wdiStopReq = (WDI_StopReqParamsType *)
2047 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2048 if(NULL == wdiStopReq)
2049 {
2050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2051 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2052 VOS_ASSERT(0);
2053 return VOS_STATUS_E_NOMEM;
2054 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2055
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2056 wdiStopReq->wdiStopReason = reason;
2057 wdiStopReq->wdiReqStatusCB = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2058
2059 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2060 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2061 {
2062 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2063 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2064 VOS_ASSERT(0);
2065 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2066 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2067 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2068
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2069 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2070 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2071 {
2072 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2073 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2074 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2075
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2076 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2077 pWdaParams->wdaMsgParam = NULL;
2078 pWdaParams->pWdaContext = pWDA;
2079
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2080 /* call WDI stop */
2081 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2082 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2083
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2084 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2085 {
2086 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2087 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2088 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2089 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2090 status = VOS_STATUS_E_FAILURE;
2091 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2092
2093 /* FTM Driver stop procedure should be synced.
2094 * Stop and Close will happen on same context */
2095 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2096 {
2097 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2098 WDI_RESPONSE_TIMEOUT);
2099 if (status != VOS_STATUS_SUCCESS)
2100 {
2101 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2102 "%s: FTM Stop Timepoout", __func__);
2103 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2104 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2105 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2106 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2107 return status;
2108}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2109/*
2110 * FUNCTION: WDA_close
2111 * call WDI_close and free the WDA context
2112 */
2113VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2114{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2115 VOS_STATUS status = VOS_STATUS_SUCCESS;
2116 WDI_Status wstatus;
2117 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2118 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2119 if (NULL == wdaContext)
2120 {
2121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2122 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2123 return VOS_STATUS_E_FAILURE;
2124 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2125 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2126 (WDA_STOP_STATE != wdaContext->wdaState))
2127 {
2128 VOS_ASSERT(0);
2129 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2130 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2131 wstatus = WDI_Close();
2132 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2133 {
2134 status = VOS_STATUS_E_FAILURE;
2135 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2136 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2137 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2138 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2139 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2140 {
2141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2142 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2143 status = VOS_STATUS_E_FAILURE;
2144 }
2145
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2146 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2147 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2148 {
2149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2150 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2151 status = VOS_STATUS_E_FAILURE;
2152 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2153 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2154 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2155 {
2156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2157 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2158 status = VOS_STATUS_E_FAILURE;
2159 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2160 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2161 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2162 {
2163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2164 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2165 status = VOS_STATUS_E_FAILURE;
2166 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2167 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2168 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2169 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2170 {
2171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2172 "error in WDA close " );
2173 status = VOS_STATUS_E_FAILURE;
2174 }
2175 return status;
2176}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2177/*
2178 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2179 * returns 1 if the compiled version is greater than or equal to the input version
2180 */
2181
2182uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2183{
2184 VOS_STATUS status = VOS_STATUS_SUCCESS;
2185 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2186 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2187 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2188 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2189 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2190 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2191 (compiledVersion.revision >= revision)))
2192 return 1;
2193 else
2194 return 0;
2195}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2196/*
2197 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2198 * returns 1 if the compiled version is greater than or equal to the input version
2199 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2200uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2201{
2202 VOS_STATUS status = VOS_STATUS_SUCCESS;
2203 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2204 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2205 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2206 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2207 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2208 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2209 (reportedVersion.revision >= revision)))
2210 return 1;
2211 else
2212 return 0;
2213}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2214/*
2215 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2216 * Returns the version of the WCNSS WLAN API with which the HOST
2217 * device driver was compiled
2218 */
2219VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2220 tSirVersionType *pVersion)
2221{
2222 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2223 if ((NULL == pvosGCtx) || (NULL == pVersion))
2224 {
2225 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2226 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2227 VOS_ASSERT(0);
2228 return VOS_STATUS_E_FAILURE;
2229 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2230 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2231 if (NULL == pWDA )
2232 {
2233 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2234 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2235 VOS_ASSERT(0);
2236 return VOS_STATUS_E_FAILURE;
2237 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2238 *pVersion = pWDA->wcnssWlanCompiledVersion;
2239 return VOS_STATUS_SUCCESS;
2240}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2241/*
2242 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2243 * Returns the version of the WCNSS WLAN API with which the WCNSS
2244 * device driver was compiled
2245 */
2246VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2247 tSirVersionType *pVersion)
2248{
2249 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2250 if ((NULL == pvosGCtx) || (NULL == pVersion))
2251 {
2252 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2253 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2254 VOS_ASSERT(0);
2255 return VOS_STATUS_E_FAILURE;
2256 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2257 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2258 if (NULL == pWDA )
2259 {
2260 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2261 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2262 VOS_ASSERT(0);
2263 return VOS_STATUS_E_FAILURE;
2264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2265 *pVersion = pWDA->wcnssWlanReportedVersion;
2266 return VOS_STATUS_SUCCESS;
2267}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2268/*
2269 * FUNCTION: WDA_GetWcnssSoftwareVersion
2270 * Returns the WCNSS Software version string
2271 */
2272VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2273 tANI_U8 *pVersion,
2274 tANI_U32 versionBufferSize)
2275{
2276 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2277 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2278 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2279 if ((NULL == pvosGCtx) || (NULL == pVersion))
2280 {
2281 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2282 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2283 VOS_ASSERT(0);
2284 return VOS_STATUS_E_FAILURE;
2285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2286 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2287 if (NULL == pWDA )
2288 {
2289 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2290 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2291 VOS_ASSERT(0);
2292 return VOS_STATUS_E_FAILURE;
2293 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2294 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2295 return VOS_STATUS_SUCCESS;
2296}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2297/*
2298 * FUNCTION: WDA_GetWcnssHardwareVersion
2299 * Returns the WCNSS Hardware version string
2300 */
2301VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2302 tANI_U8 *pVersion,
2303 tANI_U32 versionBufferSize)
2304{
2305 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2306 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2307 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2308 if ((NULL == pvosGCtx) || (NULL == pVersion))
2309 {
2310 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2311 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2312 VOS_ASSERT(0);
2313 return VOS_STATUS_E_FAILURE;
2314 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2315 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2316 if (NULL == pWDA )
2317 {
2318 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2319 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2320 VOS_ASSERT(0);
2321 return VOS_STATUS_E_FAILURE;
2322 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2323 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2324 return VOS_STATUS_SUCCESS;
2325}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2326/*
2327 * FUNCTION: WDA_WniCfgDnld
2328 * Trigger CFG Download
2329 */
2330VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2331{
2332 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2333 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2334
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2335 if (NULL == pMac )
2336 {
2337 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2338 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2339 VOS_ASSERT(0);
2340 return VOS_STATUS_E_FAILURE;
2341 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2342 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2343 return vosStatus;
2344}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2345/* -----------------------------------------------------------------
2346 * WDI interface
2347 * -----------------------------------------------------------------
2348 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2349/*
2350 * FUNCTION: WDA_suspendDataTxCallback
2351 * call back function called from TL after suspend Transmission
2352 */
2353VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2354 v_U8_t* ucSTAId,
2355 VOS_STATUS vosStatus)
2356{
2357 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2359 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2360 if (NULL == pWDA )
2361 {
2362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2363 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2364 VOS_ASSERT(0);
2365 return VOS_STATUS_E_FAILURE;
2366 }
2367 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2368 {
2369 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2370 }
2371 else
2372 {
2373 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2374 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2375 /* Trigger the event to bring the WDA TL suspend function to come
2376 * out of wait*/
2377 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2378 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2379 {
2380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2381 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2382 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2383 /* If TL suspended had timedout before this callback was called, resume back
2384 * TL.*/
2385 if (pWDA->txSuspendTimedOut)
2386 {
2387 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2388 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2389 WDA_ResumeDataTx(pWDA);
2390 pWDA->txSuspendTimedOut = FALSE;
2391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2392 return VOS_STATUS_SUCCESS;
2393}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2394/*
2395 * FUNCTION: WDA_suspendDataTx
2396 * Update TL to suspend the data Transmission
2397 */
2398VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2399{
2400 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2401 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2402
2403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2404 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2405 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2406 if (pWDA->txSuspendTimedOut)
2407 {
2408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2409 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2410 return status;
2411 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2412 /* Reset the event to be not signalled */
2413 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2414 if(!VOS_IS_STATUS_SUCCESS(status))
2415 {
2416 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2417 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2418 return VOS_STATUS_E_FAILURE;
2419 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2420 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2421 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2422 WDA_SuspendDataTxCallback);
2423 if(status != VOS_STATUS_SUCCESS)
2424 {
2425 return status;
2426 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2427 /* Wait for the event to be set by the TL, to get the response of
2428 * suspending the TX queues, this event should be set by the Callback
2429 * function called by TL*/
2430 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2431 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2432 if(!VOS_IS_STATUS_SUCCESS(status))
2433 {
2434 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2435 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2436 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2437 /* Set this flag to true when TL suspend times out, so that when TL
2438 * suspend eventually happens and calls the callback, TL can be resumed
2439 * right away by looking at this flag when true.*/
2440 pWDA->txSuspendTimedOut = TRUE;
2441 }
2442 else
2443 {
2444 pWDA->txSuspendTimedOut = FALSE;
2445 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2446 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2447 {
2448 status = VOS_STATUS_SUCCESS;
2449 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2450 return status;
2451}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2452/*
2453 * FUNCTION: WDA_resumeDataTx
2454 * Update TL to resume the data Transmission
2455 */
2456VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2457{
2458 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2459
2460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2461 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2462
2463 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2464 return status;
2465}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2466/*
2467 * FUNCTION: WDA_InitScanReqCallback
2468 * Trigger Init SCAN callback
2469 */
2470void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2471{
2472 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2473 tWDA_CbContext *pWDA;
2474 tInitScanParams *pWDA_ScanParam ;
2475 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2477 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2478 if(NULL == pWdaParams)
2479 {
2480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2481 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2482 VOS_ASSERT(0) ;
2483 return ;
2484 }
2485 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2486 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2487 if(NULL == pWDA_ScanParam)
2488 {
2489 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2490 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2491 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2492 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2493 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2494 return ;
2495 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2496 if(WDI_STATUS_SUCCESS != wdiStatus)
2497 {
2498 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2499 if(VOS_STATUS_SUCCESS != status)
2500 {
2501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2502 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2503 }
2504 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2505 /* free WDI command buffer */
2506 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2507 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2508
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2509
2510 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2511 /* without converting the Status to Failure or Success Just
2512 pass the same status to lim */
2513 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2514 /* send SCAN RSP message back to PE */
2515 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2516 return ;
2517}
2518
2519/*
2520 * FUNCTION: WDA_ProcessInitScanReq
2521 * Trigger Init SCAN in DAL
2522 */
2523VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2524 tInitScanParams *initScanParams)
2525{
2526 WDI_Status status = WDI_STATUS_SUCCESS ;
2527 WDI_InitScanReqParamsType *wdiInitScanParam =
2528 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2529 sizeof(WDI_InitScanReqParamsType)) ;
2530 tWDA_ReqParams *pWdaParams;
2531 tANI_U8 i = 0;
2532
2533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2534 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2535 if(NULL == wdiInitScanParam)
2536 {
2537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2538 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2539 VOS_ASSERT(0);
2540 return VOS_STATUS_E_NOMEM;
2541 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2542 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2543 if(NULL == pWdaParams)
2544 {
2545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2546 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2547 VOS_ASSERT(0);
2548 vos_mem_free(wdiInitScanParam);
2549 return VOS_STATUS_E_NOMEM;
2550 }
2551
2552 /* Copy init Scan params to WDI structure */
2553 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2554 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2555 sizeof(tSirMacAddr)) ;
2556 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2557 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2558 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2559 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2560 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2561 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2562 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2563 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2564 {
2565 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2566 initScanParams->scanEntry.bssIdx[i] ;
2567 }
2568
2569 /* if Frame length, copy macMgmtHdr or WDI structure */
2570 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2571 {
2572 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2573 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2574 }
2575 wdiInitScanParam->wdiReqStatusCB = NULL ;
2576
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2577 /* Store Init Req pointer, as this will be used for response */
2578 pWdaParams->pWdaContext = pWDA;
2579 pWdaParams->wdaMsgParam = initScanParams;
2580 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2581 /* first try to suspend TX */
2582 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2583 if(WDI_STATUS_SUCCESS != status)
2584 {
2585 goto handleWdiFailure;
2586 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2587 /* call DAL API to pass init scan request to DAL */
2588 status = WDI_InitScanReq(wdiInitScanParam,
2589 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2590 if(IS_WDI_STATUS_FAILURE(status))
2591 {
2592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2593 "error in WDA Init Scan, Resume Tx " );
2594 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2595 VOS_ASSERT(0) ;
2596
2597 goto handleWdiFailure;
2598 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2599 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2600handleWdiFailure:
2601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2602 "Failure in WDI Api, free all the memory " );
2603 /* free WDI command buffer */
2604 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2605 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2606 /* send Failure to PE */
2607 initScanParams->status = eSIR_FAILURE ;
2608 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2609 return CONVERT_WDI2VOS_STATUS(status) ;
2610}
2611
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2612/*
2613 * FUNCTION: WDA_StartScanReqCallback
2614 * send Start SCAN RSP back to PE
2615 */
2616void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2617 void* pUserData)
2618{
2619 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2620 tWDA_CbContext *pWDA;
2621 tStartScanParams *pWDA_ScanParam;
2622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2623 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2624 if(NULL == pWdaParams)
2625 {
2626 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2627 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2628 VOS_ASSERT(0) ;
2629 return ;
2630 }
2631 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2632 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2633 if(NULL == pWDA_ScanParam)
2634 {
2635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2636 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2637 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2638 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2639 return ;
2640 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2641 if(NULL == pWdaParams->wdaWdiApiMsgParam)
2642 {
2643 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2644 "%s: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2645 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2646 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2647 return ;
2648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2649 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2650 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2651
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2652
2653 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2654 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2655 /* send SCAN RSP message back to PE */
2656 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2657 return ;
2658}
2659
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2660/*
2661 * FUNCTION: WDA_ProcessStartScanReq
2662 * Trigger start SCAN in WDI
2663 */
2664VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
2665 tStartScanParams *startScanParams)
2666{
2667 WDI_Status status = WDI_STATUS_SUCCESS;
2668 WDI_StartScanReqParamsType *wdiStartScanParams =
2669 (WDI_StartScanReqParamsType *)vos_mem_malloc(
2670 sizeof(WDI_StartScanReqParamsType)) ;
2671 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2673 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2674 if(NULL == wdiStartScanParams)
2675 {
2676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2677 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2678 VOS_ASSERT(0);
2679 return VOS_STATUS_E_NOMEM;
2680 }
2681 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2682 if(NULL == pWdaParams)
2683 {
2684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2685 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2686 VOS_ASSERT(0);
2687 vos_mem_free(wdiStartScanParams);
2688 return VOS_STATUS_E_NOMEM;
2689 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2690 /* Copy init Scan params to WDI structure */
2691 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
2692 wdiStartScanParams->wdiReqStatusCB = NULL ;
2693
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2694 /* Store Init Req pointer, as this will be used for response */
2695 /* store Params pass it to WDI */
2696 pWdaParams->pWdaContext = pWDA;
2697 pWdaParams->wdaMsgParam = startScanParams;
2698 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2699 /* call DAL API to pass init scan request to DAL */
2700 status = WDI_StartScanReq(wdiStartScanParams,
2701 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2702 /* failure returned by WDI API */
2703 if(IS_WDI_STATUS_FAILURE(status))
2704 {
2705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2706 "Failure in Start Scan WDI API, free all the memory "
2707 "It should be due to previous abort scan." );
2708 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2709 vos_mem_free(pWdaParams) ;
2710 startScanParams->status = eSIR_FAILURE ;
2711 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
2712 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2713 return CONVERT_WDI2VOS_STATUS(status) ;
2714}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2715/*
2716 * FUNCTION: WDA_EndScanReqCallback
2717 * END SCAN callback
2718 */
2719void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
2720{
2721 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2722 tWDA_CbContext *pWDA;
2723 tEndScanParams *endScanParam;
2724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2725 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2726 if(NULL == pWdaParams)
2727 {
2728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2729 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2730 VOS_ASSERT(0) ;
2731 return ;
2732 }
2733 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2734 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2735 if(NULL == endScanParam)
2736 {
2737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2738 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2739 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2740 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2741 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2742 return ;
2743 }
2744
2745 /* Free WDI command buffer */
2746 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2747 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2748 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2749 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2750 /* send response back to PE */
2751 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
2752 return ;
2753}
2754
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2755/*
2756 * FUNCTION: WDA_ProcessEndScanReq
2757 * Trigger END SCAN in WDI
2758 */
2759VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
2760 tEndScanParams *endScanParams)
2761{
2762 WDI_Status status = WDI_STATUS_SUCCESS;
2763 WDI_EndScanReqParamsType *wdiEndScanParams =
2764 (WDI_EndScanReqParamsType *)vos_mem_malloc(
2765 sizeof(WDI_EndScanReqParamsType)) ;
2766 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2767 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2768 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2769 if(NULL == wdiEndScanParams)
2770 {
2771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2772 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2773 VOS_ASSERT(0);
2774 return VOS_STATUS_E_NOMEM;
2775 }
2776 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2777 if(NULL == pWdaParams)
2778 {
2779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2780 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2781 VOS_ASSERT(0);
2782 vos_mem_free(wdiEndScanParams);
2783 return VOS_STATUS_E_NOMEM;
2784 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2785 /* Copy init Scan params to WDI structure */
2786 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
2787 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2788 /* Store Init Req pointer, as this will be used for response */
2789 /* store Params pass it to WDI */
2790 pWdaParams->pWdaContext = pWDA;
2791 pWdaParams->wdaMsgParam = endScanParams;
2792 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2793 /* call DAL API to pass init scan request to DAL */
2794 status = WDI_EndScanReq(wdiEndScanParams,
2795 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2796 if(IS_WDI_STATUS_FAILURE(status))
2797 {
2798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2799 "Failure in End Scan WDI API, free all the memory "
2800 "It should be due to previous abort scan." );
2801 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2802 vos_mem_free(pWdaParams) ;
2803 endScanParams->status = eSIR_FAILURE ;
2804 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
2805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2806 return CONVERT_WDI2VOS_STATUS(status) ;
2807}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2808/*
2809 * FUNCTION: WDA_FinishScanReqCallback
2810 * Trigger Finish SCAN callback
2811 */
2812void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2813{
2814 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2815 tWDA_CbContext *pWDA;
2816 tFinishScanParams *finishScanParam;
2817 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2819 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2820 if(NULL == pWdaParams)
2821 {
2822 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2823 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2824 VOS_ASSERT(0) ;
2825 return ;
2826 }
2827
2828 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2829 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2830 if(NULL == finishScanParam)
2831 {
2832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2833 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2834 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2835 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2836 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2837 return ;
2838 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2839 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2840 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2841 /*
2842 * Now Resume TX, if we reached here means, TX is already suspended, we
2843 * have to resume it unconditionaly
2844 */
2845 status = WDA_ResumeDataTx(pWDA) ;
2846
2847 if(VOS_STATUS_SUCCESS != status)
2848 {
2849 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2850 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2851 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2852 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2853 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
2854 return ;
2855}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2856/*
2857 * FUNCTION: WDA_ProcessFinshScanReq
2858 * Trigger Finish SCAN in WDI
2859 */
2860VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
2861 tFinishScanParams *finishScanParams)
2862{
2863 WDI_Status status = WDI_STATUS_SUCCESS;
2864 WDI_FinishScanReqParamsType *wdiFinishScanParams =
2865 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
2866 sizeof(WDI_FinishScanReqParamsType)) ;
2867 tWDA_ReqParams *pWdaParams ;
2868 tANI_U8 i = 0;
2869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2870 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2871 if(NULL == wdiFinishScanParams)
2872 {
2873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2874 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2875 VOS_ASSERT(0);
2876 return VOS_STATUS_E_NOMEM;
2877 }
2878 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2879 if(NULL == pWdaParams)
2880 {
2881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2882 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2883 VOS_ASSERT(0);
2884 vos_mem_free(wdiFinishScanParams);
2885 return VOS_STATUS_E_NOMEM;
2886 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2887 /* Copy init Scan params to WDI structure */
2888 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
2889 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
2890 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2891 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
2892 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
2893 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
2894 finishScanParams->frameLength ;
2895 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
2896 finishScanParams->currentOperChannel ;
2897 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
2898 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
2899 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2900 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
2901 {
2902 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2903 finishScanParams->scanEntry.bssIdx[i] ;
2904 }
2905
2906
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2907 /* if Frame length, copy macMgmtHdr ro WDI structure */
2908 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
2909 {
2910 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
2911 &finishScanParams->macMgmtHdr,
2912 sizeof(WDI_MacMgmtHdr)) ;
2913 }
2914 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2915 /* Store Init Req pointer, as this will be used for response */
2916 /* store Params pass it to WDI */
2917 pWdaParams->pWdaContext = pWDA;
2918 pWdaParams->wdaMsgParam = finishScanParams;
2919 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2920 /* call DAL API to pass init scan request to DAL */
2921 status = WDI_FinishScanReq(wdiFinishScanParams,
2922 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2923
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2924
2925 /*
2926 * WDI API returns failure..
2927 */
2928 if(IS_WDI_STATUS_FAILURE( status))
2929 {
2930 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2931 "Failure in Finish Scan WDI API, free all the memory " );
2932 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2933 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2934 finishScanParams->status = eSIR_FAILURE ;
2935 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
2936 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2937 return CONVERT_WDI2VOS_STATUS(status) ;
2938}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2939/*---------------------------------------------------------------------
2940 * ASSOC API's
2941 *---------------------------------------------------------------------
2942 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2943/*
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame^]2944 * FUNCTION: WDA_JoinRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2945 * Trigger Init SCAN callback
2946 */
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame^]2947void WDA_JoinRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2948{
2949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2950 tWDA_CbContext *pWDA;
2951 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2953 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2954 if(NULL == pWdaParams)
2955 {
2956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2957 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2958 VOS_ASSERT(0) ;
2959 return ;
2960 }
2961 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2962 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2963 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
2964 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2965 /* reset macBSSID */
2966 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2967 /* reset macSTASelf */
2968 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2969 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2970 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2971 return ;
2972}
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame^]2973
2974/*
2975 * FUNCTION: WDA_JoinReqCallback
2976 * Free memory and send SWITCH CHANNEL RSP back to PE.
2977 * Invoked when Enter JOIN REQ failed in WDI and no RSP callback is generated.
2978 */
2979void WDA_JoinReqCallback(WDI_Status wdiStatus, void* pUserData)
2980{
2981 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2982 tWDA_CbContext *pWDA;
2983 tSwitchChannelParams *joinReqParam;
2984
2985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2986 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
2987
2988 if(NULL == pWdaParams)
2989 {
2990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2991 "%s: pWdaParams received NULL", __func__);
2992 VOS_ASSERT(0);
2993 return;
2994 }
2995
2996 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2997 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
2998 joinReqParam->status = wdiStatus;
2999
3000 if(IS_WDI_STATUS_FAILURE(wdiStatus))
3001 {
3002 /* reset macBSSID */
3003 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
3004 /* reset macSTASelf */
3005 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
3006
3007 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3008 vos_mem_free(pWdaParams);
3009 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
3010 }
3011
3012 return;
3013}
3014
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3015/*
3016 * FUNCTION: WDA_ProcessJoinReq
3017 * Trigger Join REQ in WDI
3018 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3019VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
3020 tSwitchChannelParams* joinReqParam)
3021{
3022 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3023 WDI_JoinReqParamsType *wdiJoinReqParam =
3024 (WDI_JoinReqParamsType *)vos_mem_malloc(
3025 sizeof(WDI_JoinReqParamsType)) ;
3026 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3027 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3028 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3029 if(NULL == wdiJoinReqParam)
3030 {
3031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3032 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3033 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3034 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3035 return VOS_STATUS_E_NOMEM;
3036 }
3037 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3038 if(NULL == pWdaParams)
3039 {
3040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3041 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3042 VOS_ASSERT(0);
3043 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3044 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3045 return VOS_STATUS_E_NOMEM;
3046 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3047
3048 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3049 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3050 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3051 {
3052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3053 "%s: received join request when BSSID or self-STA is NULL "
3054 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3055 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3056 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3057 VOS_ASSERT(0);
3058 vos_mem_free(wdiJoinReqParam);
3059 vos_mem_free(pWdaParams);
3060 joinReqParam->status = eSIR_FAILURE ;
3061 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3062 return VOS_STATUS_E_INVAL;
3063 }
3064
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3065 /* copy the BSSID for pWDA */
3066 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3067 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3068 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3069 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3070 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3071 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3072#ifdef WLAN_FEATURE_VOWIFI
3073 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3074 joinReqParam->maxTxPower ;
3075#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3076 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3077 joinReqParam->localPowerConstraint ;
3078#endif
3079 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3080 joinReqParam->secondaryChannelOffset ;
3081 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3082
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame^]3083 wdiJoinReqParam->wdiReqStatusCB = WDA_JoinReqCallback;
3084 wdiJoinReqParam->pUserData = pWdaParams;
3085
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3086 /* Store Init Req pointer, as this will be used for response */
3087 /* store Params pass it to WDI */
3088 pWdaParams->pWdaContext = pWDA;
3089 pWdaParams->wdaMsgParam = joinReqParam;
3090 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3091 status = WDI_JoinReq(wdiJoinReqParam,
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame^]3092 (WDI_JoinRspCb )WDA_JoinRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3093 if(IS_WDI_STATUS_FAILURE(status))
3094 {
3095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3096 "Failure in Join WDI API, free all the memory " );
3097 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3098 vos_mem_free(pWdaParams) ;
3099 joinReqParam->status = eSIR_FAILURE ;
3100 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3101 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3102 return CONVERT_WDI2VOS_STATUS(status) ;
3103}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3104/*
3105 * FUNCTION: WDA_SwitchChannelReqCallback
3106 * send Switch channel RSP back to PE
3107 */
3108void WDA_SwitchChannelReqCallback(
3109 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3110{
3111 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3112 tWDA_CbContext *pWDA;
3113 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3115 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3116 if(NULL == pWdaParams)
3117 {
3118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3119 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3120 VOS_ASSERT(0) ;
3121 return ;
3122 }
3123 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3124 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3125
3126#ifdef WLAN_FEATURE_VOWIFI
3127 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3128#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3129 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3130 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3131 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3132 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3133 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3134 return ;
3135}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3136/*
3137 * FUNCTION: WDA_ProcessChannelSwitchReq
3138 * Request to WDI to switch channel REQ params.
3139 */
3140VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3141 tSwitchChannelParams *pSwitchChanParams)
3142{
3143 WDI_Status status = WDI_STATUS_SUCCESS ;
3144 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3145 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3146 sizeof(WDI_SwitchChReqParamsType)) ;
3147 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3149 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3150 if(NULL == wdiSwitchChanParam)
3151 {
3152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3153 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3154 VOS_ASSERT(0);
3155 return VOS_STATUS_E_NOMEM;
3156 }
3157 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3158 if(NULL == pWdaParams)
3159 {
3160 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3161 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3162 VOS_ASSERT(0);
3163 vos_mem_free(wdiSwitchChanParam);
3164 return VOS_STATUS_E_NOMEM;
3165 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3166 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3167#ifndef WLAN_FEATURE_VOWIFI
3168 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3169 pSwitchChanParams->localPowerConstraint;
3170#endif
3171 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3172 pSwitchChanParams->secondaryChannelOffset;
3173 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3174 /* Store req pointer, as this will be used for response */
3175 /* store Params pass it to WDI */
3176 pWdaParams->pWdaContext = pWDA;
3177 pWdaParams->wdaMsgParam = pSwitchChanParams;
3178 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3179#ifdef WLAN_FEATURE_VOWIFI
3180 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3181 = pSwitchChanParams->maxTxPower;
3182 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3183 pSwitchChanParams ->selfStaMacAddr,
3184 sizeof(tSirMacAddr));
3185#endif
3186 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3187 pSwitchChanParams->bssId,
3188 sizeof(tSirMacAddr));
3189
3190 status = WDI_SwitchChReq(wdiSwitchChanParam,
3191 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3192 if(IS_WDI_STATUS_FAILURE(status))
3193 {
3194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3195 "Failure in process channel switch Req WDI API, free all the memory " );
3196 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3197 vos_mem_free(pWdaParams) ;
3198 pSwitchChanParams->status = eSIR_FAILURE ;
3199 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3200 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3201 return CONVERT_WDI2VOS_STATUS(status) ;
3202}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3203
3204/*
3205 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3206 * send Switch channel RSP back to PE
3207 */
3208void WDA_SwitchChannelReqCallback_V1(
3209 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3210 void* pUserData)
3211{
3212 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3213 tWDA_CbContext *pWDA;
3214 tSwitchChannelParams *pSwitchChanParams;
3215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3216 "<------ %s " ,__func__);
3217
3218 if (NULL == pWdaParams)
3219 {
3220 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3221 "%s: pWdaParams received NULL", __func__);
3222 VOS_ASSERT(0);
3223 return ;
3224 }
3225 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3226 pSwitchChanParams =
3227 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3228 pSwitchChanParams->channelSwitchSrc =
3229 wdiSwitchChanRsp->channelSwitchSrc;
3230#ifdef WLAN_FEATURE_VOWIFI
3231 pSwitchChanParams->txMgmtPower =
3232 wdiSwitchChanRsp->ucTxMgmtPower;
3233#endif
3234 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3235 vos_mem_free(pWdaParams);
3236 pSwitchChanParams->status =
3237 wdiSwitchChanRsp->wdiStatus ;
3238 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3239 (void *)pSwitchChanParams , 0);
3240 return;
3241}
3242
3243/*
3244 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3245 * Request to WDI to switch channel REQ params.
3246 */
3247VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3248 tSwitchChannelParams *pSwitchChanParams)
3249{
3250 WDI_Status status = WDI_STATUS_SUCCESS ;
3251 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3252 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3253 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3254 tWDA_ReqParams *pWdaParams ;
3255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3256 "------> %s " ,__func__);
3257 if (NULL == wdiSwitchChanParam)
3258 {
3259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3260 "%s: VOS MEM Alloc Failure", __func__);
3261 VOS_ASSERT(0);
3262 return VOS_STATUS_E_NOMEM;
3263 }
3264 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3265 if (NULL == pWdaParams)
3266 {
3267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3268 "%s: VOS MEM Alloc Failure", __func__);
3269 VOS_ASSERT(0);
3270 vos_mem_free(wdiSwitchChanParam);
3271 return VOS_STATUS_E_NOMEM;
3272 }
3273 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3274 pSwitchChanParams->channelSwitchSrc;
3275
3276 wdiSwitchChanParam->wdiChInfo.ucChannel =
3277 pSwitchChanParams->channelNumber;
3278#ifndef WLAN_FEATURE_VOWIFI
3279 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3280 pSwitchChanParams->localPowerConstraint;
3281#endif
3282 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3283 pSwitchChanParams->secondaryChannelOffset;
3284 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3285 /* Store req pointer, as this will be used for response */
3286 /* store Params pass it to WDI */
3287 pWdaParams->pWdaContext = pWDA;
3288 pWdaParams->wdaMsgParam = pSwitchChanParams;
3289 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3290#ifdef WLAN_FEATURE_VOWIFI
3291 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3292 pSwitchChanParams->maxTxPower;
3293 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3294 pSwitchChanParams ->selfStaMacAddr,
3295 sizeof(tSirMacAddr));
3296#endif
3297 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3298 pSwitchChanParams->bssId,
3299 sizeof(tSirMacAddr));
3300
3301 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3302 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3303 pWdaParams);
3304 if (IS_WDI_STATUS_FAILURE(status))
3305 {
3306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3307 "Failure in process channel switch Req WDI "
3308 "API, free all the memory " );
3309 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3310 vos_mem_free(pWdaParams) ;
3311 pSwitchChanParams->status = eSIR_FAILURE ;
3312 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3313 (void *)pSwitchChanParams, 0) ;
3314 }
3315 return CONVERT_WDI2VOS_STATUS(status) ;
3316}
3317
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3318/*
3319 * FUNCTION: WDA_ConfigBssReqCallback
3320 * config BSS Req Callback, called by WDI
3321 */
3322void WDA_ConfigBssReqCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
3323 ,void* pUserData)
3324{
3325 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3326 tWDA_CbContext *pWDA;
3327 tAddBssParams *configBssReqParam;
3328 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3330 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3331 if(NULL == pWdaParams)
3332 {
3333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3334 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3335 VOS_ASSERT(0) ;
3336 return ;
3337 }
3338 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3339 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3340 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3341 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3342 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3343 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3344 {
3345 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3346 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3347 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3348 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3349 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3350
3351 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3352 {
3353 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3354 {
3355 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3356 staConfigBssParam->staType = STA_ENTRY_BSSID;
3357 }
3358 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3359 (staConfigBssParam->staType == STA_ENTRY_SELF))
3360 {
3361 /* This is the 1st add BSS Req for the BTAMP STA */
3362 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3363 staConfigBssParam->staType = STA_ENTRY_BSSID;
3364 }
3365 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3366 (staConfigBssParam->staType == STA_ENTRY_PEER))
3367 {
3368 /* This is the 2nd ADD BSS Request that is sent
3369 * on the BTAMP STA side. The Sta type is
3370 * set to STA_ENTRY_PEER here.*/
3371 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3372 }
3373 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3374 (staConfigBssParam->staType == STA_ENTRY_SELF))
3375 {
3376 /* statype is already set by PE.
3377 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3378 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3379 staConfigBssParam->staType = STA_ENTRY_BSSID;
3380 }
3381 else
3382 {
3383 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3384 staConfigBssParam->staType = STA_ENTRY_PEER;
3385 }
3386 }
3387 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3388 {
3389 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3390 staConfigBssParam->staType = STA_ENTRY_SELF;
3391 }
3392 else
3393 {
3394 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3395 "Invalid operation mode specified");
3396 VOS_ASSERT(0);
3397 }
3398
3399 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3400 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3401 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3402 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3403 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3404 sizeof(tSirMacAddr));
3405 staConfigBssParam->txChannelWidthSet =
3406 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3407 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3408 staConfigBssParam->htCapable)
3409 {
3410 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3411 wdiConfigBssRsp->ucBSSIdx;
3412 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3413 WDA_VALID_STA_INDEX ;
3414 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3415 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3416 wdiConfigBssRsp->ucBSSIdx,
3417 wdiConfigBssRsp->ucSTAIdx))
3418 {
3419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3420 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3421 VOS_ASSERT(0) ;
3422 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3423 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3424 {
3425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3426 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3427 VOS_ASSERT(0) ;
3428 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3429#ifdef WLAN_FEATURE_VOWIFI
3430 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3431#endif
3432 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3433 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3434 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3435 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3436 return ;
3437}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3438/*
3439 * FUNCTION: WDA_UpdateEdcaParamsForAC
3440 * Update WDI EDCA params with PE edca params
3441 */
3442void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3443 WDI_EdcaParamRecord *wdiEdcaParam,
3444 tSirMacEdcaParamRecord *macEdcaParam)
3445{
3446 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3447 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3448 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3449 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3450 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3451 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3452}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3453/*
3454 * FUNCTION: WDA_ProcessConfigBssReq
3455 * Configure BSS before starting Assoc with AP
3456 */
3457VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3458 tAddBssParams* configBssReqParam)
3459{
3460 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3461 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3462 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3464 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3465 if (NULL == configBssReqParam)
3466 {
3467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3468 "%s: configBssReqParam is NULL", __func__);
3469 return VOS_STATUS_E_INVAL;
3470 }
3471
3472 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3473 sizeof(WDI_ConfigBSSReqParamsType)) ;
3474
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3475 if(NULL == wdiConfigBssReqParam)
3476 {
3477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3478 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3479 VOS_ASSERT(0);
3480 return VOS_STATUS_E_NOMEM;
3481 }
3482 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3483 if(NULL == pWdaParams)
3484 {
3485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3486 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3487 VOS_ASSERT(0);
3488 vos_mem_free(wdiConfigBssReqParam);
3489 return VOS_STATUS_E_NOMEM;
3490 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3492 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3493 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3494 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3495 configBssReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3496 /* Store Init Req pointer, as this will be used for response */
3497 /* store Params pass it to WDI */
3498 pWdaParams->pWdaContext = pWDA;
3499 pWdaParams->wdaMsgParam = configBssReqParam;
3500 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3501 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
3502 (WDI_ConfigBSSRspCb )WDA_ConfigBssReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3503 if(IS_WDI_STATUS_FAILURE(status))
3504 {
3505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3506 "Failure in Config BSS WDI API, free all the memory " );
3507 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3508 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3509 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3510 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3511 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3512 return CONVERT_WDI2VOS_STATUS(status) ;
3513}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3514#ifdef ENABLE_HAL_COMBINED_MESSAGES
3515/*
3516 * FUNCTION: WDA_PostAssocReqCallback
3517 * Post ASSOC req callback, send RSP back to PE
3518 */
3519void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3520 void* pUserData)
3521{
3522 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3523 tPostAssocParams *postAssocReqParam =
3524 (tPostAssocParams *)pWDA->wdaMsgParam ;
3525 /*STA context within the BSS Params*/
3526 tAddStaParams *staPostAssocParam =
3527 &postAssocReqParam->addBssParams.staContext ;
3528 /*STA Params for self STA*/
3529 tAddStaParams *selfStaPostAssocParam =
3530 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3531 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3532 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3533 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3534 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3535 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3536 {
3537 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3538 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3539 sizeof(tSirMacAddr)) ;
3540 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3541 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3542 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3543 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3544 }
3545 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3546 pWDA->wdaWdiApiMsgParam = NULL;
3547 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3548 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3549 return ;
3550}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3551/*
3552 * FUNCTION: WDA_ProcessPostAssocReq
3553 * Trigger POST ASSOC processing in WDI
3554 */
3555VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3556 tPostAssocParams *postAssocReqParam)
3557{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3558 WDI_Status status = WDI_STATUS_SUCCESS ;
3559
3560 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3561 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3562 sizeof(WDI_PostAssocReqParamsType)) ;
3563 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3564 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3565
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3566 if(NULL == wdiPostAssocReqParam)
3567 {
3568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3569 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3570 VOS_ASSERT(0);
3571 return VOS_STATUS_E_NOMEM;
3572 }
3573
3574 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3575 {
3576 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3577 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3578 VOS_ASSERT(0);
3579 return VOS_STATUS_E_FAILURE;
3580 }
3581
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3582 /* update BSS params into WDI structure */
3583 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3584 &postAssocReqParam->addBssParams) ;
3585 /* update STA params into WDI structure */
3586 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3587 &postAssocReqParam->addStaParams) ;
3588
3589 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
3590 postAssocReqParam->addBssParams.highPerformance;
3591 WDA_UpdateEdcaParamsForAC(pWDA,
3592 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
3593 &postAssocReqParam->addBssParams.acbe);
3594 WDA_UpdateEdcaParamsForAC(pWDA,
3595 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
3596 &postAssocReqParam->addBssParams.acbk);
3597 WDA_UpdateEdcaParamsForAC(pWDA,
3598 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
3599 &postAssocReqParam->addBssParams.acvi);
3600 WDA_UpdateEdcaParamsForAC(pWDA,
3601 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
3602 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3603 /* Store Init Req pointer, as this will be used for response */
3604 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3605 /* store Params pass it to WDI */
3606 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3607 status = WDI_PostAssocReq(wdiPostAssocReqParam,
3608 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3609 if(IS_WDI_STATUS_FAILURE(status))
3610 {
3611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3612 "Failure in Post Assoc WDI API, free all the memory " );
3613 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3614 pWDA->wdaWdiApiMsgParam = NULL;
3615 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3616 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3617 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
3618 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3619 return CONVERT_WDI2VOS_STATUS(status) ;
3620}
3621#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3622/*
3623 * FUNCTION: WDA_AddStaReqCallback
3624 * ADD STA req callback, send RSP back to PE
3625 */
3626void WDA_AddStaReqCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
3627 void* pUserData)
3628{
3629 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3630 tWDA_CbContext *pWDA;
3631 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3633 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3634 if(NULL == pWdaParams)
3635 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3636 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]3637 VOS_ASSERT(0) ;
3638 return ;
3639 }
3640 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3641 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3642 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3643 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3644 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
3645 {
3646 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
3647 /*TODO: UMAC structure doesn't have these fields*/
3648 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
3649 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
3650 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
3651 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
3652 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
3653 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3654#ifdef FEATURE_WLAN_TDLS
3655 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
3656 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
3657#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3658 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3659#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3660 {
3661 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
3662 wdiConfigStaRsp->ucBssIdx;
3663 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
3664 WDA_VALID_STA_INDEX ;
3665 }
3666 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
3667 {
3668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3669 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3670 VOS_ASSERT(0) ;
3671 return ;
3672 }
3673 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3674 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3675 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3676 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3677 return ;
3678}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3679/*
3680 * FUNCTION: WDA_ConfigStaReq
3681 * Trigger Config STA processing in WDI
3682 */
3683VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
3684 tAddStaParams *addStaReqParam)
3685{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3686 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3687 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
3688 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
3689 sizeof(WDI_ConfigSTAReqParamsType)) ;
3690 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3692 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3693 if(NULL == wdiConfigStaReqParam)
3694 {
3695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3696 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3697 VOS_ASSERT(0);
3698 return VOS_STATUS_E_NOMEM;
3699 }
3700 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3701 if(NULL == pWdaParams)
3702 {
3703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3704 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3705 VOS_ASSERT(0);
3706 vos_mem_free(wdiConfigStaReqParam);
3707 return VOS_STATUS_E_NOMEM;
3708 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3709 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3710 /* update STA params into WDI structure */
3711 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
3712 addStaReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3713 /* Store Init Req pointer, as this will be used for response */
3714 /* store Params pass it to WDI */
3715 pWdaParams->pWdaContext = pWDA;
3716 pWdaParams->wdaMsgParam = addStaReqParam;
3717 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3718 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
3719 (WDI_ConfigSTARspCb )WDA_AddStaReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3720 if(IS_WDI_STATUS_FAILURE(status))
3721 {
3722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3723 "Failure in Config STA WDI API, free all the memory " );
3724 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3725 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3726 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3727 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
3728 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3729 return CONVERT_WDI2VOS_STATUS(status) ;
3730}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3731/*
3732 * FUNCTION: WDA_DelBSSReqCallback
3733 * Dens DEL BSS RSP back to PE
3734 */
3735void WDA_DelBSSReqCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
3736 void* pUserData)
3737{
3738 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3739 tWDA_CbContext *pWDA;
3740 tDeleteBssParams *delBssReqParam;
3741 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3743 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3744 if(NULL == pWdaParams)
3745 {
3746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3747 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3748 VOS_ASSERT(0) ;
3749 return ;
3750 }
3751 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3752 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3753 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3754 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
3755 {
3756 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
3757 sizeof(tSirMacAddr)) ;
3758 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3759 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
3760 {
3761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3762 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3763 VOS_ASSERT(0) ;
3764 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3765 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
3766 {
3767 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3768 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3769 VOS_ASSERT(0) ;
3770 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3771 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
3772 {
3773 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3774 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3775 VOS_ASSERT(0) ;
3776 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3777
3778 WLANTL_StartForwarding(staIdx,0,0);
3779
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3780 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3781 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3782 /* reset the the system role*/
3783 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
3784
3785 /* Reset the BA related information */
3786 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
3787 {
3788 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
3789 {
3790 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
3791 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
3792 /* Reset framesTxed counters here */
3793 for(tid = 0; tid < STACFG_MAX_TC; tid++)
3794 {
3795 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
3796 }
3797 }
3798 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3799 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3800 return ;
3801}
3802
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3803/*
3804 * FUNCTION: WDA_ProcessDelBssReq
3805 * Init DEL BSS req with WDI
3806 */
3807VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
3808 tDeleteBssParams *delBssParam)
3809{
3810 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3811 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
3812 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
3813 sizeof(WDI_DelBSSReqParamsType)) ;
3814 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3816 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3817 if(NULL == wdiDelBssReqParam)
3818 {
3819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3820 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3821 VOS_ASSERT(0);
3822 return VOS_STATUS_E_NOMEM;
3823 }
3824 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3825 if(NULL == pWdaParams)
3826 {
3827 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3828 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3829 VOS_ASSERT(0);
3830 vos_mem_free(wdiDelBssReqParam);
3831 return VOS_STATUS_E_NOMEM;
3832 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3833 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
3834 wdiDelBssReqParam->wdiReqStatusCB = NULL ;
3835
3836 /* Store Init Req pointer, as this will be used for response */
3837 /* store Params pass it to WDI */
3838 pWdaParams->pWdaContext = pWDA;
3839 pWdaParams->wdaMsgParam = delBssParam;
3840 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3841 status = WDI_DelBSSReq(wdiDelBssReqParam,
3842 (WDI_DelBSSRspCb )WDA_DelBSSReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3843 if(IS_WDI_STATUS_FAILURE(status))
3844 {
3845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3846 "Failure in Del BSS WDI API, free all the memory " );
3847 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3848 vos_mem_free(pWdaParams) ;
3849 delBssParam->status = eSIR_FAILURE ;
3850 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
3851 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3852 return CONVERT_WDI2VOS_STATUS(status) ;
3853}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3854/*
3855 * FUNCTION: WDA_DelSTAReqCallback
3856 * Dens DEL STA RSP back to PE
3857 */
3858void WDA_DelSTAReqCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
3859 void* pUserData)
3860{
3861 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3862 tWDA_CbContext *pWDA;
3863 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3865 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3866 if(NULL == pWdaParams)
3867 {
3868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3869 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3870 VOS_ASSERT(0) ;
3871 return ;
3872 }
3873 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3874 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3875 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3876 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
3877 {
3878 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
3879 {
3880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3881 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3882 VOS_ASSERT(0) ;
3883 }
3884 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3885 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3886 }
3887 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3888 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3889 /*Reset the BA information corresponding to this STAIdx */
3890 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
3891 WDA_INVALID_STA_INDEX;
3892 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
3893
3894 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3895 return ;
3896}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3897/*
3898 * FUNCTION: WDA_ProcessDelStaReq
3899 * Init DEL STA req with WDI
3900 */
3901VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
3902 tDeleteStaParams *delStaParam)
3903{
3904 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3905 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
3906 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
3907 sizeof(WDI_DelSTAReqParamsType)) ;
3908 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3910 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3911 if(NULL == wdiDelStaReqParam)
3912 {
3913 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3914 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3915 VOS_ASSERT(0);
3916 return VOS_STATUS_E_NOMEM;
3917 }
3918 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3919 if(NULL == pWdaParams)
3920 {
3921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3922 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3923 VOS_ASSERT(0);
3924 vos_mem_free(wdiDelStaReqParam);
3925 return VOS_STATUS_E_NOMEM;
3926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3927 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
3928 wdiDelStaReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3929 /* Store Init Req pointer, as this will be used for response */
3930 /* store Params pass it to WDI */
3931 pWdaParams->pWdaContext = pWDA;
3932 pWdaParams->wdaMsgParam = delStaParam;
3933 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3934 status = WDI_DelSTAReq(wdiDelStaReqParam,
3935 (WDI_DelSTARspCb )WDA_DelSTAReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3936 if(IS_WDI_STATUS_FAILURE(status))
3937 {
3938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3939 "Failure in Del STA WDI API, free all the memory status = %d",
3940 status );
3941 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3942 vos_mem_free(pWdaParams) ;
3943 delStaParam->status = eSIR_FAILURE ;
3944 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
3945 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3946 return CONVERT_WDI2VOS_STATUS(status) ;
3947}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3948void WDA_ProcessAddStaSelfRsp(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
3949{
3950 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3951 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3952 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3954 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3955 if(NULL == pWdaParams)
3956 {
3957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3958 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3959 VOS_ASSERT(0) ;
3960 return ;
3961 }
3962 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3963 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3964 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3965 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3966 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
3967 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
3968 pwdiAddSTASelfRsp->macSelfSta,
3969 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3970 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
3971 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
3972 if (pAddStaSelfRsp->status == eSIR_FAILURE)
3973 {
3974 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
3975 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
3976 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3977 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3978 return ;
3979}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3980
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3981/*
3982 * FUNCTION: WDA_ProcessAddStaSelfReq
3983 *
3984 */
3985VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
3986{
3987 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3988 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3989 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
3990 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
3991 sizeof(WDI_AddSTASelfReqParamsType)) ;
3992 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3994 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3995 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3996 if( NULL == wdiAddStaSelfReq )
3997 {
3998 VOS_ASSERT( 0 );
3999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4000 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4001 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4002 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4003 return( VOS_STATUS_E_NOMEM );
4004 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4005 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4006 if( NULL == pWdaParams )
4007 {
4008 VOS_ASSERT( 0 );
4009 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4010 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4011 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4012 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4013 vos_mem_free(wdiAddStaSelfReq) ;
4014 return( VOS_STATUS_E_NOMEM );
4015 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4016 wdiAddStaSelfReq->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4017 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]4018 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4019 /* Store Init Req pointer, as this will be used for response */
4020 /* store Params pass it to WDI */
4021 pWdaParams->pWdaContext = pWDA;
4022 pWdaParams->wdaMsgParam = pAddStaSelfReq;
4023 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4024 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq, WDA_ProcessAddStaSelfRsp, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4025
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4026 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4027 {
4028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4029 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4030 wstatus );
4031 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4032 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4033 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4034 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
4035 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4036 pAddStaSelfReq->status = eSIR_FAILURE ;
4037 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
4038 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4039 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4040}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4041/*
4042 * FUNCTION: WDA_DelSTASelfRespCallback
4043 *
4044 */
4045void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4046 wdiDelStaSelfRspParams , void* pUserData)
4047{
4048 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4049 tWDA_CbContext *pWDA;
4050 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4052 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4053 if (NULL == pWdaParams)
4054 {
4055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4056 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4057 VOS_ASSERT(0);
4058 return;
4059 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4060 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4061 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4062 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4063 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4064
4065 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4066 vos_mem_free(pWdaParams) ;
4067
4068 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4069 return ;
4070}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4071/*
4072 * FUNCTION: WDA_DelSTASelfReqCallback
4073 *
4074 */
4075void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4076 void* pUserData)
4077{
4078 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4079 tWDA_CbContext *pWDA;
4080 tDelStaSelfParams *delStaSelfParams;
4081
4082 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4083 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4084 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4085
4086 if (NULL == pWdaParams)
4087 {
4088 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4089 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4090 VOS_ASSERT(0);
4091 return;
4092 }
4093
4094 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4095 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4096
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4097 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4098
4099 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4100 {
4101 VOS_ASSERT(0);
4102 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4103 vos_mem_free(pWdaParams) ;
4104 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4105 }
4106
4107 return ;
4108}
4109
4110/*
4111 * FUNCTION: WDA_DelSTASelfReq
4112 * Trigger Config STA processing in WDI
4113 */
4114VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4115 tDelStaSelfParams* pDelStaSelfReqParam)
4116{
4117 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4118 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4119 tWDA_ReqParams *pWdaParams = NULL;
4120 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4121 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4122 sizeof(WDI_DelSTASelfReqParamsType)) ;
4123
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4124 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4125 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4126 if( NULL == wdiDelStaSelfReq )
4127 {
4128 VOS_ASSERT( 0 );
4129 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4130 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4131 return( VOS_STATUS_E_NOMEM );
4132 }
4133
4134 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4135 if( NULL == pWdaParams )
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__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4140 vos_mem_free(wdiDelStaSelfReq) ;
4141 return( VOS_STATUS_E_NOMEM );
4142 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4143 pWdaParams->pWdaContext = pWDA;
4144 /* Store param pointer as passed in by caller */
4145 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4146 /* store Params pass it to WDI */
4147 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4148 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4149 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4150
4151 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4152 wdiDelStaSelfReq->pUserData = pWdaParams;
4153
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4154 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4155 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4156
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4157 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4158 {
4159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4160 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4161 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4162 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4163 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4164 vos_mem_free(pWdaParams) ;
4165 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4166 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4167 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4168 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4169}
4170
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4171/*
4172 * FUNCTION: WDA_SendMsg
4173 * Send Message back to PE
4174 */
4175void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4176 void *pBodyptr, tANI_U32 bodyVal)
4177{
4178 tSirMsgQ msg = {0} ;
4179 tANI_U32 status = VOS_STATUS_SUCCESS ;
4180 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4181 msg.type = msgType;
4182 msg.bodyval = bodyVal;
4183 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4184 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4185 if (VOS_STATUS_SUCCESS != status)
4186 {
4187 if(NULL != pBodyptr)
4188 {
4189 vos_mem_free(pBodyptr);
4190 }
4191 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4192 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4193 VOS_ASSERT(0) ;
4194 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4195 return ;
4196}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4197/*
4198 * FUNCTION: WDA_UpdateBSSParams
4199 * Translated WDA/PE BSS info into WDI BSS info..
4200 */
4201void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4202 WDI_ConfigBSSReqInfoType *wdiBssParams,
4203 tAddBssParams *wdaBssParams)
4204{
4205 v_U8_t keyIndex = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4206 /* copy bssReq Params to WDI structure */
4207 vos_mem_copy(wdiBssParams->macBSSID,
4208 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4209 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4210 sizeof(tSirMacAddr)) ;
4211 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4212 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4213 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4214 wdiBssParams->ucShortSlotTimeSupported =
4215 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4216 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4217 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4218 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4219 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4220 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4221
4222 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4223 wdiBssParams->ucTXOPProtectionFullSupport =
4224 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4225 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4226 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4227 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4228 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4229 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4230 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4231 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4232
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4233 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4234
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4235 /* copy SSID into WDI structure */
4236 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4237 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4238 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4239 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4240 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4241 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4242#ifdef WLAN_FEATURE_VOWIFI
4243 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4244#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4245 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4246 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4247#ifdef WLAN_FEATURE_VOWIFI_11R
4248 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4249 if(wdiBssParams->bExtSetStaKeyParamValid)
4250 {
4251 /* copy set STA key params to WDI structure */
4252 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4253 wdaBssParams->extSetStaKeyParam.staIdx;
4254 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4255 wdaBssParams->extSetStaKeyParam.encType;
4256 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4257 wdaBssParams->extSetStaKeyParam.wepType;
4258 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4259 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4260 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4261 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4262 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4263 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4264 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4265 {
4266 WDA_GetWepKeysFromCfg( pWDA,
4267 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4268 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4269 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4270 }
4271 else
4272 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4273 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4274 keyIndex++)
4275 {
4276 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4277 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4278 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4279 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4280 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4281 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4282 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4283 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4284 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4285 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4286 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4287 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
4288 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4289 wdaBssParams->extSetStaKeyParam.key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4290 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4291 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
4292 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4293 }
4294 }
4295 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4296 }
4297 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4298 {
4299 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4300 sizeof(wdaBssParams->extSetStaKeyParam) );
4301 }
4302#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4303#ifdef WLAN_FEATURE_11AC
4304 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4305 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4306#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4307
4308 return ;
4309}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4310/*
4311 * FUNCTION: WDA_UpdateSTAParams
4312 * Translated WDA/PE BSS info into WDI BSS info..
4313 */
4314void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4315 WDI_ConfigStaReqInfoType *wdiStaParams,
4316 tAddStaParams *wdaStaParams)
4317{
4318 tANI_U8 i = 0;
4319 /* Update STA params */
4320 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4321 sizeof(tSirMacAddr)) ;
4322 wdiStaParams->usAssocId = wdaStaParams->assocId;
4323 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4324 wdiStaParams->staIdx = wdaStaParams->staIdx;
4325
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4326 wdiStaParams->ucShortPreambleSupported =
4327 wdaStaParams->shortPreambleSupported;
4328 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4329 sizeof(tSirMacAddr)) ;
4330 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4331
4332 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4333
4334 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4335 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4336 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4337 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
4338 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
4339 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
4340 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
4341
4342 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
4343 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4344 wdiStaParams->wdiSupportedRates.opRateMode =
4345 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4346 for(i = 0;i < WDI_NUM_11B_RATES;i++)
4347 {
4348 wdiStaParams->wdiSupportedRates.llbRates[i] =
4349 wdaStaParams->supportedRates.llbRates[i];
4350 }
4351 for(i = 0;i < WDI_NUM_11A_RATES;i++)
4352 {
4353 wdiStaParams->wdiSupportedRates.llaRates[i] =
4354 wdaStaParams->supportedRates.llaRates[i];
4355 }
4356 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
4357 {
4358 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
4359 wdaStaParams->supportedRates.aniLegacyRates[i];
4360 }
4361 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
4362 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4363#ifdef WLAN_FEATURE_11AC
4364 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
4365 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
4366 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
4367 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
4368#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4369 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
4370 {
4371 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
4372 wdaStaParams->supportedRates.supportedMCSSet[i];
4373 }
4374 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
4375 wdaStaParams->supportedRates.rxHighestDataRate;
4376
4377 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
4378
4379 wdiStaParams->wdiAction = wdaStaParams->updateSta;
4380
4381 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
4382 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
4383 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
4384
4385 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
4386 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
4387 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
4388 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4389 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4390#ifdef WLAN_FEATURE_11AC
4391 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
4392 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]4393 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]4394 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
4395 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
4396 * must be set by default */
4397 if ( wdiStaParams->vhtTxMUBformeeCapable )
4398 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4399#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]4400 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
4401 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4402 return ;
4403}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4404/*
4405 * -------------------------------------------------------------------------
4406 * CFG update to WDI
4407 * -------------------------------------------------------------------------
4408 */
4409
4410 /*
4411 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
4412 * Convert the WNI CFG ID to HAL CFG ID
4413 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4414static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4415{
4416 switch(wniCfgId)
4417 {
4418 case WNI_CFG_STA_ID:
4419 return QWLAN_HAL_CFG_STA_ID;
4420 case WNI_CFG_CURRENT_TX_ANTENNA:
4421 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
4422 case WNI_CFG_CURRENT_RX_ANTENNA:
4423 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
4424 case WNI_CFG_LOW_GAIN_OVERRIDE:
4425 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
4426 case WNI_CFG_POWER_STATE_PER_CHAIN:
4427 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
4428 case WNI_CFG_CAL_PERIOD:
4429 return QWLAN_HAL_CFG_CAL_PERIOD;
4430 case WNI_CFG_CAL_CONTROL:
4431 return QWLAN_HAL_CFG_CAL_CONTROL;
4432 case WNI_CFG_PROXIMITY:
4433 return QWLAN_HAL_CFG_PROXIMITY;
4434 case WNI_CFG_NETWORK_DENSITY:
4435 return QWLAN_HAL_CFG_NETWORK_DENSITY;
4436 case WNI_CFG_MAX_MEDIUM_TIME:
4437 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
4438 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
4439 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
4440 case WNI_CFG_RTS_THRESHOLD:
4441 return QWLAN_HAL_CFG_RTS_THRESHOLD;
4442 case WNI_CFG_SHORT_RETRY_LIMIT:
4443 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
4444 case WNI_CFG_LONG_RETRY_LIMIT:
4445 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
4446 case WNI_CFG_FRAGMENTATION_THRESHOLD:
4447 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
4448 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
4449 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
4450 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
4451 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
4452 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
4453 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
4454 case WNI_CFG_FIXED_RATE:
4455 return QWLAN_HAL_CFG_FIXED_RATE;
4456 case WNI_CFG_RETRYRATE_POLICY:
4457 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
4458 case WNI_CFG_RETRYRATE_SECONDARY:
4459 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
4460 case WNI_CFG_RETRYRATE_TERTIARY:
4461 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
4462 case WNI_CFG_FORCE_POLICY_PROTECTION:
4463 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
4464 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
4465 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
4466 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
4467 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
4468 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
4469 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
4470 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
4471 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
4472 case WNI_CFG_MAX_BA_SESSIONS:
4473 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
4474 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
4475 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
4476 case WNI_CFG_PS_ENABLE_BCN_FILTER:
4477 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
4478 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
4479 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
4480 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
4481 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
4482 case WNI_CFG_STATS_PERIOD:
4483 return QWLAN_HAL_CFG_STATS_PERIOD;
4484 case WNI_CFG_CFP_MAX_DURATION:
4485 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
4486#if 0 /*This is not part of CFG*/
4487 case WNI_CFG_FRAME_TRANS_ENABLED:
4488 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
4489#endif
4490 case WNI_CFG_DTIM_PERIOD:
4491 return QWLAN_HAL_CFG_DTIM_PERIOD;
4492 case WNI_CFG_EDCA_WME_ACBK:
4493 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
4494 case WNI_CFG_EDCA_WME_ACBE:
4495 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
4496 case WNI_CFG_EDCA_WME_ACVI:
4497 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
4498 case WNI_CFG_EDCA_WME_ACVO:
4499 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
4500#if 0
4501 case WNI_CFG_TELE_BCN_WAKEUP_EN:
4502 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
4503 case WNI_CFG_TELE_BCN_TRANS_LI:
4504 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
4505 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
4506 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
4507 case WNI_CFG_TELE_BCN_MAX_LI:
4508 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
4509 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
4510 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
4511#endif
4512 case WNI_CFG_ENABLE_CLOSE_LOOP:
4513 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]4514 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
4515 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4516 default:
4517 {
4518 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4519 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4520 wniCfgId);
4521 return VOS_STATUS_E_INVAL;
4522 }
4523 }
4524}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4525/*
4526 * FUNCTION: WDA_UpdateCfgCallback
4527 *
4528 */
4529void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
4530{
4531 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4532 WDI_UpdateCfgReqParamsType *wdiCfgParam =
4533 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4535 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4536 /*
4537 * currently there is no response message is expected between PE and
4538 * WDA, Failure return from WDI is a ASSERT condition
4539 */
4540 if(WDI_STATUS_SUCCESS != wdiStatus)
4541 {
4542 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4543 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4544 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
4545 }
4546
4547 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
4548 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4549 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4550 return ;
4551}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4552/*
4553 * FUNCTION: WDA_UpdateCfg
4554 *
4555 */
4556VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
4557{
4558
4559 WDI_Status status = WDI_STATUS_SUCCESS ;
4560 tANI_U32 val =0;
4561 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
4562 tHalCfg *configData;
4563 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
4564 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4565 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4566 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4567 if (NULL == pMac )
4568 {
4569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4570 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4571 return VOS_STATUS_E_FAILURE;
4572 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4573 if(WDA_START_STATE != pWDA->wdaState)
4574 {
4575 return VOS_STATUS_E_FAILURE;
4576 }
4577
4578 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
4579 {
4580 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4581 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4582 VOS_ASSERT(0);
4583 return VOS_STATUS_E_FAILURE;
4584 }
4585
4586 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
4587 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4588 if(NULL == wdiCfgReqParam)
4589 {
4590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4591 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4592 VOS_ASSERT(0);
4593 return VOS_STATUS_E_NOMEM;
4594 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4595 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
4596 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4597 if(NULL == wdiCfgReqParam->pConfigBuffer)
4598 {
4599 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4600 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4601 vos_mem_free(wdiCfgReqParam);
4602 VOS_ASSERT(0);
4603 return VOS_STATUS_E_NOMEM;
4604 }
4605
4606 /*convert the WNI CFG Id to HAL CFG Id*/
4607 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
4608 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
4609
4610 /*TODO: revisit this for handling string parameters */
4611 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
4612 &val) != eSIR_SUCCESS)
4613 {
4614 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4615 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4616 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
4617 vos_mem_free(wdiCfgReqParam);
4618 return eSIR_FAILURE;
4619 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4620 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
4621 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
4622 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
4623 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
4624 wdiCfgReqParam->wdiReqStatusCB = NULL ;
4625
4626 /* store Params pass it to WDI */
4627 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4628#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
4629 status = WDI_UpdateCfgReq(wdiCfgReqParam,
4630 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4631 if(IS_WDI_STATUS_FAILURE(status))
4632 {
4633 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4634 "Failure in Update CFG WDI API, free all the memory " );
4635 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4636 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4637 pWDA->wdaWdiCfgApiMsgParam = NULL;
4638 /* Failure is not expected */
4639 VOS_ASSERT(0) ;
4640 }
4641#else
4642 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4643 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4644 pWDA->wdaWdiCfgApiMsgParam = NULL;
4645#endif
4646 return CONVERT_WDI2VOS_STATUS(status) ;
4647}
4648
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4649VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
4650 v_U8_t *pDefaultKeyId,
4651 v_U8_t *pNumKeys,
4652 WDI_KeysType *pWdiKeys )
4653{
4654 v_U32_t i, j, defKeyId = 0;
4655 v_U32_t val = SIR_MAC_KEY_LENGTH;
4656 VOS_STATUS status = WDI_STATUS_SUCCESS;
4657 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4658 if (NULL == pMac )
4659 {
4660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4661 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4662 return VOS_STATUS_E_FAILURE;
4663 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4664 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
4665 &defKeyId ))
4666 {
4667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4668 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
4669 }
4670
4671 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4672 /* Need to extract ALL of the configured WEP Keys */
4673 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
4674 {
4675 val = SIR_MAC_KEY_LENGTH;
4676 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
4677 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
4678 pWdiKeys[j].key,
4679 &val ))
4680 {
4681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4682 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4683 }
4684 else
4685 {
4686 pWdiKeys[j].keyId = (tANI_U8) i;
4687 /*
4688 * Actually, a DC (Don't Care) because
4689 * this is determined (and set) by PE/MLME
4690 */
4691 pWdiKeys[j].unicast = 0;
4692 /*
4693 * Another DC (Don't Care)
4694 */
4695 pWdiKeys[j].keyDirection = eSIR_TX_RX;
4696 /* Another DC (Don't Care). Unused for WEP */
4697 pWdiKeys[j].paeRole = 0;
4698 /* Determined from wlan_cfgGetStr() above.*/
4699 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4700 j++;
4701 *pNumKeys = (tANI_U8) j;
4702 }
4703 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4704 return status;
4705}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4706/*
4707 * FUNCTION: WDA_SetBssKeyReqCallback
4708 * send SET BSS key RSP back to PE
4709 */
4710void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
4711{
4712 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4713 tWDA_CbContext *pWDA;
4714 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4715 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4716 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4717 if(NULL == pWdaParams)
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: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4721 VOS_ASSERT(0) ;
4722 return ;
4723 }
4724 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4725 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4726 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4727 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4728 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4729 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4730 return ;
4731}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4732/*
4733 * FUNCTION: WDA_ProcessSetBssKeyReq
4734 * Request to WDI for programming the BSS key( key for
4735 * broadcast/multicast frames Encryption)
4736 */
4737VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
4738 tSetBssKeyParams *setBssKeyParams )
4739{
4740 WDI_Status status = WDI_STATUS_SUCCESS ;
4741 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
4742 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
4743 sizeof(WDI_SetBSSKeyReqParamsType)) ;
4744 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4745 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4747 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4748 if(NULL == wdiSetBssKeyParam)
4749 {
4750 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4751 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4752 VOS_ASSERT(0);
4753 return VOS_STATUS_E_NOMEM;
4754 }
4755 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4756 if(NULL == pWdaParams)
4757 {
4758 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4759 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4760 VOS_ASSERT(0);
4761 vos_mem_free(wdiSetBssKeyParam);
4762 return VOS_STATUS_E_NOMEM;
4763 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4764 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4765 /* copy set BSS params to WDI structure */
4766 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
4767 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
4768 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4769 if(setBssKeyParams->encType != eSIR_ED_NONE)
4770 {
4771 if( setBssKeyParams->numKeys == 0 &&
4772 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
4773 setBssKeyParams->encType == eSIR_ED_WEP104))
4774 {
4775 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4776 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
4777 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
4778 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
4779 }
4780 else
4781 {
4782 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
4783 {
4784 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
4785 setBssKeyParams->key[keyIndex].keyId;
4786 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
4787 setBssKeyParams->key[keyIndex].unicast;
4788 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
4789 setBssKeyParams->key[keyIndex].keyDirection;
4790 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
4791 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4792 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
4793 setBssKeyParams->key[keyIndex].paeRole;
4794 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
4795 setBssKeyParams->key[keyIndex].keyLength;
4796 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
4797 setBssKeyParams->key[keyIndex].key,
4798 SIR_MAC_MAX_KEY_LENGTH);
4799 }
4800 }
4801 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4802 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
4803 setBssKeyParams->singleTidRc;
4804 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4805 /* Store set key pointer, as this will be used for response */
4806 /* store Params pass it to WDI */
4807 pWdaParams->pWdaContext = pWDA;
4808 pWdaParams->wdaMsgParam = setBssKeyParams;
4809 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4810 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
4811 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
4812
4813 if(IS_WDI_STATUS_FAILURE(status))
4814 {
4815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4816 "Failure in Set BSS Key Req WDI API, free all the memory " );
4817 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4818 vos_mem_free(pWdaParams) ;
4819 setBssKeyParams->status = eSIR_FAILURE ;
4820 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
4821 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4822 return CONVERT_WDI2VOS_STATUS(status) ;
4823}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4824/*
4825 * FUNCTION: WDA_RemoveBssKeyReqCallback
4826 * send SET BSS key RSP back to PE
4827 */
4828void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
4829{
4830 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4831 tWDA_CbContext *pWDA;
4832 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4834 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4835 if(NULL == pWdaParams)
4836 {
4837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4838 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4839 VOS_ASSERT(0) ;
4840 return ;
4841 }
4842 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4843 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4844 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4845 vos_mem_free(pWdaParams) ;
4846
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4847 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4848 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4849 return ;
4850}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4851/*
4852 * FUNCTION: WDA_ProcessRemoveBssKeyReq
4853 * Request to WDI to remove the BSS key( key for broadcast/multicast
4854 * frames Encryption)
4855 */
4856VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
4857 tRemoveBssKeyParams *removeBssKeyParams )
4858{
4859 WDI_Status status = WDI_STATUS_SUCCESS ;
4860 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
4861 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
4862 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
4863 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4865 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4866 if(NULL == wdiRemoveBssKeyParam)
4867 {
4868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4869 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4870 VOS_ASSERT(0);
4871 return VOS_STATUS_E_NOMEM;
4872 }
4873 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4874 if(NULL == pWdaParams)
4875 {
4876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4877 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4878 VOS_ASSERT(0);
4879 vos_mem_free(wdiRemoveBssKeyParam);
4880 return VOS_STATUS_E_NOMEM;
4881 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4882 /* copy Remove BSS key params to WDI structure*/
4883 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
4884 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
4885 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
4886 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
4887 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4888 /* Store remove key pointer, as this will be used for response */
4889 /* store Params pass it to WDI */
4890 pWdaParams->pWdaContext = pWDA;
4891 pWdaParams->wdaMsgParam = removeBssKeyParams;
4892 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4893 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
4894 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4895 if(IS_WDI_STATUS_FAILURE(status))
4896 {
4897 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4898 "Failure in Remove BSS Key Req WDI API, free all the memory " );
4899 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4900 vos_mem_free(pWdaParams) ;
4901 removeBssKeyParams->status = eSIR_FAILURE ;
4902 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
4903 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4904 return CONVERT_WDI2VOS_STATUS(status) ;
4905}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4906/*
4907 * FUNCTION: WDA_SetBssKeyReqCallback
4908 * send SET BSS key RSP back to PE
4909 */
4910void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
4911{
4912 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4913 tWDA_CbContext *pWDA;
4914 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4915 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4916 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4917 if(NULL == pWdaParams)
4918 {
4919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4920 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4921 VOS_ASSERT(0) ;
4922 return ;
4923 }
4924 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4925 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4926 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4927 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4928 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4929 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4930 return ;
4931}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4932/*
4933 * FUNCTION: WDA_ProcessSetStaKeyReq
4934 * Request to WDI for programming the STA key( key for Unicast frames
4935 * Encryption)
4936 */
4937VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
4938 tSetStaKeyParams *setStaKeyParams )
4939{
4940 WDI_Status status = WDI_STATUS_SUCCESS ;
4941 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
4942 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
4943 sizeof(WDI_SetSTAKeyReqParamsType)) ;
4944 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4945 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4947 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4948 if(NULL == wdiSetStaKeyParam)
4949 {
4950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4951 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4952 VOS_ASSERT(0);
4953 return VOS_STATUS_E_NOMEM;
4954 }
4955 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4956 if(NULL == pWdaParams)
4957 {
4958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4959 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4960 VOS_ASSERT(0);
4961 vos_mem_free(wdiSetStaKeyParam);
4962 return VOS_STATUS_E_NOMEM;
4963 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4964 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4965 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4966 /* copy set STA key params to WDI structure */
4967 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
4968 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
4969 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
4970 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4971 if(setStaKeyParams->encType != eSIR_ED_NONE)
4972 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4973 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4974 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
4975 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4976 {
4977 WDA_GetWepKeysFromCfg( pWDA,
4978 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
4979 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
4980 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
4981 }
4982 else
4983 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4984 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4985 keyIndex++)
4986 {
4987 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
4988 setStaKeyParams->key[keyIndex].keyId;
4989 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
4990 setStaKeyParams->key[keyIndex].unicast;
4991 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
4992 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4993 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
4994 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4995 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
4996 setStaKeyParams->key[keyIndex].paeRole;
4997 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
4998 setStaKeyParams->key[keyIndex].keyLength;
4999 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5000 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5001 /* set default index to index which have key direction as WDI_TX_DEFAULT */
5002 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
5003 {
5004 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
5005 }
5006 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5007 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5008 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5009 }
5010 }
5011 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
5012 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5013 /* Store set key pointer, as this will be used for response */
5014 /* store Params pass it to WDI */
5015 pWdaParams->pWdaContext = pWDA;
5016 pWdaParams->wdaMsgParam = setStaKeyParams;
5017 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5018 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
5019 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5020 if(IS_WDI_STATUS_FAILURE(status))
5021 {
5022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5023 "Failure in set STA Key Req WDI API, free all the memory " );
5024 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5025 vos_mem_free(pWdaParams) ;
5026 setStaKeyParams->status = eSIR_FAILURE ;
5027 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
5028 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5029 return CONVERT_WDI2VOS_STATUS(status) ;
5030}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5031/*
5032 * FUNCTION: WDA_SetBcastStaKeyReqCallback
5033 * send SET Bcast STA key RSP back to PE
5034 */
5035void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
5036{
5037 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5038 tWDA_CbContext *pWDA;
5039 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5041 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5042 if(NULL == pWdaParams)
5043 {
5044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5045 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5046 VOS_ASSERT(0) ;
5047 return ;
5048 }
5049 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5050 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5051 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5052 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5053 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5054 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5055 return ;
5056}
5057
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5058/*
5059 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5060 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5061 * Encryption)
5062 */
5063VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5064 tSetStaKeyParams *setStaKeyParams )
5065{
5066 WDI_Status status = WDI_STATUS_SUCCESS ;
5067 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5068 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5069 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5070 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5071 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5072 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5073 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5074 if(NULL == wdiSetStaKeyParam)
5075 {
5076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5077 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5078 VOS_ASSERT(0);
5079 return VOS_STATUS_E_NOMEM;
5080 }
5081 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5082 if(NULL == pWdaParams)
5083 {
5084 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5085 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5086 VOS_ASSERT(0);
5087 vos_mem_free(wdiSetStaKeyParam);
5088 return VOS_STATUS_E_NOMEM;
5089 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5090 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5091 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5092 /* copy set STA key params to WDI structure */
5093 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5094 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5095 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5096 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5097 if(setStaKeyParams->encType != eSIR_ED_NONE)
5098 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5099 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5100 keyIndex++)
5101 {
5102 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5103 setStaKeyParams->key[keyIndex].keyId;
5104 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5105 setStaKeyParams->key[keyIndex].unicast;
5106 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5107 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5108 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5109 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5110 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5111 setStaKeyParams->key[keyIndex].paeRole;
5112 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5113 setStaKeyParams->key[keyIndex].keyLength;
5114 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5115 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5116 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5117 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5118 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5119 }
5120 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5121 /* Store set key pointer, as this will be used for response */
5122 /* store Params pass it to WDI */
5123 pWdaParams->pWdaContext = pWDA;
5124 pWdaParams->wdaMsgParam = setStaKeyParams;
5125 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5126 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5127 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5128 if(IS_WDI_STATUS_FAILURE(status))
5129 {
5130 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5131 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5132 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5133 vos_mem_free(pWdaParams) ;
5134 setStaKeyParams->status = eSIR_FAILURE ;
5135 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5136 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5137 return CONVERT_WDI2VOS_STATUS(status) ;
5138}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5139/*
5140 * FUNCTION: WDA_RemoveStaKeyReqCallback
5141 * send SET BSS key RSP back to PE
5142 */
5143void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5144{
5145 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5146 tWDA_CbContext *pWDA;
5147 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5149 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5150 if(NULL == pWdaParams)
5151 {
5152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5153 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5154 VOS_ASSERT(0) ;
5155 return ;
5156 }
5157 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5158 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5159 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5160 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5161 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5162 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5163 return ;
5164}
5165
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5166/*
5167 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5168 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5169 */
5170VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5171 tRemoveStaKeyParams *removeStaKeyParams )
5172{
5173 WDI_Status status = WDI_STATUS_SUCCESS ;
5174 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
5175 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
5176 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
5177 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5179 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5180 if(NULL == wdiRemoveStaKeyParam)
5181 {
5182 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5183 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5184 VOS_ASSERT(0);
5185 return VOS_STATUS_E_NOMEM;
5186 }
5187 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5188 if(NULL == pWdaParams)
5189 {
5190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5191 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5192 VOS_ASSERT(0);
5193 vos_mem_free(wdiRemoveStaKeyParam);
5194 return VOS_STATUS_E_NOMEM;
5195 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5196 /* copy remove STA key params to WDI structure*/
5197 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
5198 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
5199 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
5200 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
5201 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5202 /* Store remove key pointer, as this will be used for response */
5203 /* store Params pass it to WDI */
5204 pWdaParams->pWdaContext = pWDA;
5205 pWdaParams->wdaMsgParam = removeStaKeyParams;
5206 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5207 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
5208 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5209 if(IS_WDI_STATUS_FAILURE(status))
5210 {
5211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5212 "Failure in remove STA Key Req WDI API, free all the memory " );
5213 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5214 vos_mem_free(pWdaParams) ;
5215 removeStaKeyParams->status = eSIR_FAILURE ;
5216 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
5217 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5218 return CONVERT_WDI2VOS_STATUS(status) ;
5219}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5220/*
5221 * FUNCTION: WDA_IsHandleSetLinkStateReq
5222 * Update the WDA state and return the status to handle this message or not
5223 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5224WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
5225 tWDA_CbContext *pWDA,
5226 tLinkStateParams *linkStateParams)
5227{
5228 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5229 switch(linkStateParams->state)
5230 {
5231 case eSIR_LINK_PREASSOC_STATE:
5232 case eSIR_LINK_BTAMP_PREASSOC_STATE:
5233 /*
5234 * set the WDA state to PRE ASSOC
5235 * copy the BSSID into pWDA to use it in join request and return,
5236 * No need to handle these messages.
5237 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5238 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
5239 {
5240 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5241 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5242 }
5243 else
5244 {
5245 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5246 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5247 VOS_ASSERT(0);
5248 }
5249
5250 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
5251 {
5252 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5253 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5254 }
5255 else
5256 {
5257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5258 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5259 VOS_ASSERT(0);
5260 }
5261
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5262 /* UMAC is issuing the setlink state with PREASSOC twice (before set
5263 *channel and after ) so reset the WDA state to ready when the second
5264 * time UMAC issue the link state with PREASSOC
5265 */
5266 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
5267 {
5268 /* RESET WDA state back to WDA_READY_STATE */
5269 pWDA->wdaState = WDA_READY_STATE;
5270 }
5271 else
5272 {
5273 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
5274 }
5275 //populate linkState info in WDACbCtxt
5276 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5277 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5278 default:
5279 if(pWDA->wdaState != WDA_READY_STATE)
5280 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5281 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
5282 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
5283 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
5284 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
5285 *the ASSERT in WDA_Stop during module unload.*/
5286 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
5287 {
5288 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5289 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5290 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5291 else
5292 {
5293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5294 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5295 status = WDA_IGNORE_SET_LINK_STATE;
5296 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5297 }
5298 break;
5299 }
5300
5301 return status;
5302}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5303/*
5304 * FUNCTION: WDA_SetLinkStateCallback
5305 * call back function for set link state from WDI
5306 */
5307void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
5308{
5309 tWDA_CbContext *pWDA;
5310 tLinkStateParams *linkStateParams;
5311 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5312 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5313 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5314 if(NULL == pWdaParams)
5315 {
5316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5317 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5318 VOS_ASSERT(0) ;
5319 return ;
5320 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5321 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5322 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5323 /*
5324 * In STA mode start the BA activity check timer after association
5325 * and in AP mode start BA activity check timer after BSS start */
5326 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
5327 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]5328 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
5329 ((status == WDI_STATUS_SUCCESS) &&
5330 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5331 {
5332 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5333 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5334 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5335 /*
5336 * No respone required for WDA_SET_LINK_STATE so free the request
5337 * param here
5338 */
5339 if( pWdaParams != NULL )
5340 {
5341 if( pWdaParams->wdaWdiApiMsgParam != NULL )
5342 {
5343 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5344 }
5345 vos_mem_free(pWdaParams);
5346 }
5347 return ;
5348}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5349/*
5350 * FUNCTION: WDA_ProcessSetLinkState
5351 * Request to WDI to set the link status.
5352 */
5353VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
5354 tLinkStateParams *linkStateParams)
5355{
5356 WDI_Status status = WDI_STATUS_SUCCESS ;
5357 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
5358 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
5359 sizeof(WDI_SetLinkReqParamsType)) ;
5360 tWDA_ReqParams *pWdaParams ;
5361 tpAniSirGlobal pMac;
5362 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
5363
5364 if(NULL == pMac)
5365 {
5366 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5367 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5368 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5369 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5370 return VOS_STATUS_E_FAILURE;
5371 }
5372
5373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5374 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5375 if(NULL == wdiSetLinkStateParam)
5376 {
5377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5378 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5379 VOS_ASSERT(0);
5380 return VOS_STATUS_E_NOMEM;
5381 }
5382 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5383 if(NULL == pWdaParams)
5384 {
5385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5386 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5387 VOS_ASSERT(0);
5388 vos_mem_free(wdiSetLinkStateParam);
5389 return VOS_STATUS_E_NOMEM;
5390 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5391 if(WDA_IGNORE_SET_LINK_STATE ==
5392 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
5393 {
5394 status = WDI_STATUS_E_FAILURE;
5395 }
5396 else
5397 {
5398 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
5399 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5400 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
5401 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5402 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
5403 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5404 pWdaParams->pWdaContext = pWDA;
5405 /* Store remove key pointer, as this will be used for response */
5406 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5407 /* store Params pass it to WDI */
5408 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
5409 /* Stop Timer only other than GO role and concurrent session */
5410 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]5411 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5412 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
5413 {
5414 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5415 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5416 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
5417 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5418 if(IS_WDI_STATUS_FAILURE(status))
5419 {
5420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5421 "Failure in set link state Req WDI API, free all the memory " );
5422 }
5423 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5424 if(IS_WDI_STATUS_FAILURE(status))
5425 {
5426 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5427 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5428 vos_mem_free(pWdaParams);
5429 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5430 return CONVERT_WDI2VOS_STATUS(status) ;
5431}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5432/*
5433 * FUNCTION: WDA_GetStatsReqParamsCallback
5434 * send the response to PE with Stats received from WDI
5435 */
5436void WDA_GetStatsReqParamsCallback(
5437 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
5438 void* pUserData)
5439{
5440 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5441 tAniGetPEStatsRsp *pGetPEStatsRspParams;
5442
5443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5444 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5445 pGetPEStatsRspParams =
5446 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
5447 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
5448
5449 if(NULL == pGetPEStatsRspParams)
5450 {
5451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5452 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5453 VOS_ASSERT(0);
5454 return;
5455 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5456 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
5457 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
5458 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
5459 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5460
5461 //Fill the Session Id Properly in PE
5462 pGetPEStatsRspParams->sessionId = 0;
5463 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5464 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5465 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
5466 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5467 vos_mem_copy( pGetPEStatsRspParams + 1,
5468 wdiGetStatsRsp + 1,
5469 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5470 /* send response to UMAC*/
5471 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
5472
5473 return;
5474}
5475
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5476/*
5477 * FUNCTION: WDA_ProcessGetStatsReq
5478 * Request to WDI to get the statistics
5479 */
5480VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
5481 tAniGetPEStatsReq *pGetStatsParams)
5482{
5483 WDI_Status status = WDI_STATUS_SUCCESS ;
5484 WDI_GetStatsReqParamsType wdiGetStatsParam;
5485 tAniGetPEStatsRsp *pGetPEStatsRspParams;
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 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
5489 pGetStatsParams->staId;
5490 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
5491 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5492 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5493 status = WDI_GetStatsReq(&wdiGetStatsParam,
5494 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5495 if(IS_WDI_STATUS_FAILURE(status))
5496 {
5497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5498 "Failure in Get Stats Req WDI API, free all the memory " );
5499 pGetPEStatsRspParams =
5500 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
5501 if(NULL == pGetPEStatsRspParams)
5502 {
5503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5504 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5505 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5506 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5507 return VOS_STATUS_E_NOMEM;
5508 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5509 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
5510 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
5511 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
5512 pGetPEStatsRspParams->rc = eSIR_FAILURE;
5513 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
5514 (void *)pGetPEStatsRspParams, 0) ;
5515 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5516 /* Free the request message */
5517 vos_mem_free(pGetStatsParams);
5518 return CONVERT_WDI2VOS_STATUS(status);
5519}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5520
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]5521#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5522/*
5523 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
5524 * send the response to PE with roam Rssi received from WDI
5525 */
5526void WDA_GetRoamRssiReqParamsCallback(
5527 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
5528 void* pUserData)
5529{
5530 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5531 tWDA_CbContext *pWDA = NULL;
5532 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5533 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
5534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5535 "<------ %s " ,__func__);
5536 if(NULL == pWdaParams)
5537 {
5538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5539 "%s: pWdaParams received NULL", __func__);
5540 VOS_ASSERT(0) ;
5541 return ;
5542 }
5543 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5544 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
5545
5546 if(NULL == pGetRoamRssiReqParams)
5547 {
5548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5549 "%s: pGetRoamRssiReqParams received NULL", __func__);
5550 VOS_ASSERT(0);
5551 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5552 vos_mem_free(pWdaParams);
5553 return ;
5554 }
5555 pGetRoamRssiRspParams =
5556 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5557
5558 if(NULL == pGetRoamRssiRspParams)
5559 {
5560 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5561 "%s: VOS MEM Alloc Failure", __func__);
5562 VOS_ASSERT(0);
5563 return;
5564 }
5565 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
5566 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5567 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5568 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
5569 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
5570
5571 /* Assign get roam rssi req (backup) in to the response */
5572 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
5573
5574 /* free WDI command buffer */
5575 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5576 vos_mem_free(pWdaParams) ;
5577
5578 /* send response to UMAC*/
5579 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
5580
5581 return;
5582}
5583
5584
5585
5586/*
5587 * FUNCTION: WDA_ProcessGetRoamRssiReq
5588 * Request to WDI to get the statistics
5589 */
5590VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
5591 tAniGetRssiReq *pGetRoamRssiParams)
5592{
5593 WDI_Status status = WDI_STATUS_SUCCESS ;
5594 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
5595 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5596 tWDA_ReqParams *pWdaParams = NULL;
5597
5598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5599 "------> %s " ,__func__);
5600 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
5601 pGetRoamRssiParams->staId;
5602 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
5603
5604 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5605 if(NULL == pWdaParams)
5606 {
5607 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5608 "%s: VOS MEM Alloc Failure", __func__);
5609 VOS_ASSERT(0);
5610 return VOS_STATUS_E_NOMEM;
5611 }
5612
5613 /* Store Init Req pointer, as this will be used for response */
5614 pWdaParams->pWdaContext = pWDA;
5615
5616 /* Take Get roam Rssi req backup as it stores the callback to be called after
5617 receiving the response */
5618 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
5619 pWdaParams->wdaWdiApiMsgParam = NULL;
5620
5621 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
5622 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
5623 if(IS_WDI_STATUS_FAILURE(status))
5624 {
5625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5626 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
5627 pGetRoamRssiRspParams =
5628 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5629 if(NULL == pGetRoamRssiRspParams)
5630 {
5631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5632 "%s: VOS MEM Alloc Failure", __func__);
5633 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]5634 vos_mem_free(pGetRoamRssiParams);
5635 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5636 return VOS_STATUS_E_NOMEM;
5637 }
5638 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
5639 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
5640 pGetRoamRssiRspParams->rssi = 0;
5641 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
5642 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
5643 (void *)pGetRoamRssiRspParams, 0) ;
5644 }
5645 return CONVERT_WDI2VOS_STATUS(status);
5646}
5647#endif
5648
5649
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5650/*
5651 * FUNCTION: WDA_UpdateEDCAParamCallback
5652 * call back function for Update EDCA params from WDI
5653 */
5654void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
5655{
5656 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5657 tEdcaParams *pEdcaParams;
5658
5659 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5660 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5661 if(NULL == pWdaParams)
5662 {
5663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5664 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5665 VOS_ASSERT(0) ;
5666 return ;
5667 }
5668 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5669 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5670 vos_mem_free(pWdaParams);
5671 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5672 return ;
5673}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5674/*
5675 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
5676 * Request to WDI to Update the EDCA params.
5677 */
5678VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
5679 tEdcaParams *pEdcaParams)
5680{
5681 WDI_Status status = WDI_STATUS_SUCCESS ;
5682 WDI_UpdateEDCAParamsType *wdiEdcaParam =
5683 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
5684 sizeof(WDI_UpdateEDCAParamsType)) ;
5685 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5686 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5687 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5688 if(NULL == wdiEdcaParam)
5689 {
5690 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5691 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5692 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5693 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5694 return VOS_STATUS_E_NOMEM;
5695 }
5696 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5697 if(NULL == pWdaParams)
5698 {
5699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5700 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5701 VOS_ASSERT(0);
5702 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5703 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5704 return VOS_STATUS_E_NOMEM;
5705 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5706 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]5707 /*
5708 Since firmware is not using highperformance flag, we have removed
5709 this flag from wdiEDCAInfo structure to match sizeof the structure
5710 between host and firmware.In future if we are planning to use
5711 highperformance flag then Please define this flag in wdiEDCAInfo
5712 structure, update it here and send it to firmware. i.e.
5713 Following is the original line which we removed as part of the fix
5714 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
5715 pEdcaParams->highPerformance;
5716 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5717 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
5718 &pEdcaParams->acbe);
5719 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
5720 &pEdcaParams->acbk);
5721 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
5722 &pEdcaParams->acvi);
5723 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
5724 &pEdcaParams->acvo);
5725 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5726 pWdaParams->pWdaContext = pWDA;
5727 /* Store remove key pointer, as this will be used for response */
5728 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5729 /* store Params pass it to WDI */
5730 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5731 status = WDI_UpdateEDCAParams(wdiEdcaParam,
5732 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5733 if(IS_WDI_STATUS_FAILURE(status))
5734 {
5735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5736 "Failure in Update EDCA Params WDI API, free all the memory " );
5737 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5738 vos_mem_free(pWdaParams);
5739 vos_mem_free(pEdcaParams);
5740 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5741 return CONVERT_WDI2VOS_STATUS(status) ;
5742}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5743/*
5744 * FUNCTION: WDA_AddBAReqCallback
5745 * send ADD BA RSP back to PE
5746 */
5747void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
5748 void* pUserData)
5749{
5750 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5751 tWDA_CbContext *pWDA;
5752 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5753 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5754 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5755 if(NULL == pWdaParams)
5756 {
5757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5758 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5759 VOS_ASSERT(0) ;
5760 return ;
5761 }
5762 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5763 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5764 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5765 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5766 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5767 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5768 return ;
5769}
5770
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5771/*
5772 * FUNCTION: WDA_ProcessAddBAReq
5773 * Request to WDI to Update the ADDBA REQ params.
5774 */
5775VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
5776 tANI_U16 baSessionID, tANI_U8 staIdx, tAddBAParams *pAddBAReqParams)
5777{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5778 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5779 WDI_AddBAReqParamsType *wdiAddBAReqParam =
5780 (WDI_AddBAReqParamsType *)vos_mem_malloc(
5781 sizeof(WDI_AddBAReqParamsType)) ;
5782 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5784 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5785 if(NULL == wdiAddBAReqParam)
5786 {
5787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5788 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5789 VOS_ASSERT(0);
5790 return VOS_STATUS_E_NOMEM;
5791 }
5792 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5793 if(NULL == pWdaParams)
5794 {
5795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5796 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5797 VOS_ASSERT(0);
5798 vos_mem_free(wdiAddBAReqParam);
5799 return VOS_STATUS_E_NOMEM;
5800 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5801 do
5802 {
5803 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5804 wdiAddBaInfo->ucSTAIdx = staIdx ;
5805 wdiAddBaInfo->ucBaSessionID = baSessionID ;
5806 wdiAddBaInfo->ucWinSize = WDA_BA_MAX_WINSIZE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5807 } while(0) ;
5808 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5809 pWdaParams->pWdaContext = pWDA;
5810 /* store Params pass it to WDI */
5811 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
5812 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5813 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
5814 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5815
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5816 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5817 {
5818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5819 "Failure in ADD BA REQ Params WDI API, free all the memory" );
5820 status = CONVERT_WDI2VOS_STATUS(wstatus);
5821 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5822 vos_mem_free(pWdaParams);
5823 pAddBAReqParams->status = eSIR_FAILURE;
5824 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5825 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5826 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5827}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5828/*
5829 * FUNCTION: WDA_AddBASessionReqCallback
5830 * send ADD BA SESSION RSP back to PE/(or TL)
5831 */
5832void WDA_AddBASessionReqCallback(
5833 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
5834{
5835 VOS_STATUS status = VOS_STATUS_SUCCESS ;
5836 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5837 tWDA_CbContext *pWDA;
5838 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5840 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5841 if(NULL == pWdaParams)
5842 {
5843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5844 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5845 VOS_ASSERT(0) ;
5846 return ;
5847 }
5848 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5849 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5850 if( NULL == pAddBAReqParams )
5851 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5852 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5853 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5854 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5855 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5856 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5857 return ;
5858 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5859 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5860 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5861 /*
5862 * if WDA in update TL state, update TL with BA session parama and send
5863 * another request to HAL(/WDI) (ADD_BA_REQ)
5864 */
5865
5866 if((VOS_STATUS_SUCCESS ==
5867 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
5868 (WDA_BA_UPDATE_TL_STATE == pWDA->wdaState))
5869 {
5870 /* Update TL with BA info received from HAL/WDI */
5871 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
5872 wdiAddBaSession->usBaSessionID,
5873 wdiAddBaSession->ucSTAIdx,
5874 wdiAddBaSession->ucBaTID,
5875 wdiAddBaSession->ucBaBufferSize,
5876 wdiAddBaSession->ucWinSize,
5877 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5878 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
5879 wdiAddBaSession->ucSTAIdx, pAddBAReqParams) ;
5880 }
5881 else
5882 {
5883 pAddBAReqParams->status =
5884 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
5885
5886 /* Setting Flag to indicate that Set BA is success */
5887 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
5888 {
5889 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
5890 tANI_U8 tid = wdiAddBaSession->ucBaTID;
5891 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
5892 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5893 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5894 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5895 /*Reset the WDA state to READY */
5896 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5897 return ;
5898}
5899
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5900/*
5901 * FUNCTION: WDA_ProcessAddBASessionReq
5902 * Request to WDI to Update the ADDBA REQ params.
5903 */
5904VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
5905 tAddBAParams *pAddBAReqParams)
5906{
5907 WDI_Status status = WDI_STATUS_SUCCESS ;
5908 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
5909 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
5910 sizeof(WDI_AddBASessionReqParamsType)) ;
5911 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5912 WLANTL_STAStateType tlSTAState = 0;
5913
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5915 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5916 if(NULL == wdiAddBASessionReqParam)
5917 {
5918 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5919 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5920 VOS_ASSERT(0);
5921 return VOS_STATUS_E_NOMEM;
5922 }
5923 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5924 if(NULL == pWdaParams)
5925 {
5926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5927 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5928 VOS_ASSERT(0);
5929 vos_mem_free(wdiAddBASessionReqParam);
5930 return VOS_STATUS_E_NOMEM;
5931 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5932 /*
5933 * Populate ADD BA parameters and pass these paarmeters to WDI.
5934 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
5935 * the state to track if these is BA recipient case or BA initiator
5936 * case.
5937 */
5938 do
5939 {
5940 WDI_AddBASessionReqinfoType *wdiBAInfoType =
5941 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
5942 /* vos_mem_copy(wdiBAInfoType->macBSSID,
5943 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
5944 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
5945 vos_mem_copy(wdiBAInfoType->macPeerAddr,
5946 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5947 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5948 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
5949 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
5950 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
5951 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
5952 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5953 /* check the BA direction and update state accordingly */
5954 (eBA_RECIPIENT == wdiBAInfoType->ucBaDirection)
5955 ? (pWDA->wdaState = WDA_BA_UPDATE_TL_STATE)
5956 : (pWDA->wdaState = WDA_BA_UPDATE_LIM_STATE);
5957
5958 }while(0) ;
5959 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5960 pWdaParams->pWdaContext = pWDA;
5961 /* Store ADD BA pointer, as this will be used for response */
5962 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
5963 /* store Params pass it to WDI */
5964 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5965
5966 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
5967 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
5968 */
5969 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
5970 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
5971 {
5972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5973 "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]5974 status = WDI_STATUS_E_NOT_ALLOWED;
5975 pAddBAReqParams->status =
5976 CONVERT_WDI2SIR_STATUS(status) ;
5977 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5978 /*Reset the WDA state to READY */
5979 pWDA->wdaState = WDA_READY_STATE;
5980 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5981 vos_mem_free(pWdaParams);
5982
5983 return CONVERT_WDI2VOS_STATUS(status) ;
5984 }
5985
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5986 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
5987 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5988 if(IS_WDI_STATUS_FAILURE(status))
5989 {
5990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5991 "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]5992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5993 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]5994 pAddBAReqParams->status =
5995 CONVERT_WDI2SIR_STATUS(status) ;
5996 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5997 /*Reset the WDA state to READY */
5998 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5999 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6000 vos_mem_free(pWdaParams);
6001 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6002 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6003}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6004/*
6005 * FUNCTION: WDA_DelBANotifyTL
6006 * send DEL BA IND to TL
6007 */
6008void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
6009 tDelBAParams *pDelBAReqParams)
6010{
6011 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
6012 //tSirMsgQ msg;
6013 vos_msg_t vosMsg;
6014 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6015 if(NULL == pDelBAInd)
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6019 VOS_ASSERT(0) ;
6020 return;
6021 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6022 pDelBAInd->mesgType = WDA_DELETEBA_IND;
6023 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
6024 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
6025 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6026
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6027
6028 vosMsg.type = WDA_DELETEBA_IND;
6029 vosMsg.bodyptr = pDelBAInd;
6030 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
6031 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
6032 {
6033 vosStatus = VOS_STATUS_E_BADMSG;
6034 }
6035}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6036/*
6037 * FUNCTION: WDA_DelBAReqCallback
6038 * send DEL BA RSP back to PE
6039 */
6040void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
6041{
6042 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6043 tWDA_CbContext *pWDA;
6044 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6046 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6047 if(NULL == pWdaParams)
6048 {
6049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6050 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6051 VOS_ASSERT(0) ;
6052 return ;
6053 }
6054 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6055 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6056 /* Notify TL about DEL BA in case of recipinet */
6057 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6058 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6059 {
6060 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6061 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6062 /*
6063 * No respone required for WDA_DELBA_IND so just free the request
6064 * param here
6065 */
6066 vos_mem_free(pDelBAReqParams);
6067 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6068 vos_mem_free(pWdaParams);
6069 return ;
6070}
6071
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6072/*
6073 * FUNCTION: WDA_ProcessDelBAReq
6074 * Request to WDI to Update the DELBA REQ params.
6075 */
6076VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6077 tDelBAParams *pDelBAReqParams)
6078{
6079 WDI_Status status = WDI_STATUS_SUCCESS ;
6080 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6081 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6082 sizeof(WDI_DelBAReqParamsType)) ;
6083 tWDA_ReqParams *pWdaParams ;
6084 tANI_U16 staIdx = 0;
6085 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6086 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6087 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6088 if(NULL == wdiDelBAReqParam)
6089 {
6090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6091 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6092 VOS_ASSERT(0);
6093 return VOS_STATUS_E_NOMEM;
6094 }
6095 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6096 if(NULL == pWdaParams)
6097 {
6098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6099 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6100 VOS_ASSERT(0);
6101 vos_mem_free(wdiDelBAReqParam);
6102 return VOS_STATUS_E_NOMEM;
6103 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6104 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6105 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6106 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6107 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6108 pWdaParams->pWdaContext = pWDA;
6109 /* Store DEL BA pointer, as this will be used for response */
6110 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6111 /* store Params pass it to WDI */
6112 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6113 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6114 * maintained in WDA, so that WDA can retry for another BA session
6115 */
6116 staIdx = pDelBAReqParams->staIdx;
6117 tid = pDelBAReqParams->baTID;
6118 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6119 status = WDI_DelBAReq(wdiDelBAReqParam,
6120 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6121 if(IS_WDI_STATUS_FAILURE(status))
6122 {
6123 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6124 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6125 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6126 vos_mem_free(pWdaParams->wdaMsgParam);
6127 vos_mem_free(pWdaParams);
6128 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6129 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6130}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6131
6132/*
6133 * FUNCTION: WDA_UpdateChReqCallback
6134 *
6135 */
6136void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6137{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6138 tWDA_ReqParams *pWdaParams;
6139 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6140 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6141 WDI_UpdateChannelReqinfoType *pChanInfoType;
6142 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6143
6144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6145 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6146 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6147 {
6148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6149 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6150 VOS_ASSERT(0);
6151 return;
6152 }
6153
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6154 pWdaParams = (tWDA_ReqParams *)pUserData;
6155 pwdiUpdateChReqParam =
6156 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
6157 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6158 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
6159 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6160 /*
6161 * currently there is no response message is expected between PE and
6162 * WDA, Failure return from WDI is a ASSERT condition
6163 */
6164 vos_mem_free(pChanInfoType);
6165 vos_mem_free(pChanList);
6166 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6167 vos_mem_free(pWdaParams);
6168
6169 return;
6170}
6171
6172/*
6173 * FUNCTION: WDA_ProcessUpdateChannelList
6174 * Request to WDI to Update the ChannelList params.
6175 */
6176VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
6177 tSirUpdateChanList *pChanList)
6178{
6179 WDI_Status status = WDI_STATUS_SUCCESS;
6180 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6181 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6182 WDI_UpdateChannelReqinfoType *pChanInfoType;
6183 tWDA_ReqParams *pWdaParams;
6184 wpt_uint8 i;
6185
6186 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6187 "------> %s " ,__func__);
6188 if(NULL == pChanList)
6189 {
6190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6191 "%s: NULL pChanList", __func__);
6192 VOS_ASSERT(0);
6193 return VOS_STATUS_E_INVAL;
6194 }
6195
6196 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
6197 {
6198 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6199 "Update channel list capability Not Supported");
6200 vos_mem_free(pChanList);
6201 return VOS_STATUS_E_INVAL;
6202 }
6203
6204 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
6205 sizeof(WDI_UpdateChReqParamsType));
6206 if(NULL == pwdiUpdateChReqParam)
6207 {
6208 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6209 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
6210 __func__);
6211 VOS_ASSERT(0);
6212 vos_mem_free(pChanList);
6213 return VOS_STATUS_E_NOMEM;
6214 }
6215 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6216 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
6217 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
6218 pChanList->numChan);
6219 if(NULL == pChanInfoType)
6220 {
6221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6222 "%s: VOS MEM Alloc Failure", __func__);
6223 VOS_ASSERT(0);
6224 vos_mem_free(pChanList);
6225 vos_mem_free(pwdiUpdateChReqParam);
6226 return VOS_STATUS_E_NOMEM;
6227 }
6228 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
6229 * pChanList->numChan);
6230 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
6231
6232 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6233 if(NULL == pWdaParams)
6234 {
6235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6236 "%s: VOS MEM Alloc Failure", __func__);
6237 VOS_ASSERT(0);
6238 vos_mem_free(pChanList);
6239 vos_mem_free(pChanInfoType);
6240 vos_mem_free(pwdiUpdateChReqParam);
6241 return VOS_STATUS_E_NOMEM;
6242 }
6243 pwdiUpdateChanReqType->numchan = pChanList->numChan;
6244
6245 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
6246 {
6247 pChanInfoType->mhz =
6248 vos_chan_to_freq(pChanList->chanParam[i].chanId);
6249
6250 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
6251 pChanInfoType->band_center_freq2 = 0;
6252
6253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6254 "chan[%d] = %u", i, pChanInfoType->mhz);
6255 if (pChanList->chanParam[i].dfsSet)
6256 {
6257 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
6258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6259 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
6260 pChanList->chanParam[i].dfsSet);
6261 }
6262
6263 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
6264 {
6265 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
6266 }
6267 else
6268 {
6269 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
6270 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
6271 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
6272 }
6273
6274 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6275 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6276
6277 pChanInfoType++;
6278 }
6279
6280 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
6281 pWdaParams->pWdaContext = pWDA;
6282 pWdaParams->wdaMsgParam = (void *)pChanList;
6283 /* store Params pass it to WDI */
6284 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
6285 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
6286 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
6287 if(IS_WDI_STATUS_FAILURE(status))
6288 {
6289 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6290 "Failure in Update Channel REQ Params WDI API, free all the memory");
6291 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
6292 vos_mem_free(pwdiUpdateChReqParam);
6293 vos_mem_free(pWdaParams->wdaMsgParam);
6294 vos_mem_free(pWdaParams);
6295 }
6296 return CONVERT_WDI2VOS_STATUS(status);
6297}
6298
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6299/*
6300 * FUNCTION: WDA_AddTSReqCallback
6301 * send ADD TS RSP back to PE
6302 */
6303void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
6304{
6305 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6306 tWDA_CbContext *pWDA;
6307 tAddTsParams *pAddTsReqParams;
6308
6309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6310 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6311 if(NULL == pWdaParams)
6312 {
6313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6314 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6315 VOS_ASSERT(0) ;
6316 return ;
6317 }
6318 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6319 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
6320 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6321 vos_mem_free(pWdaParams);
6322
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6323 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6324 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6325 return ;
6326}
6327
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6328/*
6329 * FUNCTION: WDA_ProcessAddTSReq
6330 * Request to WDI to Update the ADD TS REQ params.
6331 */
6332VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
6333 tAddTsParams *pAddTsReqParams)
6334{
6335 WDI_Status status = WDI_STATUS_SUCCESS ;
6336 WDI_AddTSReqParamsType *wdiAddTSReqParam =
6337 (WDI_AddTSReqParamsType *)vos_mem_malloc(
6338 sizeof(WDI_AddTSReqParamsType)) ;
6339 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6340 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6341 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6342 if(NULL == wdiAddTSReqParam)
6343 {
6344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6345 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6346 VOS_ASSERT(0);
6347 return VOS_STATUS_E_NOMEM;
6348 }
6349 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6350 if(NULL == pWdaParams)
6351 {
6352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6353 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6354 VOS_ASSERT(0);
6355 vos_mem_free(wdiAddTSReqParam);
6356 return VOS_STATUS_E_NOMEM;
6357 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6358 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
6359 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6360 //TS IE
6361 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
6362 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
6363 pAddTsReqParams->tspec.length;
6364
6365 //TS IE : TS INFO : TRAFFIC
6366 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
6367 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
6368 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
6369 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
6370 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
6371 pAddTsReqParams->tspec.tsinfo.traffic.psb;
6372 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
6373 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
6374 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
6375 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
6376 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
6377 pAddTsReqParams->tspec.tsinfo.traffic.direction;
6378 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
6379 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
6380 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
6381 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
6382
6383 //TS IE : TS INFO : SCHEDULE
6384 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
6385 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
6386 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
6387 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6388 //TS IE
6389 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
6390 pAddTsReqParams->tspec.nomMsduSz;
6391 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
6392 pAddTsReqParams->tspec.maxMsduSz;
6393 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
6394 pAddTsReqParams->tspec.minSvcInterval;
6395 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
6396 pAddTsReqParams->tspec.maxSvcInterval;
6397 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
6398 pAddTsReqParams->tspec.inactInterval;
6399 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
6400 pAddTsReqParams->tspec.suspendInterval;
6401 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
6402 pAddTsReqParams->tspec.svcStartTime;
6403 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
6404 pAddTsReqParams->tspec.minDataRate;
6405 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
6406 pAddTsReqParams->tspec.meanDataRate;
6407 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
6408 pAddTsReqParams->tspec.peakDataRate;
6409 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
6410 pAddTsReqParams->tspec.maxBurstSz;
6411 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
6412 pAddTsReqParams->tspec.delayBound;
6413 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
6414 pAddTsReqParams->tspec.minPhyRate;
6415 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
6416 pAddTsReqParams->tspec.surplusBw;
6417 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
6418 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6419 /* TODO: tAddTsParams doesn't have the following fields */
6420#if 0
6421 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
6422 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
6423 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
6424 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
6425#endif
6426 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
6427
6428 pWdaParams->pWdaContext = pWDA;
6429 /* Store ADD TS pointer, as this will be used for response */
6430 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6431 /* store Params pass it to WDI */
6432 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6433 status = WDI_AddTSReq(wdiAddTSReqParam,
6434 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6435 if(IS_WDI_STATUS_FAILURE(status))
6436 {
6437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6438 "Failure in ADD TS REQ Params WDI API, free all the memory " );
6439 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6440 vos_mem_free(pWdaParams);
6441 pAddTsReqParams->status = eSIR_FAILURE ;
6442 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
6443 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6444 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6445}
6446
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6447/*
6448 * FUNCTION: WDA_DelTSReqCallback
6449 * send DEL TS RSP back to PE
6450 */
6451void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
6452{
6453 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6454 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6455 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6456 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6457 vos_mem_free(pWdaParams->wdaMsgParam) ;
6458 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6459 /*
6460 * No respone required for WDA_DEL_TS_REQ so just free the request
6461 * param here
6462 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6463 return ;
6464}
6465
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6466/*
6467 * FUNCTION: WDA_ProcessDelTSReq
6468 * Request to WDI to Update the DELTS REQ params.
6469 */
6470VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
6471 tDelTsParams *pDelTSReqParams)
6472{
6473 WDI_Status status = WDI_STATUS_SUCCESS ;
6474 WDI_DelTSReqParamsType *wdiDelTSReqParam =
6475 (WDI_DelTSReqParamsType *)vos_mem_malloc(
6476 sizeof(WDI_DelTSReqParamsType)) ;
6477 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6479 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6480 if(NULL == wdiDelTSReqParam)
6481 {
6482 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6483 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6484 VOS_ASSERT(0);
6485 return VOS_STATUS_E_NOMEM;
6486 }
6487 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6488 if(NULL == pWdaParams)
6489 {
6490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6491 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6492 VOS_ASSERT(0);
6493 vos_mem_free(wdiDelTSReqParam);
6494 return VOS_STATUS_E_NOMEM;
6495 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6496 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
6497 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
6498 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
6499 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
6500 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6501 pWdaParams->pWdaContext = pWDA;
6502 /* Store DEL TS pointer, as this will be used for response */
6503 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6504 /* store Params pass it to WDI */
6505 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6506 status = WDI_DelTSReq(wdiDelTSReqParam,
6507 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6508 if(IS_WDI_STATUS_FAILURE(status))
6509 {
6510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6511 "Failure in DEL TS REQ Params WDI API, free all the memory " );
6512 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6513 vos_mem_free(pWdaParams->wdaMsgParam);
6514 vos_mem_free(pWdaParams);
6515 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6516 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6517}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6518/*
6519 * FUNCTION: WDA_UpdateBeaconParamsCallback
6520 * Free the memory. No need to send any response to PE in this case
6521 */
6522void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
6523{
6524 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6526 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6527 if(NULL == pWdaParams)
6528 {
6529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6530 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6531 VOS_ASSERT(0) ;
6532 return ;
6533 }
6534 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6535 vos_mem_free(pWdaParams->wdaMsgParam) ;
6536 vos_mem_free(pWdaParams);
6537 /*
6538 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
6539 * param here
6540 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6541 return ;
6542}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6543/*
6544 * FUNCTION: WDA_ProcessUpdateBeaconParams
6545 * Request to WDI to send the beacon parameters to HAL to update the Hardware
6546 */
6547VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
6548 tUpdateBeaconParams *pUpdateBeaconParams)
6549{
6550 WDI_Status status = WDI_STATUS_SUCCESS ;
6551 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
6552 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
6553 sizeof(WDI_UpdateBeaconParamsType)) ;
6554 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6556 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6557 if(NULL == wdiUpdateBeaconParams)
6558 {
6559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6560 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6561 VOS_ASSERT(0);
6562 return VOS_STATUS_E_NOMEM;
6563 }
6564 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6565 if(NULL == pWdaParams)
6566 {
6567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6568 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6569 VOS_ASSERT(0);
6570 vos_mem_free(wdiUpdateBeaconParams);
6571 return VOS_STATUS_E_NOMEM;
6572 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6573 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
6574 pUpdateBeaconParams->bssIdx;
6575 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
6576 pUpdateBeaconParams->fShortPreamble;
6577 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
6578 pUpdateBeaconParams->fShortSlotTime;
6579 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
6580 pUpdateBeaconParams->beaconInterval;
6581 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
6582 pUpdateBeaconParams->llaCoexist;
6583 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
6584 pUpdateBeaconParams->llbCoexist;
6585 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
6586 pUpdateBeaconParams->llgCoexist;
6587 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
6588 pUpdateBeaconParams->ht20MhzCoexist;
6589 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
6590 pUpdateBeaconParams->llnNonGFCoexist;
6591 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
6592 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
6593 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
6594 pUpdateBeaconParams->fRIFSMode;
6595 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
6596 pUpdateBeaconParams->paramChangeBitmap;
6597 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
6598
6599 pWdaParams->pWdaContext = pWDA;
6600 /* Store UpdateBeacon Req pointer, as this will be used for response */
6601 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6602 /* store Params pass it to WDI */
6603 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6604 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
6605 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
6606 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6607 if(IS_WDI_STATUS_FAILURE(status))
6608 {
6609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6610 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
6611 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6612 vos_mem_free(pWdaParams->wdaMsgParam);
6613 vos_mem_free(pWdaParams);
6614 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6615 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6616}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6617#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6618/*
6619 * FUNCTION: WDA_TSMStatsReqCallback
6620 * send TSM Stats RSP back to PE
6621 */
6622void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
6623{
6624 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6625 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6626 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
6627 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6628
6629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6630 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6631 if(NULL == pWdaParams)
6632 {
6633 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6634 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6635 VOS_ASSERT(0) ;
6636 return ;
6637 }
6638 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6639 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
6640
6641 if(NULL == pGetTsmStatsReqParams)
6642 {
6643 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6644 "%s: pGetTsmStatsReqParams received NULL", __func__);
6645 VOS_ASSERT(0);
6646 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6647 vos_mem_free(pWdaParams);
6648 return;
6649 }
6650
6651 pTsmRspParams =
6652 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6653 if( NULL == pTsmRspParams )
6654 {
6655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6656 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6657 VOS_ASSERT( 0 );
6658 return ;
6659 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6660 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
6661 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
6662 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
6663
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6664 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
6665 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
6666 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
6667 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
6668 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
6669 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
6670 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
6671 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
6672 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
6673 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6674
6675 /* Assign get tsm stats req req (backup) in to the response */
6676 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
6677
6678 /* free WDI command buffer */
6679 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6680 vos_mem_free(pWdaParams);
6681
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6682 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6683 return ;
6684}
6685
6686
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6687/*
6688 * FUNCTION: WDA_ProcessTsmStatsReq
6689 * Request to WDI to get the TSM Stats params.
6690 */
6691VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6692 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6693{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6694 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6695 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6696 tWDA_ReqParams *pWdaParams = NULL;
6697 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
6698
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 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6701 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
6702 sizeof(WDI_TSMStatsReqParamsType));
6703 if(NULL == wdiTSMReqParam)
6704 {
6705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6706 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6707 VOS_ASSERT(0);
6708 return VOS_STATUS_E_NOMEM;
6709 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6710 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6711 if(NULL == pWdaParams)
6712 {
6713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6714 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6715 VOS_ASSERT(0);
6716 vos_mem_free(wdiTSMReqParam);
6717 return VOS_STATUS_E_NOMEM;
6718 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6719 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
6720 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
6721 pTsmStats->bssId,
6722 sizeof(wpt_macAddr));
6723 wdiTSMReqParam->wdiReqStatusCB = NULL ;
6724
6725 pWdaParams->pWdaContext = pWDA;
6726 /* Store TSM Stats pointer, as this will be used for response */
6727 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6728 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6729 status = WDI_TSMStatsReq(wdiTSMReqParam,
6730 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6731 if(IS_WDI_STATUS_FAILURE(status))
6732 {
6733 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6734 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6735 vos_mem_free(pWdaParams);
6736
6737 pGetTsmStatsRspParams =
6738 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
6739 if(NULL == pGetTsmStatsRspParams)
6740 {
6741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6742 "%s: VOS MEM Alloc Failure", __func__);
6743 VOS_ASSERT(0);
6744 vos_mem_free(pTsmStats);
6745 return VOS_STATUS_E_NOMEM;
6746 }
6747 pGetTsmStatsRspParams->staId = pTsmStats->staId;
6748 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
6749 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
6750
6751 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6752 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6753 return CONVERT_WDI2VOS_STATUS(status) ;
6754}
6755#endif
6756/*
6757 * FUNCTION: WDA_SendBeaconParamsCallback
6758 * No need to send any response to PE in this case
6759 */
6760void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
6761{
6762
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6763 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6764 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6765 return ;
6766}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6767/*
6768 * FUNCTION: WDA_ProcessSendBeacon
6769 * Request to WDI to send the beacon template to HAL to update the TPE memory and
6770 * start beacon trasmission
6771 */
6772VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
6773 tSendbeaconParams *pSendbeaconParams)
6774{
6775 WDI_Status status = WDI_STATUS_SUCCESS ;
6776 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6777 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6778 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6779 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
6780 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
6781 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
6782 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6783 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
6784 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]6785 /* p2pIeOffset should be atleast greater than timIeOffset */
6786 if ((pSendbeaconParams->p2pIeOffset != 0) &&
6787 (pSendbeaconParams->p2pIeOffset <
6788 pSendbeaconParams->timIeOffset))
6789 {
6790 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6791 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
6792 VOS_ASSERT( 0 );
6793 return WDI_STATUS_E_FAILURE;
6794 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6795 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
6796 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6797 /* Copy the beacon template to local buffer */
6798 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
6799 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
6800 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
6801
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6802 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
6803 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6804 if(IS_WDI_STATUS_FAILURE(status))
6805 {
6806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6807 "Failure in SEND BEACON REQ Params WDI API" );
6808 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6809 vos_mem_free(pSendbeaconParams);
6810 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6811}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6812/*
6813 * FUNCTION: WDA_UpdateProbeRspParamsCallback
6814 * No need to send any response to PE in this case
6815 */
6816void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
6817{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6819 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6820 return ;
6821}
6822
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6823/*
6824 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
6825 * Request to WDI to send the probe response template to HAL to update the TPE memory and
6826 * send probe response
6827 */
6828VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
6829 tSendProbeRespParams *pSendProbeRspParams)
6830{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6831 WDI_Status status = WDI_STATUS_SUCCESS;
6832 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
6833 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6834 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6835 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6836
6837 if (!wdiSendProbeRspParam)
6838 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
6839
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6840 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6841 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6842 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6843 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6844 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6845 /* Copy the Probe Response template to local buffer */
6846 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6847 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6848 pSendProbeRspParams->pProbeRespTemplate,
6849 pSendProbeRspParams->probeRespTemplateLen);
6850 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6851 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6852 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
6853 WDI_PROBE_REQ_BITMAP_IE_LEN);
6854
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6855 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6856
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6857 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6858 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6859 if(IS_WDI_STATUS_FAILURE(status))
6860 {
6861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6862 "Failure in SEND Probe RSP Params WDI API" );
6863 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6864 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6865 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6866 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6867}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6868#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6869/*
6870 * FUNCTION: WDA_SetMaxTxPowerCallBack
6871 * send the response to PE with power value received from WDI
6872 */
6873void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
6874 void* pUserData)
6875{
6876 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6877 tWDA_CbContext *pWDA = NULL;
6878 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
6879
6880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6881 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6882 if(NULL == pWdaParams)
6883 {
6884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6885 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6886 VOS_ASSERT(0) ;
6887 return ;
6888 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6889 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6890 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6891 if( NULL == pMaxTxPowerParams )
6892 {
6893 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6894 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6895 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6896 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6897 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6898 return ;
6899 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6900
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6901
6902 /*need to free memory for the pointers used in the
6903 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6904 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6905 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6906 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6907
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6908
6909 /* send response to UMAC*/
6910 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
6911
6912 return;
6913}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6914/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6915 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6916 * Request to WDI to send set Max Tx Power Request
6917 */
6918 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
6919 tMaxTxPowerParams *MaxTxPowerParams)
6920{
6921 WDI_Status status = WDI_STATUS_SUCCESS;
6922 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
6923 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6924
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6925 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6926 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6927
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6928 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
6929 sizeof(WDI_SetMaxTxPowerParamsType));
6930 if(NULL == wdiSetMaxTxPowerParams)
6931 {
6932 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6933 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6934 VOS_ASSERT(0);
6935 return VOS_STATUS_E_NOMEM;
6936 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6937 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6938 if(NULL == pWdaParams)
6939 {
6940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6941 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6942 vos_mem_free(wdiSetMaxTxPowerParams);
6943 VOS_ASSERT(0);
6944 return VOS_STATUS_E_NOMEM;
6945 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6946 /* Copy.Max.Tx.Power Params to WDI structure */
6947 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
6948 MaxTxPowerParams->bssId,
6949 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6950 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
6951 MaxTxPowerParams->selfStaMacAddr,
6952 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6953 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
6954 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6955 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6956 pWdaParams->pWdaContext = pWDA;
6957 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6958 /* store Params pass it to WDI */
6959 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6960 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
6961 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6962 if(IS_WDI_STATUS_FAILURE(status))
6963 {
6964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6965 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
6966 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6967 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6968 /* send response to UMAC*/
6969 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6970 }
6971 return CONVERT_WDI2VOS_STATUS(status);
6972
6973}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6974#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]6975
6976/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]6977 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
6978 * send the response to PE with power value received from WDI
6979 */
6980void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
6981 *pwdiSetMaxTxPowerPerBandRsp,
6982 void* pUserData)
6983{
6984 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6985 tWDA_CbContext *pWDA = NULL;
6986 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
6987
6988 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6989 "<------ %s ", __func__);
6990 if (NULL == pWdaParams)
6991 {
6992 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6993 "%s: pWdaParams received NULL", __func__);
6994 VOS_ASSERT(0);
6995 return ;
6996 }
6997 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6998 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
6999 if ( NULL == pMxTxPwrPerBandParams )
7000 {
7001 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7002 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
7003 VOS_ASSERT(0);
7004 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7005 vos_mem_free(pWdaParams);
7006 return;
7007 }
7008
7009 /*need to free memory for the pointers used in the
7010 WDA Process.Set Max Tx Power Req function*/
7011 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7012 vos_mem_free(pWdaParams);
7013 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
7014
7015 /* send response to UMAC*/
7016 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7017 pMxTxPwrPerBandParams, 0);
7018
7019 return;
7020}
7021
7022/*
7023 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
7024 * Request to WDI to send set Max Tx Power Per band Request
7025 */
7026 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
7027 tMaxTxPowerPerBandParams
7028 *MaxTxPowerPerBandParams)
7029{
7030 WDI_Status status = WDI_STATUS_SUCCESS;
7031 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
7032 tWDA_ReqParams *pWdaParams = NULL;
7033
7034 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7035 "------> %s ", __func__);
7036
7037 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
7038 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
7039
7040 if (NULL == wdiSetMxTxPwrPerBandParams)
7041 {
7042 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7043 "%s: VOS MEM Alloc Failure", __func__);
7044 VOS_ASSERT(0);
7045 return VOS_STATUS_E_NOMEM;
7046 }
7047 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7048 if (NULL == pWdaParams)
7049 {
7050 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7051 "%s: VOS MEM Alloc Failure", __func__);
7052 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7053 VOS_ASSERT(0);
7054 return VOS_STATUS_E_NOMEM;
7055 }
7056 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7057 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7058 MaxTxPowerPerBandParams->bandInfo;
7059 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7060 MaxTxPowerPerBandParams->power;
7061 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7062 pWdaParams->pWdaContext = pWDA;
7063 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7064 /* store Params pass it to WDI */
7065 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7066 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7067 WDA_SetMaxTxPowerPerBandCallBack,
7068 pWdaParams);
7069 if (IS_WDI_STATUS_FAILURE(status))
7070 {
7071 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7072 "Failure in SET MAX TX Power REQ Params WDI API,"
7073 " free all the memory");
7074 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7075 vos_mem_free(pWdaParams);
7076 /* send response to UMAC*/
7077 WDA_SendMsg(pWDA,
7078 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7079 MaxTxPowerPerBandParams, 0);
7080 }
7081 return CONVERT_WDI2VOS_STATUS(status);
7082}
7083
7084/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7085 * FUNCTION: WDA_SetTxPowerCallBack
7086 * send the response to PE with power value received from WDI
7087 */
7088void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7089 void* pUserData)
7090{
7091 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7092 tWDA_CbContext *pWDA = NULL;
7093 tSirSetTxPowerReq *pTxPowerParams = NULL;
7094
7095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7096 "<------ %s ", __func__);
7097 if(NULL == pWdaParams)
7098 {
7099 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7100 "%s: pWdaParams received NULL", __func__);
7101 VOS_ASSERT(0) ;
7102 return ;
7103 }
7104 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7105 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
7106 if(NULL == pTxPowerParams)
7107 {
7108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7109 "%s: pTxPowerParams received NULL " ,__func__);
7110 VOS_ASSERT(0);
7111 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7112 vos_mem_free(pWdaParams);
7113 return ;
7114 }
7115
7116 /*need to free memory for the pointers used in the
7117 WDA Process.Set Max Tx Power Req function*/
7118 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7119 vos_mem_free(pWdaParams);
7120
7121 /* send response to UMAC*/
7122 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
7123 return;
7124}
7125
7126/*
7127 * FUNCTION: WDA_ProcessSetTxPowerReq
7128 * Request to WDI to send set Tx Power Request
7129 */
7130 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
7131 tSirSetTxPowerReq *txPowerParams)
7132{
7133 WDI_Status status = WDI_STATUS_SUCCESS;
7134 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
7135 tWDA_ReqParams *pWdaParams = NULL;
7136
7137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7138 "------> %s ", __func__);
7139
7140 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
7141 sizeof(WDI_SetTxPowerParamsType));
7142 if(NULL == wdiSetTxPowerParams)
7143 {
7144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7145 "%s: VOS MEM Alloc Failure", __func__);
7146 VOS_ASSERT(0);
7147 return VOS_STATUS_E_NOMEM;
7148 }
7149 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7150 if(NULL == pWdaParams)
7151 {
7152 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7153 "%s: VOS MEM Alloc Failure", __func__);
7154 vos_mem_free(wdiSetTxPowerParams);
7155 VOS_ASSERT(0);
7156 return VOS_STATUS_E_NOMEM;
7157 }
7158 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
7159 txPowerParams->bssIdx;
7160 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
7161 txPowerParams->mwPower;
7162 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
7163 pWdaParams->pWdaContext = pWDA;
7164 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
7165 /* store Params pass it to WDI */
7166 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
7167 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
7168 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
7169 if(IS_WDI_STATUS_FAILURE(status))
7170 {
7171 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7172 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
7173 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7174 vos_mem_free(pWdaParams);
7175 /* send response to UMAC*/
7176 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
7177 }
7178 return CONVERT_WDI2VOS_STATUS(status);
7179}
7180
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7181/*
7182 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7183 * Free the memory. No need to send any response to PE in this case
7184 */
7185void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
7186{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7187 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7188
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7190 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7191
7192 if(NULL == pWdaParams)
7193 {
7194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7195 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7196 VOS_ASSERT(0) ;
7197 return ;
7198 }
7199
7200 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7201 vos_mem_free(pWdaParams->wdaMsgParam) ;
7202 vos_mem_free(pWdaParams);
7203
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7204 /*
7205 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
7206 * so just free the request param here
7207 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7208 return ;
7209}
7210
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7211/*
7212 * FUNCTION: WDA_ProcessSetP2PGONOAReq
7213 * Request to WDI to set the P2P Group Owner Notice of Absence Req
7214 */
7215VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
7216 tP2pPsParams *pP2pPsConfigParams)
7217{
7218 WDI_Status status = WDI_STATUS_SUCCESS ;
7219 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
7220 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
7221 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7222 tWDA_ReqParams *pWdaParams = NULL;
7223
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7225 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7226 if(NULL == wdiSetP2PGONOAReqParam)
7227 {
7228 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7229 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7230 VOS_ASSERT(0);
7231 return VOS_STATUS_E_NOMEM;
7232 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7233
7234 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7235 if(NULL == pWdaParams)
7236 {
7237 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7238 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7239 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7240 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7241 VOS_ASSERT(0);
7242 return VOS_STATUS_E_NOMEM;
7243 }
7244
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7245 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
7246 pP2pPsConfigParams->opp_ps;
7247 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
7248 pP2pPsConfigParams->ctWindow;
7249 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
7250 pP2pPsConfigParams->count;
7251 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
7252 pP2pPsConfigParams->duration;
7253 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
7254 pP2pPsConfigParams->interval;
7255 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
7256 pP2pPsConfigParams->single_noa_duration;
7257 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
7258 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7259
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7260 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
7261 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7262 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
7263
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7264 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7265 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
7266 pWdaParams->pWdaContext = pWDA;
7267
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7268 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7269 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
7270
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7271 if(IS_WDI_STATUS_FAILURE(status))
7272 {
7273 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7274 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7275 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7276 vos_mem_free(pWdaParams->wdaMsgParam);
7277 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7278 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7279 return CONVERT_WDI2VOS_STATUS(status);
7280
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7281}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7282
7283#ifdef FEATURE_WLAN_TDLS
7284/*
7285 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7286 * Free the memory. No need to send any response to PE in this case
7287 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7288void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
7289 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7290{
7291 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7292 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7293 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7294
7295
7296 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7297 "<------ %s " ,__func__);
7298 if(NULL == pWdaParams)
7299 {
7300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7301 "%s: pWdaParams received NULL", __func__);
7302 VOS_ASSERT(0) ;
7303 return ;
7304 }
7305 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7306
7307 if(NULL == pWdaParams)
7308 {
7309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7310 "%s: pWdaParams received NULL", __func__);
7311 VOS_ASSERT(0) ;
7312 return ;
7313 }
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7314 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
7315 if( NULL == pTdlsLinkEstablishParams )
7316 {
7317 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7318 "%s: pTdlsLinkEstablishParams "
7319 "received NULL " ,__func__);
7320 VOS_ASSERT(0);
7321 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7322 vos_mem_free(pWdaParams);
7323 return ;
7324 }
7325 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
7326 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7327 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7328 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7329 /* send response to UMAC*/
7330 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
7331
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7332 return ;
7333}
7334
7335VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
7336 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
7337{
7338 WDI_Status status = WDI_STATUS_SUCCESS ;
7339 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
7340 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
7341 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
7342 tWDA_ReqParams *pWdaParams = NULL;
7343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7344 "------> %s " ,__func__);
7345 if(NULL == wdiSetTDLSLinkEstablishReqParam)
7346 {
7347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7348 "%s: VOS MEM Alloc Failure", __func__);
7349 VOS_ASSERT(0);
7350 return VOS_STATUS_E_NOMEM;
7351 }
7352 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7353 if(NULL == pWdaParams)
7354 {
7355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7356 "%s: VOS MEM Alloc Failure", __func__);
7357 vos_mem_free(pTdlsLinkEstablishParams);
7358 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
7359 VOS_ASSERT(0);
7360 return VOS_STATUS_E_NOMEM;
7361 }
7362 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7363 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7364 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7365 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7366 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7367 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7368 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7369 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7370 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7371 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]7372 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
7373 pTdlsLinkEstablishParams->isOffChannelSupported;
7374
7375 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
7376 pTdlsLinkEstablishParams->validChannels,
7377 pTdlsLinkEstablishParams->validChannelsLen);
7378
7379 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
7380 pTdlsLinkEstablishParams->validChannelsLen;
7381
7382 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
7383 pTdlsLinkEstablishParams->validOperClasses,
7384 pTdlsLinkEstablishParams->validOperClassesLen);
7385 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
7386 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7387
7388 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
7389 /* Store msg pointer from PE, as this will be used for response */
7390 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
7391 /* store Params pass it to WDI */
7392 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
7393 pWdaParams->pWdaContext = pWDA;
7394
7395 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
7396 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
7397 WDA_SetTDLSLinkEstablishReqParamsCallback,
7398 pWdaParams);
7399 if(IS_WDI_STATUS_FAILURE(status))
7400 {
7401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7402 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
7403 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7404 vos_mem_free(pWdaParams->wdaMsgParam);
7405 vos_mem_free(pWdaParams);
7406 }
7407 return CONVERT_WDI2VOS_STATUS(status);
7408}
7409#endif
7410
7411
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7412#ifdef WLAN_FEATURE_VOWIFI_11R
7413/*
7414 * FUNCTION: WDA_AggrAddTSReqCallback
7415 * send ADD AGGREGATED TS RSP back to PE
7416 */
7417void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
7418{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7419 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7420 tWDA_CbContext *pWDA;
7421 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7422 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7423 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7424 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7425 if(NULL == pWdaParams)
7426 {
7427 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7428 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7429 VOS_ASSERT(0) ;
7430 return ;
7431 }
7432
7433 pWDA = pWdaParams->pWdaContext;
7434 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7435
7436 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7437 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7438 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7439 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7440 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7441
7442 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7443 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7444 return ;
7445}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7446/*
7447 * FUNCTION: WDA_ProcessAddTSReq
7448 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
7449 */
7450VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
7451 tAggrAddTsParams *pAggrAddTsReqParams)
7452{
7453 WDI_Status status = WDI_STATUS_SUCCESS ;
7454 int i;
7455 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7456 tWDA_ReqParams *pWdaParams = NULL;
7457
7458
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7460 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7461 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
7462 sizeof(WDI_AggrAddTSReqParamsType)) ;
7463 if(NULL == wdiAggrAddTSReqParam)
7464 {
7465 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7466 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7467 VOS_ASSERT(0);
7468 return VOS_STATUS_E_NOMEM;
7469 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7470
7471
7472 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7473 if(NULL == pWdaParams)
7474 {
7475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7476 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7477 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7478 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7479 VOS_ASSERT(0);
7480 return VOS_STATUS_E_NOMEM;
7481 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7482 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
7483 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
7484 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7485 for( i = 0; i < WDI_MAX_NO_AC; i++ )
7486 {
7487 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
7488 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
7489 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7490 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
7491 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
7492 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
7493 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
7494 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
7495 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
7496 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
7497 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
7498 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
7499 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
7500 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
7501 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
7502 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
7503 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
7504 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
7505 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7506 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
7507 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7508 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
7509 pAggrAddTsReqParams->tspec[i].nomMsduSz;
7510 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
7511 pAggrAddTsReqParams->tspec[i].maxMsduSz;
7512 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
7513 pAggrAddTsReqParams->tspec[i].minSvcInterval;
7514 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
7515 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
7516 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
7517 pAggrAddTsReqParams->tspec[i].inactInterval;
7518 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
7519 pAggrAddTsReqParams->tspec[i].suspendInterval;
7520 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
7521 pAggrAddTsReqParams->tspec[i].svcStartTime;
7522 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
7523 pAggrAddTsReqParams->tspec[i].minDataRate;
7524 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
7525 pAggrAddTsReqParams->tspec[i].meanDataRate;
7526 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
7527 pAggrAddTsReqParams->tspec[i].peakDataRate;
7528 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
7529 pAggrAddTsReqParams->tspec[i].maxBurstSz;
7530 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
7531 pAggrAddTsReqParams->tspec[i].delayBound;
7532 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
7533 pAggrAddTsReqParams->tspec[i].minPhyRate;
7534 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
7535 pAggrAddTsReqParams->tspec[i].surplusBw;
7536 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
7537 pAggrAddTsReqParams->tspec[i].mediumTime;
7538 }
7539
7540 /* TODO: tAggrAddTsParams doesn't have the following fields */
7541#if 0
7542 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7543 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
7544 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7545 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7546#endif
7547 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
7548
7549 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7550 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7551 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7552 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
7553
7554 pWdaParams->pWdaContext = pWDA;
7555
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7556 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7557 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
7558
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7559 if(IS_WDI_STATUS_FAILURE(status))
7560 {
7561 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7562 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7563 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7564 vos_mem_free(pWdaParams);
7565
7566 /* send the failure response back to PE*/
7567 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7568 {
7569 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
7570 }
7571
7572 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
7573 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7574 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7575 return CONVERT_WDI2VOS_STATUS(status) ;
7576}
7577#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7578/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7579 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7580 * send Enter IMPS RSP back to PE
7581 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7582void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7583{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7584 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7585 tWDA_CbContext *pWDA;
7586
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7588 "<------ %s status=%d" ,__func__,status);
7589 if(NULL == pWdaParams)
7590 {
7591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7592 "%s: pWdaParams received NULL", __func__);
7593 VOS_ASSERT(0);
7594 return;
7595 }
7596
7597 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7598
7599 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7600 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7601 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7602 return ;
7603}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7604
7605
7606/*
7607 * FUNCTION: WDA_EnterImpsReqCallback
7608 * Free memory and send Enter IMPS RSP back to PE.
7609 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
7610 */
7611void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7612{
7613 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7614 tWDA_CbContext *pWDA;
7615
7616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7617 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7618
7619 if(NULL == pWdaParams)
7620 {
7621 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7622 "%s: pWdaParams received NULL", __func__);
7623 VOS_ASSERT(0);
7624 return;
7625 }
7626
7627 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7628
7629 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7630 {
7631 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7632 vos_mem_free(pWdaParams);
7633 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7634 CONVERT_WDI2SIR_STATUS(wdiStatus));
7635 }
7636
7637 return;
7638}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7639/*
7640 * FUNCTION: WDA_ProcessEnterImpsReq
7641 * Request to WDI to Enter IMPS power state.
7642 */
7643VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
7644{
7645 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7646 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
7647 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7649 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7650
7651
7652 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
7653 if (NULL == wdiEnterImpsReqParams)
7654 {
7655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7656 "%s: VOS MEM Alloc Failure", __func__);
7657 VOS_ASSERT(0);
7658 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7659 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7660 return VOS_STATUS_E_NOMEM;
7661 }
7662
7663 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7664 if (NULL == pWdaParams)
7665 {
7666 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7667 "%s: VOS MEM Alloc Failure", __func__);
7668 VOS_ASSERT(0);
7669 vos_mem_free(wdiEnterImpsReqParams);
7670 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
7671 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7672 return VOS_STATUS_E_NOMEM;
7673 }
7674
7675 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
7676 wdiEnterImpsReqParams->pUserData = pWdaParams;
7677
7678 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
7679 pWdaParams->wdaMsgParam = NULL;
7680 pWdaParams->pWdaContext = pWDA;
7681
7682 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
7683 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
7684 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7685 if(IS_WDI_STATUS_FAILURE(status))
7686 {
7687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7688 "Failure in Enter IMPS REQ WDI API, free all the memory " );
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7689 vos_mem_free(wdiEnterImpsReqParams);
7690 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7691 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7692 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7693 return CONVERT_WDI2VOS_STATUS(status) ;
7694}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7695/*
7696 * FUNCTION: WDA_ExitImpsReqCallback
7697 * send Exit IMPS RSP back to PE
7698 */
7699void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
7700{
7701 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7703 "<------ %s " ,__func__);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7704 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7705 return ;
7706}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7707/*
7708 * FUNCTION: WDA_ProcessExitImpsReq
7709 * Request to WDI to Exit IMPS power state.
7710 */
7711VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
7712{
7713 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7715 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7716 status = WDI_ExitImpsReq((WDI_ExitImpsRspCb)WDA_ExitImpsReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7717 if(IS_WDI_STATUS_FAILURE(status))
7718 {
7719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7720 "Failure in Exit IMPS REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7721 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7722 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7723 return CONVERT_WDI2VOS_STATUS(status) ;
7724}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7725/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7726 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7727 * send Enter BMPS RSP back to PE
7728 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7729void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7730{
7731 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7732 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7733 tEnterBmpsParams *pEnterBmpsRspParams;
7734
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7736 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7737 if(NULL == pWdaParams)
7738 {
7739 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7740 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7741 VOS_ASSERT(0) ;
7742 return ;
7743 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7744
7745 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7746 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
7747
7748 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7749 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7750
7751 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7752 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7753 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
7754
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7755 return ;
7756}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7757/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7758 * FUNCTION: WDA_EnterBmpsReqCallback
7759 * Free memory and send Enter BMPS RSP back to PE.
7760 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
7761 */
7762void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7763{
7764 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7765 tWDA_CbContext *pWDA;
7766 tEnterBmpsParams *pEnterBmpsRspParams;
7767
7768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7769 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7770
7771 if(NULL == pWdaParams)
7772 {
7773 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7774 "%s: pWdaParams received NULL", __func__);
7775 VOS_ASSERT(0);
7776 return;
7777 }
7778
7779 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7780 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
7781 pEnterBmpsRspParams->status = wdiStatus;
7782
7783 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7784 {
7785 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7786 vos_mem_free(pWdaParams);
7787 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
7788 }
7789
7790 return;
7791}
7792/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7793 * FUNCTION: WDA_ProcessEnterBmpsReq
7794 * Request to WDI to Enter BMPS power state.
7795 */
7796VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
7797 tEnterBmpsParams *pEnterBmpsReqParams)
7798{
7799 WDI_Status status = WDI_STATUS_SUCCESS;
7800 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
7801 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7803 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7804 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
7805 {
7806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7807 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7808 VOS_ASSERT(0);
7809 return VOS_STATUS_E_FAILURE;
7810 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7811 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
7812 if (NULL == wdiEnterBmpsReqParams)
7813 {
7814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7815 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7816 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7817 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
7818 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7819 return VOS_STATUS_E_NOMEM;
7820 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7821 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7822 if (NULL == pWdaParams)
7823 {
7824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7825 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7826 VOS_ASSERT(0);
7827 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7828 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
7829 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7830 return VOS_STATUS_E_NOMEM;
7831 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7832 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
7833 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
7834 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
7835 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7836 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7837 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
7838 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
7839 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7840 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
7841 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7842
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7843 /* Store param pointer as passed in by caller */
7844 /* store Params pass it to WDI */
7845 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7846 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7847 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7848 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7849 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7850 if (IS_WDI_STATUS_FAILURE(status))
7851 {
7852 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7853 "Failure in Enter BMPS REQ WDI API, free all the memory" );
7854 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7855 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7856 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7857 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7858 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7859 return CONVERT_WDI2VOS_STATUS(status);
7860}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7861
7862
7863static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
7864 WDI_Status wdiStatus,
7865 tExitBmpsParams *pExitBmpsReqParams)
7866{
7867 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
7868
7869 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
7870}
7871
7872
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7873/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7874 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7875 * send Exit BMPS RSP back to PE
7876 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7877void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7878{
7879 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7880 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7881 tExitBmpsParams *pExitBmpsRspParams;
7882
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7884 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7885 if(NULL == pWdaParams)
7886 {
7887 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7888 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7889 VOS_ASSERT(0) ;
7890 return ;
7891 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7892
7893 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7894 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
7895
7896 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7897 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7898
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7899 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7900 vos_mem_free(pWdaParams) ;
7901
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7902 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7903 return ;
7904}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7905/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7906 * FUNCTION: WDA_ExitBmpsReqCallback
7907 * Free memory and send Exit BMPS RSP back to PE.
7908 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
7909 */
7910void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7911{
7912 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7913 tWDA_CbContext *pWDA;
7914 tExitBmpsParams *pExitBmpsRspParams;
7915
7916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7917 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7918
7919 if(NULL == pWdaParams)
7920 {
7921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7922 "%s: pWdaParams received NULL", __func__);
7923 VOS_ASSERT(0);
7924 return;
7925 }
7926
7927 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7928 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
7929 pExitBmpsRspParams->status = wdiStatus;
7930
7931 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7932 {
7933 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7934 vos_mem_free(pWdaParams);
7935 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
7936 }
7937
7938 return;
7939}
7940/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7941 * FUNCTION: WDA_ProcessExitBmpsReq
7942 * Request to WDI to Exit BMPS power state.
7943 */
7944VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
7945 tExitBmpsParams *pExitBmpsReqParams)
7946{
7947 WDI_Status status = WDI_STATUS_SUCCESS ;
7948 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
7949 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
7950 sizeof(WDI_ExitBmpsReqParamsType)) ;
7951 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7953 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7954 if(NULL == wdiExitBmpsReqParams)
7955 {
7956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7957 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7958 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7959 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7960 return VOS_STATUS_E_NOMEM;
7961 }
7962 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7963 if(NULL == pWdaParams)
7964 {
7965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7966 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7967 VOS_ASSERT(0);
7968 vos_mem_free(wdiExitBmpsReqParams);
7969 return VOS_STATUS_E_NOMEM;
7970 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7971 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7972
7973 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
7974
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7975 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
7976 wdiExitBmpsReqParams->pUserData = pWdaParams;
7977
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7978 /* Store param pointer as passed in by caller */
7979 /* store Params pass it to WDI */
7980 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
7981 pWdaParams->pWdaContext = pWDA;
7982 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7983 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7984 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7985 if(IS_WDI_STATUS_FAILURE(status))
7986 {
7987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7988 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7989 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7990 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7991 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7992 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7993 return CONVERT_WDI2VOS_STATUS(status) ;
7994}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7995/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7996 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7997 * send Enter UAPSD RSP back to PE
7998 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7999void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8000{
8001 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8002 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8003 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8005 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8006 if(NULL == pWdaParams)
8007 {
8008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8009 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8010 VOS_ASSERT(0) ;
8011 return ;
8012 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8013
8014 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8015 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8016
8017 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8018 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8019
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8020 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8021 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8022 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8023 return ;
8024}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8025/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8026 * FUNCTION: WDA_EnterUapsdReqCallback
8027 * Free memory and send Enter UAPSD RSP back to PE.
8028 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
8029 */
8030void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8031{
8032 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8033 tWDA_CbContext *pWDA;
8034 tUapsdParams *pEnterUapsdRsqParams;
8035
8036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8037 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8038
8039 if(NULL == pWdaParams)
8040 {
8041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8042 "%s: pWdaParams received NULL", __func__);
8043 VOS_ASSERT(0);
8044 return;
8045 }
8046
8047 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8048 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8049 pEnterUapsdRsqParams->status = wdiStatus;
8050
8051 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8052 {
8053 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8054 vos_mem_free(pWdaParams);
8055 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
8056 }
8057
8058 return;
8059}
8060/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8061 * FUNCTION: WDA_ProcessEnterUapsdReq
8062 * Request to WDI to Enter UAPSD power state.
8063 */
8064VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
8065 tUapsdParams *pEnterUapsdReqParams)
8066{
8067 WDI_Status status = WDI_STATUS_SUCCESS ;
8068 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
8069 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
8070 sizeof(WDI_EnterUapsdReqParamsType)) ;
8071 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8072 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8073 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8074 if(NULL == wdiEnterUapsdReqParams)
8075 {
8076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8077 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8078 VOS_ASSERT(0);
8079 return VOS_STATUS_E_NOMEM;
8080 }
8081 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8082 if(NULL == pWdaParams)
8083 {
8084 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8085 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8086 VOS_ASSERT(0);
8087 vos_mem_free(wdiEnterUapsdReqParams);
8088 return VOS_STATUS_E_NOMEM;
8089 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8090 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
8091 pEnterUapsdReqParams->beDeliveryEnabled;
8092 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
8093 pEnterUapsdReqParams->beTriggerEnabled;
8094 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
8095 pEnterUapsdReqParams->bkDeliveryEnabled;
8096 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
8097 pEnterUapsdReqParams->bkTriggerEnabled;
8098 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
8099 pEnterUapsdReqParams->viDeliveryEnabled;
8100 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
8101 pEnterUapsdReqParams->viTriggerEnabled;
8102 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
8103 pEnterUapsdReqParams->voDeliveryEnabled;
8104 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
8105 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8106 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8107
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8108 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
8109 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8110
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8111 /* Store param pointer as passed in by caller */
8112 /* store Params pass it to WDI */
8113 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
8114 pWdaParams->pWdaContext = pWDA;
8115 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8116 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8117 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8118 if(IS_WDI_STATUS_FAILURE(status))
8119 {
8120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8121 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
8122 vos_mem_free(pWdaParams->wdaMsgParam) ;
8123 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8124 vos_mem_free(pWdaParams) ;
8125 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8126 return CONVERT_WDI2VOS_STATUS(status) ;
8127}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8128/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8129 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8130 * send Exit UAPSD RSP back to PE
8131 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8132void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8133{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8134
8135 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8136 tWDA_CbContext *pWDA;
8137 tExitUapsdParams *pExitUapsdRspParams;
8138
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8140 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8141 if(NULL == pWdaParams)
8142 {
8143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8144 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8145 VOS_ASSERT(0);
8146 return;
8147 }
8148
8149 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8150 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8151
8152 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8153 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8154
8155 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8156 vos_mem_free(pWdaParams) ;
8157
8158 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8159 return ;
8160}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8161/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8162 * FUNCTION: WDA_ExitUapsdReqCallback
8163 * Free memory and send Exit UAPSD RSP back to PE.
8164 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
8165 */
8166void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8167{
8168 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8169 tWDA_CbContext *pWDA;
8170 tExitUapsdParams *pExitUapsdRspParams;
8171
8172 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8173 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8174
8175 if(NULL == pWdaParams)
8176 {
8177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8178 "%s: pWdaParams received NULL", __func__);
8179 VOS_ASSERT(0);
8180 return;
8181 }
8182
8183 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8184 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8185 pExitUapsdRspParams->status = wdiStatus;
8186
8187 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8188 {
8189 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8190 vos_mem_free(pWdaParams);
8191 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
8192 }
8193
8194 return;
8195}
8196/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8197 * FUNCTION: WDA_ProcessExitUapsdReq
8198 * Request to WDI to Exit UAPSD power state.
8199 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8200VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
8201 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8202{
8203 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8204 tWDA_ReqParams *pWdaParams ;
8205 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
8206 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
8207 sizeof(WDI_ExitUapsdReqParamsType)) ;
8208
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8210 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8211
8212 if(NULL == wdiExitUapsdReqParams)
8213 {
8214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8215 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8216 VOS_ASSERT(0);
8217 return VOS_STATUS_E_NOMEM;
8218 }
8219 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8220 if(NULL == pWdaParams)
8221 {
8222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8223 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8224 VOS_ASSERT(0);
8225 vos_mem_free(wdiExitUapsdReqParams);
8226 return VOS_STATUS_E_NOMEM;
8227 }
8228
8229 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8230 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
8231 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8232
8233 /* Store param pointer as passed in by caller */
8234 /* store Params pass it to WDI */
8235 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
8236 pWdaParams->pWdaContext = pWDA;
8237 pWdaParams->wdaMsgParam = pExitUapsdParams;
8238
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8239 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8240 if(IS_WDI_STATUS_FAILURE(status))
8241 {
8242 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8243 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8244 vos_mem_free(pWdaParams->wdaMsgParam) ;
8245 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8246 vos_mem_free(pWdaParams) ;
8247
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8248 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8249 return CONVERT_WDI2VOS_STATUS(status) ;
8250}
8251
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8252/*
8253 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
8254 *
8255 */
8256void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
8257{
8258 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8260 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8261 if(NULL == pWdaParams)
8262 {
8263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8264 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8265 VOS_ASSERT(0) ;
8266 return ;
8267 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8268 if( pWdaParams != NULL )
8269 {
8270 if( pWdaParams->wdaWdiApiMsgParam != NULL )
8271 {
8272 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8273 }
8274 if( pWdaParams->wdaMsgParam != NULL )
8275 {
8276 vos_mem_free(pWdaParams->wdaMsgParam) ;
8277 }
8278 vos_mem_free(pWdaParams) ;
8279 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8280 return ;
8281}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8282/*
8283 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
8284 * Request to WDI to set the power save params at start.
8285 */
8286VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
8287 tSirPowerSaveCfg *pPowerSaveCfg)
8288{
8289 WDI_Status status = WDI_STATUS_SUCCESS ;
8290 tHalCfg *tlvStruct = NULL ;
8291 tANI_U8 *tlvStructStart = NULL ;
8292 v_PVOID_t *configParam;
8293 tANI_U32 configParamSize;
8294 tANI_U32 *configDataValue;
8295 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
8296 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8298 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8299 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
8300 {
8301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8302 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8303 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8304 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8305 return VOS_STATUS_E_FAILURE;
8306 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8307 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
8308 if (NULL == wdiPowerSaveCfg)
8309 {
8310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8311 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8312 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8313 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8314 return VOS_STATUS_E_NOMEM;
8315 }
8316 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8317 if(NULL == pWdaParams)
8318 {
8319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8320 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8321 VOS_ASSERT(0);
8322 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8323 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8324 return VOS_STATUS_E_NOMEM;
8325 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8326 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
8327 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8328 if(NULL == configParam)
8329 {
8330 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8331 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8332 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8333 vos_mem_free(pWdaParams);
8334 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8335 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8336 return VOS_STATUS_E_NOMEM;
8337 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8338 vos_mem_set(configParam, configParamSize, 0);
8339 wdiPowerSaveCfg->pConfigBuffer = configParam;
8340 tlvStruct = (tHalCfg *)configParam;
8341 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8342 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
8343 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
8344 tlvStruct->length = sizeof(tANI_U32);
8345 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8346 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8347 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8348 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8349 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
8350 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
8351 tlvStruct->length = sizeof(tANI_U32);
8352 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8353 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8354 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8355 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8356 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
8357 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
8358 tlvStruct->length = sizeof(tANI_U32);
8359 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8360 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8361 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8362 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8363 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
8364 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
8365 tlvStruct->length = sizeof(tANI_U32);
8366 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8367 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8368 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8369 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8370 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
8371 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
8372 tlvStruct->length = sizeof(tANI_U32);
8373 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8374 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8375 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8376 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8377 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
8378 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
8379 tlvStruct->length = sizeof(tANI_U32);
8380 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8381 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8382 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8383 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8384 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
8385 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
8386 tlvStruct->length = sizeof(tANI_U32);
8387 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8388 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8389 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8390 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8391 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
8392 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
8393 tlvStruct->length = sizeof(tANI_U32);
8394 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8395 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
8396 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8397 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8398 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
8399 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
8400 tlvStruct->length = sizeof(tANI_U32);
8401 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8402 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
8403 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8404 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8405 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
8406 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
8407 tlvStruct->length = sizeof(tANI_U32);
8408 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8409 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8410 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8411 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8412 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
8413 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
8414 tlvStruct->length = sizeof(tANI_U32);
8415 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8416 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8417 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8418 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8419 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8420 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8421 /* store Params pass it to WDI */
8422 pWdaParams->wdaMsgParam = configParam;
8423 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
8424 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8425 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
8426 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8427 if(IS_WDI_STATUS_FAILURE(status))
8428 {
8429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8430 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
8431 vos_mem_free(pWdaParams->wdaMsgParam);
8432 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8433 vos_mem_free(pWdaParams);
8434 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8435 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8436 return CONVERT_WDI2VOS_STATUS(status);
8437}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8438/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8439 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8440 *
8441 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8442void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8443{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8444 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8445
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8447 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8448
8449 if(NULL == pWdaParams)
8450 {
8451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8452 "%s: pWdaParams received NULL", __func__);
8453 VOS_ASSERT(0);
8454 return ;
8455 }
8456
8457 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8458 vos_mem_free(pWdaParams);
8459
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8460 return ;
8461}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8462/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8463 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
8464 * Free memory.
8465 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
8466 */
8467void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8468{
8469 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8470
8471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8472 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8473
8474 if(NULL == pWdaParams)
8475 {
8476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8477 "%s: pWdaParams received NULL", __func__);
8478 VOS_ASSERT(0);
8479 return;
8480 }
8481
8482 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8483 {
8484 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8485 vos_mem_free(pWdaParams);
8486 }
8487
8488 return;
8489}
8490/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8491 * FUNCTION: WDA_SetUapsdAcParamsReq
8492 * Request to WDI to set the UAPSD params for an ac (sta mode).
8493 */
8494VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
8495 tUapsdInfo *pUapsdInfo)
8496{
8497 WDI_Status status = WDI_STATUS_SUCCESS;
8498 tWDA_CbContext *pWDA = NULL ;
8499 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
8500 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
8501 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
8502 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8504 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8505 if(NULL == wdiUapsdParams)
8506 {
8507 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8508 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8509 VOS_ASSERT(0);
8510 return VOS_STATUS_E_NOMEM;
8511 }
8512 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8513 if(NULL == pWdaParams)
8514 {
8515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8516 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8517 VOS_ASSERT(0);
8518 vos_mem_free(wdiUapsdParams);
8519 return VOS_STATUS_E_NOMEM;
8520 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8521 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
8522 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
8523 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
8524 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
8525 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
8526 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8527 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
8528 wdiUapsdParams->pUserData = pWdaParams;
8529
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8530 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8531 pWdaParams->pWdaContext = pWDA;
8532 /* Store param pointer as passed in by caller */
8533 pWdaParams->wdaMsgParam = pUapsdInfo;
8534 /* store Params pass it to WDI */
8535 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8536 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8537 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8538 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8539 if(IS_WDI_STATUS_FAILURE(status))
8540 {
8541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8542 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
8543 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8544 vos_mem_free(pWdaParams);
8545 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8546 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
8547 return VOS_STATUS_SUCCESS;
8548 else
8549 return VOS_STATUS_E_FAILURE;
8550
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8551}
8552/*
8553 * FUNCTION: WDA_ClearUapsdAcParamsReq
8554 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
8555 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
8556 * and again enter the UPASD with the modified params. Hence the disable
8557 * function was kept empty.
8558 *
8559 */
8560VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
8561{
8562 /* do nothing */
8563 return VOS_STATUS_SUCCESS;
8564}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8565/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8566 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8567 *
8568 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8569void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8570{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8571 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8572
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8573 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8574 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8575
8576 if(NULL == pWdaParams)
8577 {
8578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8579 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8580 VOS_ASSERT(0) ;
8581 return ;
8582 }
8583
8584 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8585 vos_mem_free(pWdaParams->wdaMsgParam);
8586 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8587
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8588 //print a msg, nothing else to do
8589 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8590 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8591 return ;
8592}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8593/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8594 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
8595 * Free memory.
8596 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
8597 */
8598void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8599{
8600 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8601
8602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8603 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8604
8605 if(NULL == pWdaParams)
8606 {
8607 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8608 "%s: pWdaParams received NULL", __func__);
8609 VOS_ASSERT(0);
8610 return;
8611 }
8612
8613 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8614 {
8615 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8616 vos_mem_free(pWdaParams->wdaMsgParam);
8617 vos_mem_free(pWdaParams);
8618 }
8619
8620 return;
8621}
8622/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8623 * FUNCTION: WDA_UpdateUapsdParamsReq
8624 * Request to WDI to update UAPSD params (in softAP mode) for a station.
8625 */
8626VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
8627 tUpdateUapsdParams* pUpdateUapsdInfo)
8628{
8629 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8630 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8631 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
8632 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
8633 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8634 tWDA_ReqParams *pWdaParams = NULL;
8635
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8637 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8638 if(NULL == wdiUpdateUapsdParams)
8639 {
8640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8641 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8642 VOS_ASSERT(0);
8643 return VOS_STATUS_E_NOMEM;
8644 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8645 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
8646 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
8647 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8648 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
8649 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8650
8651 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8652 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8653 {
8654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8655 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8656 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8657 vos_mem_free(pUpdateUapsdInfo);
8658 vos_mem_free(wdiUpdateUapsdParams);
8659 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8660 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8661 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8662 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8663 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8664 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
8665 pWdaParams->pWdaContext = pWDA;
8666
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8667 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8668 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8669 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8670
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8671 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8672 {
8673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8674 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8675 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
8676 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8677 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8678 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8679 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8680 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8681}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8682/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8683 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8684 *
8685 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8686void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8687{
8688 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8689 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8690 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8691 if(WDI_STATUS_SUCCESS != wdiStatus)
8692 {
8693 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8694 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8695 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8696 if(NULL == pWdaParams)
8697 {
8698 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8699 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8700 VOS_ASSERT(0) ;
8701 return ;
8702 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8703 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8704 vos_mem_free(pWdaParams->wdaMsgParam);
8705 vos_mem_free(pWdaParams);
8706 return ;
8707}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8708/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8709 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
8710 * Free memory.
8711 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
8712 */
8713void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8714{
8715 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8716
8717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8718 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8719
8720 if(NULL == pWdaParams)
8721 {
8722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8723 "%s: pWdaParams received NULL", __func__);
8724 VOS_ASSERT(0);
8725 return;
8726 }
8727
8728 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8729 {
8730 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8731 vos_mem_free(pWdaParams->wdaMsgParam);
8732 vos_mem_free(pWdaParams);
8733 }
8734
8735 return;
8736}
8737/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8738 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
8739 *
8740 */
8741VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
8742 tSirWlanSetRxpFilters *pWlanSuspendParam)
8743{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8744 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8745 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8746 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8747 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8748 /* Sanity Check
8749 * This is very unlikely and add assert to collect more info next time */
8750 if(NULL == pWlanSuspendParam)
8751 {
8752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8753 "%s: pWlanSuspendParam received NULL", __func__);
8754 VOS_ASSERT(0) ;
8755 return VOS_STATUS_E_FAULT;
8756 }
8757 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
8758 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8759 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8760 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8761 if(NULL == wdiRxpFilterParams)
8762 {
8763 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8764 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8765 VOS_ASSERT(0);
8766 vos_mem_free(pWlanSuspendParam);
8767 return VOS_STATUS_E_NOMEM;
8768 }
8769 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8770 if(NULL == pWdaParams)
8771 {
8772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8773 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8774 VOS_ASSERT(0);
8775 vos_mem_free(wdiRxpFilterParams);
8776 vos_mem_free(pWlanSuspendParam);
8777 return VOS_STATUS_E_NOMEM;
8778 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8779 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
8780 pWlanSuspendParam->setMcstBcstFilter;
8781 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
8782 pWlanSuspendParam->configuredMcstBcstFilterSetting;
8783
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8784 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
8785 wdiRxpFilterParams->pUserData = pWdaParams;
8786
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8787 pWdaParams->pWdaContext = pWDA;
8788 pWdaParams->wdaMsgParam = pWlanSuspendParam;
8789 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8790 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8791 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8792 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8793 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8794 {
8795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8796 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8797 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8798 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8799 vos_mem_free(pWdaParams->wdaMsgParam);
8800 vos_mem_free(pWdaParams);
8801 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8802 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8803}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8804/*
8805 * FUNCTION: WDA_WdiIndicationCallback
8806 *
8807 */
8808void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
8809 void* pUserData)
8810{
8811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8812 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8813}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8814/*
8815 * FUNCTION: WDA_ProcessWlanSuspendInd
8816 *
8817 */
8818VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
8819 tSirWlanSuspendParam *pWlanSuspendParam)
8820{
8821 WDI_Status wdiStatus;
8822 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8824 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8825 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
8826 pWlanSuspendParam->configuredMcstBcstFilterSetting;
8827 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
8828 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8829 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]8830 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
8831 if(WDI_STATUS_PENDING == wdiStatus)
8832 {
8833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8834 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8835 }
8836 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
8837 {
8838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8839 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8840 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8841 vos_mem_free(pWlanSuspendParam);
8842 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8843}
8844
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]8845#ifdef WLAN_FEATURE_11W
8846/*
8847 * FUNCTION: WDA_ProcessExcludeUnecryptInd
8848 *
8849 */
8850VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
8851 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
8852{
8853 WDI_Status wdiStatus;
8854 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
8855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8856 "------> %s ", __func__);
8857
8858 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
8859 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
8860 sizeof(tSirMacAddr));
8861
8862 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
8863 wdiExclUnencryptParams.pUserData = pWDA;
8864
8865 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
8866 if(WDI_STATUS_PENDING == wdiStatus)
8867 {
8868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8869 "Pending received for %s:%d ", __func__, __LINE__ );
8870 }
8871 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
8872 {
8873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8874 "Failure in %s:%d ", __func__, __LINE__ );
8875 }
8876 vos_mem_free(pExclUnencryptParam);
8877 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8878}
8879#endif
8880
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8881/*
8882 * FUNCTION: WDA_ProcessWlanResumeCallback
8883 *
8884 */
8885void WDA_ProcessWlanResumeCallback(
8886 WDI_SuspendResumeRspParamsType *resumeRspParams,
8887 void* pUserData)
8888{
8889 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8891 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8892 if(NULL == pWdaParams)
8893 {
8894 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8895 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8896 VOS_ASSERT(0) ;
8897 return ;
8898 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8899 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
8900 {
8901 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8902 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8903 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8904 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8905 vos_mem_free(pWdaParams->wdaMsgParam);
8906 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8907 return ;
8908}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8909/*
8910 * FUNCTION: WDA_ProcessWlanResumeReq
8911 *
8912 */
8913VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
8914 tSirWlanResumeParam *pWlanResumeParam)
8915{
8916 WDI_Status wdiStatus;
8917 WDI_ResumeParamsType *wdiResumeParams =
8918 (WDI_ResumeParamsType *)vos_mem_malloc(
8919 sizeof(WDI_ResumeParamsType) ) ;
8920 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8922 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8923 if(NULL == wdiResumeParams)
8924 {
8925 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8926 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8927 VOS_ASSERT(0);
8928 return VOS_STATUS_E_NOMEM;
8929 }
8930 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8931 if(NULL == pWdaParams)
8932 {
8933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8934 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8935 VOS_ASSERT(0);
8936 vos_mem_free(wdiResumeParams);
8937 return VOS_STATUS_E_NOMEM;
8938 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8939 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
8940 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8941 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]8942 wdiResumeParams->wdiReqStatusCB = NULL;
8943 pWdaParams->wdaMsgParam = pWlanResumeParam;
8944 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
8945 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8946 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
8947 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
8948 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8949 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8950 {
8951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8952 "Failure in Host Resume REQ WDI API, free all the memory " );
8953 VOS_ASSERT(0);
8954 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8955 vos_mem_free(pWdaParams->wdaMsgParam);
8956 vos_mem_free(pWdaParams);
8957 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8958 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8959}
8960
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8961/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8962 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8963 *
8964 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8965void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8966{
8967 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8969 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8970 if(NULL == pWdaParams)
8971 {
8972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8973 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8974 VOS_ASSERT(0) ;
8975 return ;
8976 }
8977
8978 vos_mem_free(pWdaParams->wdaMsgParam) ;
8979 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8980 vos_mem_free(pWdaParams) ;
8981 /*
8982 * No respone required for SetBeaconFilter req so just free the request
8983 * param here
8984 */
8985
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8986 return ;
8987}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8988/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8989 * FUNCTION: WDA_SetBeaconFilterReqCallback
8990 * Free memory.
8991 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
8992 */
8993void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8994{
8995 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8996
8997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8998 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8999
9000 if(NULL == pWdaParams)
9001 {
9002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9003 "%s: pWdaParams received NULL", __func__);
9004 VOS_ASSERT(0);
9005 return;
9006 }
9007
9008 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9009 {
9010 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9011 vos_mem_free(pWdaParams->wdaMsgParam);
9012 vos_mem_free(pWdaParams);
9013 }
9014
9015 return;
9016}
9017/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9018 * FUNCTION: WDA_SetBeaconFilterReq
9019 * Request to WDI to send the beacon filtering related information.
9020 */
9021VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
9022 tBeaconFilterMsg* pBeaconFilterInfo)
9023{
9024 WDI_Status status = WDI_STATUS_SUCCESS;
9025 tANI_U8 *dstPtr, *srcPtr;
9026 tANI_U8 filterLength;
9027 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
9028 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
9029 sizeof(WDI_BeaconFilterReqParamsType) ) ;
9030 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9032 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9033 if(NULL == wdiBeaconFilterInfo)
9034 {
9035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9036 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9037 VOS_ASSERT(0);
9038 return VOS_STATUS_E_NOMEM;
9039 }
9040 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9041 if(NULL == pWdaParams)
9042 {
9043 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9044 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9045 VOS_ASSERT(0);
9046 vos_mem_free(wdiBeaconFilterInfo);
9047 return VOS_STATUS_E_NOMEM;
9048 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9049 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
9050 pBeaconFilterInfo->beaconInterval;
9051 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
9052 pBeaconFilterInfo->capabilityInfo;
9053 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
9054 pBeaconFilterInfo->capabilityMask;
9055 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]9056
9057 //Fill the BssIdx
9058 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
9059
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9060 //Fill structure with info contained in the beaconFilterTable
9061 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
9062 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
9063 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
9064 if(WDI_BEACON_FILTER_LEN < filterLength)
9065 {
9066 filterLength = WDI_BEACON_FILTER_LEN;
9067 }
9068 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9069 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
9070 wdiBeaconFilterInfo->pUserData = pWdaParams;
9071
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9072 /* Store param pointer as passed in by caller */
9073 /* store Params pass it to WDI */
9074 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
9075 pWdaParams->pWdaContext = pWDA;
9076 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
9077
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9078 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9079 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9080 if(IS_WDI_STATUS_FAILURE(status))
9081 {
9082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9083 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
9084 vos_mem_free(pWdaParams->wdaMsgParam) ;
9085 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9086 vos_mem_free(pWdaParams) ;
9087 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9088 return CONVERT_WDI2VOS_STATUS(status) ;
9089}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9090/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9091 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9092 *
9093 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9094void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9095{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9096 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9097
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9099 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9100
9101 if(NULL == pWdaParams)
9102 {
9103 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9104 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9105 VOS_ASSERT(0) ;
9106 return ;
9107 }
9108
9109 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9110 vos_mem_free(pWdaParams->wdaMsgParam);
9111 vos_mem_free(pWdaParams);
9112
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9113 //print a msg, nothing else to do
9114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9115 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9116 return ;
9117}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9118/*
9119 * FUNCTION: WDA_RemBeaconFilterReqCallback
9120 * Free memory.
9121 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
9122 */
9123void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9124{
9125 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9126
9127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9128 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9129
9130 if(NULL == pWdaParams)
9131 {
9132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9133 "%s: pWdaParams received NULL", __func__);
9134 VOS_ASSERT(0);
9135 return;
9136 }
9137
9138 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9139 {
9140 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9141 vos_mem_free(pWdaParams->wdaMsgParam);
9142 vos_mem_free(pWdaParams);
9143 }
9144
9145 return;
9146}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9147 // TODO: PE does not have this feature for now implemented,
9148 // but the support for removing beacon filter exists between
9149 // HAL and FW. This function can be called whenever PE defines
9150 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9151/*
9152 * FUNCTION: WDA_RemBeaconFilterReq
9153 * Request to WDI to send the removal of beacon filtering related information.
9154 */
9155VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
9156 tRemBeaconFilterMsg* pBeaconFilterInfo)
9157{
9158 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9159 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9160 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
9161 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
9162 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9163 tWDA_ReqParams *pWdaParams ;
9164
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9166 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9167 if(NULL == wdiBeaconFilterInfo)
9168 {
9169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9170 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9171 VOS_ASSERT(0);
9172 return VOS_STATUS_E_NOMEM;
9173 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9174 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9175 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9176 {
9177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9178 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9179 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9180 vos_mem_free(wdiBeaconFilterInfo);
9181 vos_mem_free(pBeaconFilterInfo);
9182 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9183 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9184
9185 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
9186 pBeaconFilterInfo->ucIeCount;
9187 //Fill structure with info contained in the ucRemIeId
9188 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
9189 pBeaconFilterInfo->ucRemIeId,
9190 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
9191 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
9192 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9193
9194 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9195 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9196 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9197 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
9198
9199 pWdaParams->pWdaContext = pWDA;
9200
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9201 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9202 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9203 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9204 {
9205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9206 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9207 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9208 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9209 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9210 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9211 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9212 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9213}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9214/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9215 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9216 *
9217 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9218void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9219{
9220 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9222 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9223 if(NULL == pWdaParams)
9224 {
9225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9226 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9227 VOS_ASSERT(0) ;
9228 return ;
9229 }
9230
9231 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9232 vos_mem_free(pWdaParams) ;
9233
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9234 return ;
9235}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9236/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9237 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
9238 * Free memory.
9239 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
9240 */
9241void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
9242{
9243 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9244
9245 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9246 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9247
9248 if(NULL == pWdaParams)
9249 {
9250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9251 "%s: pWdaParams received NULL", __func__);
9252 VOS_ASSERT(0);
9253 return;
9254 }
9255
9256 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9257 {
9258 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9259 vos_mem_free(pWdaParams);
9260 }
9261
9262 return;
9263}
9264/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9265 * FUNCTION: WDA_SetRSSIThresholdsReq
9266 * Request to WDI to set the RSSI thresholds (sta mode).
9267 */
9268VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
9269{
9270 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9271 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9272 tWDA_CbContext *pWDA = NULL ;
9273 v_PVOID_t pVosContext = NULL;
9274 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
9275 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
9276 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
9277 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9278 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9279 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9280 if(NULL == wdiRSSIThresholdsInfo)
9281 {
9282 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9283 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9284 VOS_ASSERT(0);
9285 return VOS_STATUS_E_NOMEM;
9286 }
9287 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9288 if(NULL == pWdaParams)
9289 {
9290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9291 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9292 VOS_ASSERT(0);
9293 vos_mem_free(wdiRSSIThresholdsInfo);
9294 return VOS_STATUS_E_NOMEM;
9295 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9296 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9297 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
9298 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
9299 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9300 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
9301 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
9302 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9303 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
9304 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
9305 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9306 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
9307 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9308 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
9309 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
9310
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9311 /* Store param pointer as passed in by caller */
9312 /* store Params pass it to WDI */
9313 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
9314 pWdaParams->pWdaContext = pWDA;
9315 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9316 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9317 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9318 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9319 {
9320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9321 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9322 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9323 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9324 vos_mem_free(pWdaParams) ;
9325 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9326 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9327
9328}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9329/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9330 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9331 *
9332 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9333void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9334{
9335 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9336
9337 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9338 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9339 if(NULL == pWdaParams)
9340 {
9341 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9342 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9343 VOS_ASSERT(0) ;
9344 return ;
9345 }
9346
9347 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9348 vos_mem_free(pWdaParams->wdaMsgParam);
9349 vos_mem_free(pWdaParams) ;
9350
9351 //print a msg, nothing else to do
9352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9353 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9354 return ;
9355}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9356/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9357 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9358 * Free memory.
9359 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9360 */
9361void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
9362{
9363 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9364
9365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9366 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9367
9368 if(NULL == pWdaParams)
9369 {
9370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9371 "%s: Invalid pWdaParams pointer", __func__);
9372 VOS_ASSERT(0);
9373 return;
9374 }
9375
9376 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9377 {
9378 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9379 vos_mem_free(pWdaParams->wdaMsgParam);
9380 vos_mem_free(pWdaParams);
9381 }
9382
9383 return;
9384}
9385/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9386 * FUNCTION: WDA_ProcessHostOffloadReq
9387 * Request to WDI to set the filter to minimize unnecessary host wakeup due
9388 * to broadcast traffic (sta mode).
9389 */
9390VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
9391 tSirHostOffloadReq *pHostOffloadParams)
9392{
9393 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9394 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9395 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
9396 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
9397 sizeof(WDI_HostOffloadReqParamsType)) ;
9398 tWDA_ReqParams *pWdaParams ;
9399
9400 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9401 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9402
9403 if(NULL == wdiHostOffloadInfo)
9404 {
9405 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9406 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9407 VOS_ASSERT(0);
9408 return VOS_STATUS_E_NOMEM;
9409 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9410 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9411 if(NULL == pWdaParams)
9412 {
9413 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9414 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9415 VOS_ASSERT(0);
9416 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9417 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9418 return VOS_STATUS_E_NOMEM;
9419 }
9420
9421 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
9422 pHostOffloadParams->offloadType;
9423 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
9424 pHostOffloadParams->enableOrDisable;
9425
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9426 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
9427 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
9428
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9429 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
9430 {
9431 case SIR_IPV4_ARP_REPLY_OFFLOAD:
9432 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
9433 pHostOffloadParams->params.hostIpv4Addr,
9434 4);
9435 break;
9436 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
9437 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9438 pHostOffloadParams->params.hostIpv6Addr,
9439 16);
9440 break;
9441 case SIR_IPV6_NS_OFFLOAD:
9442 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9443 pHostOffloadParams->params.hostIpv6Addr,
9444 16);
9445
9446#ifdef WLAN_NS_OFFLOAD
9447 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
9448 {
9449 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
9450 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
9451 16);
9452 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
9453 }
9454 else
9455 {
9456 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
9457 }
9458
9459 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
9460 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
9461 16);
9462 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
9463 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
9464 6);
9465
9466 //Only two are supported so let's go through them without a loop
9467 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
9468 {
9469 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
9470 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
9471 16);
9472 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
9473 }
9474 else
9475 {
9476 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
9477 }
9478
9479 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
9480 {
9481 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
9482 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
9483 16);
9484 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
9485 }
9486 else
9487 {
9488 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
9489 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]9490 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
9491 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9492 break;
9493#endif //WLAN_NS_OFFLOAD
9494 default:
9495 {
9496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9497 "No Handling for Offload Type %x in WDA "
9498 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
9499 //WDA_VOS_ASSERT(0) ;
9500 }
9501 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9502 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
9503 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9504
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9505 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9506 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9507 /* store Params pass it to WDI */
9508 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
9509 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9510
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9511
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9512 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9513 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9514
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9515 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9516 {
9517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9518 "Failure in host offload REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9519 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9520 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9521 vos_mem_free(pWdaParams->wdaMsgParam);
9522 vos_mem_free(pWdaParams) ;
9523 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9524 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9525
9526}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9527/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9528 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9529 *
9530 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9531void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9532{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9533 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9534
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9536 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9537
9538 if(NULL == pWdaParams)
9539 {
9540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9541 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9542 VOS_ASSERT(0) ;
9543 return ;
9544 }
9545
9546 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9547 vos_mem_free(pWdaParams->wdaMsgParam);
9548 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9549
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9550 //print a msg, nothing else to do
9551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9552 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9553 return ;
9554}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9555/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9556 * FUNCTION: WDA_KeepAliveReqCallback
9557 * Free memory.
9558 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
9559 */
9560void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
9561{
9562 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9563
9564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9565 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9566
9567 if(NULL == pWdaParams)
9568 {
9569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9570 "%s: pWdaParams received NULL", __func__);
9571 VOS_ASSERT(0);
9572 return;
9573 }
9574
9575 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9576 {
9577 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9578 vos_mem_free(pWdaParams->wdaMsgParam);
9579 vos_mem_free(pWdaParams);
9580 }
9581
9582 return;
9583}
9584/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9585 * FUNCTION: WDA_ProcessKeepAliveReq
9586 * Request to WDI to send Keep Alive packets to minimize unnecessary host
9587 * wakeup due to broadcast traffic (sta mode).
9588 */
9589VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
9590 tSirKeepAliveReq *pKeepAliveParams)
9591{
9592 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9593 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9594 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
9595 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
9596 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9597 tWDA_ReqParams *pWdaParams;
9598
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9600 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9601 if(NULL == wdiKeepAliveInfo)
9602 {
9603 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9604 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9605 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9606 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9607 return VOS_STATUS_E_NOMEM;
9608 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9609
9610 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9611 if(NULL == pWdaParams)
9612 {
9613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9614 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9615 VOS_ASSERT(0);
9616 vos_mem_free(wdiKeepAliveInfo);
9617 vos_mem_free(pKeepAliveParams);
9618 return VOS_STATUS_E_NOMEM;
9619 }
9620
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9621 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
9622 pKeepAliveParams->packetType;
9623 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
9624 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9625
9626 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
9627 pKeepAliveParams->bssId,
9628 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9629
9630 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
9631 {
9632 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9633 pKeepAliveParams->hostIpv4Addr,
9634 SIR_IPV4_ADDR_LEN);
9635 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9636 pKeepAliveParams->destIpv4Addr,
9637 SIR_IPV4_ADDR_LEN);
9638 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9639 pKeepAliveParams->destMacAddr,
9640 SIR_MAC_ADDR_LEN);
9641 }
9642 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
9643 {
9644 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9645 SIR_IPV4_ADDR_LEN,
9646 0);
9647 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9648 SIR_IPV4_ADDR_LEN,
9649 0);
9650 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9651 SIR_MAC_ADDR_LEN,
9652 0);
9653 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9654 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
9655 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9656
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9657 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9658 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9659 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9660 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
9661 pWdaParams->pWdaContext = pWDA;
9662
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
9664 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
9665 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
9666 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
9667 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
9668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
9669 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
9670 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
9671 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
9672 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
9673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9674 "WDA DMAC : %d:%d:%d:%d:%d:%d",
9675 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
9676 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
9677 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
9678 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
9679 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
9680 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
9681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9682 "TimePeriod %d PacketType %d",
9683 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
9684 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9685 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9686 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9687
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9688 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9689 {
9690 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9691 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9692 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9693 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9694 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9695 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9696 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9697 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9698
9699}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9700/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9701 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9702 *
9703 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9704void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9705 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
9706 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9707{
9708 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9710 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9711 if(NULL == pWdaParams)
9712 {
9713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9714 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9715 VOS_ASSERT(0) ;
9716 return ;
9717 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9718 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9719 vos_mem_free(pWdaParams->wdaMsgParam);
9720 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9721 return ;
9722}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9723/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9724 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
9725 * Free memory.
9726 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
9727 */
9728void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
9729{
9730 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9731
9732 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9733 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9734
9735 if(NULL == pWdaParams)
9736 {
9737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9738 "%s: pWdaParams received NULL", __func__);
9739 VOS_ASSERT(0);
9740 return;
9741 }
9742
9743 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9744 {
9745 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9746 vos_mem_free(pWdaParams->wdaMsgParam);
9747 vos_mem_free(pWdaParams);
9748 }
9749
9750 return;
9751}
9752
9753/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9754 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
9755 * Request to WDI to add WOWL Bcast pattern
9756 */
9757VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
9758 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
9759{
9760 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9761 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9762 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
9763 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
9764 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
9765 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9767 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9768 if(NULL == wdiWowlAddBcPtrnInfo)
9769 {
9770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9771 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9772 VOS_ASSERT(0);
9773 return VOS_STATUS_E_NOMEM;
9774 }
9775 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9776 if(NULL == pWdaParams)
9777 {
9778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9779 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9780 VOS_ASSERT(0);
9781 vos_mem_free(wdiWowlAddBcPtrnInfo);
9782 return VOS_STATUS_E_NOMEM;
9783 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9784 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
9785 pWowlAddBcPtrnParams->ucPatternId;
9786 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
9787 pWowlAddBcPtrnParams->ucPatternByteOffset;
9788 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
9789 pWowlAddBcPtrnParams->ucPatternMaskSize;
9790 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
9791 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9792 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
9793 {
9794 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
9795 pWowlAddBcPtrnParams->ucPattern,
9796 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
9797 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
9798 pWowlAddBcPtrnParams->ucPatternMask,
9799 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
9800 }
9801 else
9802 {
9803 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
9804 pWowlAddBcPtrnParams->ucPattern,
9805 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9806 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
9807 pWowlAddBcPtrnParams->ucPatternMask,
9808 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9809
9810 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
9811 pWowlAddBcPtrnParams->ucPatternExt,
9812 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9813 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
9814 pWowlAddBcPtrnParams->ucPatternMaskExt,
9815 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9816 }
9817
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9818 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
9819 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
9820
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9821 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
9822 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9823 /* Store param pointer as passed in by caller */
9824 /* store Params pass it to WDI */
9825 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
9826 pWdaParams->pWdaContext = pWDA;
9827 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9828 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9829 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9830 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9831 {
9832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9833 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9834 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9835 vos_mem_free(pWdaParams->wdaMsgParam) ;
9836 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9837 vos_mem_free(pWdaParams) ;
9838 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9839 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9840
9841}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9842/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9843 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9844 *
9845 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9846void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9847 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
9848 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9849{
9850 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9852 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9853 if(NULL == pWdaParams)
9854 {
9855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9856 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9857 VOS_ASSERT(0) ;
9858 return ;
9859 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9860 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9861 vos_mem_free(pWdaParams->wdaMsgParam);
9862 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9863 return ;
9864}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9865/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9866 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
9867 * Free memory.
9868 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
9869 */
9870void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
9871{
9872 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9873
9874 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9875 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9876
9877 if(NULL == pWdaParams)
9878 {
9879 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9880 "%s: pWdaParams received NULL", __func__);
9881 VOS_ASSERT(0);
9882 return;
9883 }
9884
9885 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9886 {
9887 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9888 vos_mem_free(pWdaParams->wdaMsgParam);
9889 vos_mem_free(pWdaParams);
9890 }
9891
9892 return;
9893}
9894/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9895 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
9896 * Request to WDI to delete WOWL Bcast pattern
9897 */
9898VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
9899 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
9900{
9901 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9902 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9903 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
9904 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
9905 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
9906 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9907 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9908 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9909 if(NULL == wdiWowlDelBcPtrnInfo)
9910 {
9911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9912 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9913 VOS_ASSERT(0);
9914 return VOS_STATUS_E_NOMEM;
9915 }
9916 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9917 if(NULL == pWdaParams)
9918 {
9919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9920 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9921 VOS_ASSERT(0);
9922 vos_mem_free(wdiWowlDelBcPtrnInfo);
9923 return VOS_STATUS_E_NOMEM;
9924 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9925 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
9926 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9927
9928 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
9929 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
9930
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9931 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
9932 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9933 /* Store param pointer as passed in by caller */
9934 /* store Params pass it to WDI */
9935 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
9936 pWdaParams->pWdaContext = pWDA;
9937 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9938 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9939 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9940 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9941 {
9942 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9943 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9944 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9945 vos_mem_free(pWdaParams->wdaMsgParam) ;
9946 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9947 vos_mem_free(pWdaParams) ;
9948 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9949 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9950
9951}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9952/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9953 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9954 *
9955 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9956void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9957{
9958 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9959 tWDA_CbContext *pWDA;
9960 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9961 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9962 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9963 if(NULL == pWdaParams)
9964 {
9965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9966 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9967 VOS_ASSERT(0) ;
9968 return ;
9969 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9970 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
9971 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
9972
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9973 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
9974
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9975 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9976 vos_mem_free(pWdaParams) ;
9977
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9978 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9979 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9980 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9981 return ;
9982}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9983/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9984 * FUNCTION: WDA_WowlEnterReqCallback
9985 * Free memory and send WOWL Enter RSP back to PE.
9986 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
9987 */
9988void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
9989{
9990 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9991 tWDA_CbContext *pWDA;
9992 tSirHalWowlEnterParams *pWowlEnterParams;
9993
9994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9995 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9996
9997 if(NULL == pWdaParams)
9998 {
9999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10000 "%s: pWdaParams received NULL", __func__);
10001 VOS_ASSERT(0);
10002 return;
10003 }
10004
10005 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10006 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
10007 pWowlEnterParams->status = wdiStatus;
10008
10009 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10010 {
10011 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10012 vos_mem_free(pWdaParams);
10013 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
10014 }
10015
10016 return;
10017}
10018/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10019 * FUNCTION: WDA_ProcessWowlEnterReq
10020 * Request to WDI to enter WOWL
10021 */
10022VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
10023 tSirHalWowlEnterParams *pWowlEnterParams)
10024{
10025 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10026 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10027 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
10028 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
10029 sizeof(WDI_WowlEnterReqParamsType)) ;
10030 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10032 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10033 if(NULL == wdiWowlEnterInfo)
10034 {
10035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10036 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10037 VOS_ASSERT(0);
10038 return VOS_STATUS_E_NOMEM;
10039 }
10040 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10041 if(NULL == pWdaParams)
10042 {
10043 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10044 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10045 VOS_ASSERT(0);
10046 vos_mem_free(wdiWowlEnterInfo);
10047 return VOS_STATUS_E_NOMEM;
10048 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]10049
10050 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
10051
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10052 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
10053 pWowlEnterParams->magicPtrn,
10054 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10055 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
10056 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10057 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
10058 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10059 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
10060 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10061 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
10062 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10063 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
10064 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10065 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
10066 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10067 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
10068 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10069 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
10070 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10071#ifdef WLAN_WAKEUP_EVENTS
10072 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
10073 pWowlEnterParams->ucWoWEAPIDRequestEnable;
10074
10075 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
10076 pWowlEnterParams->ucWoWEAPOL4WayEnable;
10077
10078 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
10079 pWowlEnterParams->ucWowNetScanOffloadMatch;
10080
10081 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
10082 pWowlEnterParams->ucWowGTKRekeyError;
10083
10084 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
10085 pWowlEnterParams->ucWoWBSSConnLoss;
10086#endif // WLAN_WAKEUP_EVENTS
10087
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10088 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
10089 pWowlEnterParams->bssIdx;
10090
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10091 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
10092 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10093 /* Store param pointer as passed in by caller */
10094 /* store Params pass it to WDI */
10095 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
10096 pWdaParams->pWdaContext = pWDA;
10097 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10098 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10099 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10100 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10101 {
10102 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10103 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10104 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10105 vos_mem_free(pWdaParams->wdaMsgParam) ;
10106 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10107 vos_mem_free(pWdaParams) ;
10108 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10109 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10110
10111}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10112/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10113 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10114 *
10115 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10116void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10117{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10118 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10119 tWDA_CbContext *pWDA;
10120 tSirHalWowlExitParams *pWowlExitParams;
10121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10122 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10123 if(NULL == pWdaParams)
10124 {
10125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10126 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10127 VOS_ASSERT(0) ;
10128 return ;
10129 }
10130 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10131 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
10132
10133 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10134 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10135
10136 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10137 vos_mem_free(pWdaParams) ;
10138
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10140 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10141 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10142 return ;
10143}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10144/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10145 * FUNCTION: WDA_WowlExitReqCallback
10146 * Free memory and send WOWL Exit RSP back to PE.
10147 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
10148 */
10149void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
10150{
10151 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10152 tWDA_CbContext *pWDA;
10153 tSirHalWowlExitParams *pWowlExitParams;
10154
10155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10156 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10157
10158 if(NULL == pWdaParams)
10159 {
10160 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10161 "%s: pWdaParams received NULL", __func__);
10162 VOS_ASSERT(0);
10163 return;
10164 }
10165
10166 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10167 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
10168 pWowlExitParams->status = wdiStatus;
10169
10170 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10171 {
10172 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10173 vos_mem_free(pWdaParams);
10174 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
10175 }
10176
10177 return;
10178}
10179/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10180 * FUNCTION: WDA_ProcessWowlExitReq
10181 * Request to WDI to add WOWL Bcast pattern
10182 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10183VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
10184 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10185{
10186 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10187 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10188 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
10189 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
10190 sizeof(WDI_WowlExitReqParamsType)) ;
10191 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10193 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10194 if(NULL == wdiWowlExitInfo)
10195 {
10196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10197 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10198 VOS_ASSERT(0);
10199 return VOS_STATUS_E_NOMEM;
10200 }
10201 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10202 if(NULL == pWdaParams)
10203 {
10204 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10205 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10206 VOS_ASSERT(0);
10207 vos_mem_free(wdiWowlExitInfo);
10208 return VOS_STATUS_E_NOMEM;
10209 }
10210
10211 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
10212 pWowlExitParams->bssIdx;
10213
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10214 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
10215 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10216
10217 /* Store param pointer as passed in by caller */
10218 /* store Params pass it to WDI */
10219 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
10220 pWdaParams->pWdaContext = pWDA;
10221 pWdaParams->wdaMsgParam = pWowlExitParams;
10222
10223 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10224 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10225
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10226 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10227 {
10228 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10229 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10230 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10231 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10232 vos_mem_free(pWdaParams->wdaMsgParam);
10233 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10234 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10235 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10236}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10237/*
10238 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
10239 * Request to WDI to determine whether a given station is capable of
10240 * using HW-based frame translation
10241 */
10242v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
10243 tANI_U8 staIdx)
10244{
10245 return WDI_IsHwFrameTxTranslationCapable(staIdx);
10246}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10247
10248/*
10249 * FUNCTION: WDA_IsSelfSTA
10250 * Request to WDI to determine whether a given STAID is self station
10251 * index.
10252 */
10253v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
10254{
10255
10256 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10257
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]10258 if (NULL != pWDA)
10259 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
10260 else
10261 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10262}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10263/*
10264 * FUNCTION: WDA_NvDownloadReqCallback
10265 * send NV Download RSP back to PE
10266 */
10267void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
10268 void* pUserData)
10269{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10270
10271 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
10272 tWDA_CbContext *pWDA;
10273
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10274 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10275 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10276
10277 if(NULL == pWdaParams)
10278 {
10279 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10280 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10281 VOS_ASSERT(0) ;
10282 return ;
10283 }
10284
10285 pWDA = pWdaParams->pWdaContext;
10286
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10287 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10288 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10289 vos_mem_free(pWdaParams);
10290
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10291 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10292 return ;
10293}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10294/*
10295 * FUNCTION: WDA_ProcessNvDownloadReq
10296 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
10297 */
10298VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
10299{
10300 /* Initialize the local Variables*/
10301 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10302 v_VOID_t *pNvBuffer=NULL;
10303 v_SIZE_t bufferSize = 0;
10304 WDI_Status status = WDI_STATUS_E_FAILURE;
10305 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10306 tWDA_ReqParams *pWdaParams ;
10307
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10308 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10309 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10310 if(NULL == pWDA)
10311 {
10312 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10313 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10314 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10315 return VOS_STATUS_E_FAILURE;
10316 }
10317
10318 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]10319 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
10320
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10321 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
10322 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10323 if(NULL == wdiNvDownloadReqParam)
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 return VOS_STATUS_E_NOMEM;
10329 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10330 /* Copy Params to wdiNvDownloadReqParam*/
10331 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
10332 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10333
10334 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10335 if(NULL == pWdaParams)
10336 {
10337 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10338 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10339 VOS_ASSERT(0);
10340 vos_mem_free(wdiNvDownloadReqParam);
10341 return VOS_STATUS_E_NOMEM;
10342 }
10343
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10344 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10345 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
10346 pWdaParams->wdaMsgParam = NULL;
10347 pWdaParams->pWdaContext = pWDA;
10348
10349
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10350 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10351
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10352 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10353 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
10354
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10355 if(IS_WDI_STATUS_FAILURE(status))
10356 {
10357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10358 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10359 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10360 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10361 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10362 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10363}
10364/*
10365 * FUNCTION: WDA_FlushAcReqCallback
10366 * send Flush AC RSP back to TL
10367 */
10368void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
10369{
10370 vos_msg_t wdaMsg = {0} ;
10371 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10372 tFlushACReq *pFlushACReqParams;
10373 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10375 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10376 if(NULL == pWdaParams)
10377 {
10378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10379 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10380 VOS_ASSERT(0) ;
10381 return ;
10382 }
10383
10384 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
10385 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
10386 if(NULL == pFlushACRspParams)
10387 {
10388 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10389 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10390 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]10391 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10392 return ;
10393 }
10394 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
10395 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
10396 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
10397 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
10398 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10399 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10400 vos_mem_free(pWdaParams->wdaMsgParam) ;
10401 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10402 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10403 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
10404 wdaMsg.bodyptr = (void *)pFlushACRspParams;
10405 // POST message to TL
10406 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
10407
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10408 return ;
10409}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10410/*
10411 * FUNCTION: WDA_ProcessFlushAcReq
10412 * Request to WDI to Update the DELBA REQ params.
10413 */
10414VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
10415 tFlushACReq *pFlushAcReqParams)
10416{
10417 WDI_Status status = WDI_STATUS_SUCCESS ;
10418 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
10419 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
10420 sizeof(WDI_FlushAcReqParamsType)) ;
10421 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10422 if(NULL == wdiFlushAcReqParam)
10423 {
10424 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10425 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10426 VOS_ASSERT(0);
10427 return VOS_STATUS_E_NOMEM;
10428 }
10429 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10430 if(NULL == pWdaParams)
10431 {
10432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10433 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10434 VOS_ASSERT(0);
10435 vos_mem_free(wdiFlushAcReqParam);
10436 return VOS_STATUS_E_NOMEM;
10437 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10438 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10439 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10440 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
10441 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
10442 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
10443 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10444 /* Store Flush AC pointer, as this will be used for response */
10445 /* store Params pass it to WDI */
10446 pWdaParams->pWdaContext = pWDA;
10447 pWdaParams->wdaMsgParam = pFlushAcReqParams;
10448 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10449 status = WDI_FlushAcReq(wdiFlushAcReqParam,
10450 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10451 if(IS_WDI_STATUS_FAILURE(status))
10452 {
10453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10454 "Failure in Flush AC REQ Params WDI API, free all the memory " );
10455 vos_mem_free(pWdaParams->wdaMsgParam) ;
10456 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10457 vos_mem_free(pWdaParams) ;
10458 //TODO: respond to TL with failure
10459 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10460 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10461}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10462/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10463 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10464 *
10465 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10466void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10467{
10468 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10469 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10470 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10471
10472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10473 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10474 if(NULL == pWdaParams)
10475 {
10476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10477 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10478 VOS_ASSERT(0) ;
10479 return ;
10480 }
10481 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10482 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10483 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10484 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10485 {
10486 pWDA->wdaAmpSessionOn = VOS_FALSE;
10487 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10488 vos_mem_free(pWdaParams->wdaMsgParam) ;
10489 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10490 vos_mem_free(pWdaParams) ;
10491 /*
10492 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
10493 * param here
10494 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10495 return ;
10496}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10497/*
10498 * FUNCTION: WDA_BtAmpEventReqCallback
10499 * Free memory.
10500 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
10501 */
10502void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
10503{
10504 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10505 tWDA_CbContext *pWDA;
10506 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10507
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10509 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10510
10511 if(NULL == pWdaParams)
10512 {
10513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10514 "%s: pWdaParams received NULL", __func__);
10515 VOS_ASSERT(0);
10516 return;
10517 }
10518
10519 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10520 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10521
10522 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10523 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10524 {
10525 pWDA->wdaAmpSessionOn = VOS_FALSE;
10526 }
10527
10528 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10529 {
10530 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10531 vos_mem_free(pWdaParams->wdaMsgParam);
10532 vos_mem_free(pWdaParams);
10533 }
10534
10535 return;
10536}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10537/*
10538 * FUNCTION: WDA_ProcessBtAmpEventReq
10539 * Request to WDI to Update with BT AMP events.
10540 */
10541VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
10542 tSmeBtAmpEvent *pBtAmpEventParams)
10543{
10544 WDI_Status status = WDI_STATUS_SUCCESS ;
10545 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
10546 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
10547 sizeof(WDI_BtAmpEventParamsType)) ;
10548 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10549 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10550 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10551 if(NULL == wdiBtAmpEventParam)
10552 {
10553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10554 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10555 VOS_ASSERT(0);
10556 return VOS_STATUS_E_NOMEM;
10557 }
10558 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10563 VOS_ASSERT(0);
10564 vos_mem_free(wdiBtAmpEventParam);
10565 return VOS_STATUS_E_NOMEM;
10566 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10567 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
10568 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10569 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
10570 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10571 /* Store BT AMP event pointer, as this will be used for response */
10572 /* store Params pass it to WDI */
10573 pWdaParams->pWdaContext = pWDA;
10574 pWdaParams->wdaMsgParam = pBtAmpEventParams;
10575 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10576 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10577 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10578 if(IS_WDI_STATUS_FAILURE(status))
10579 {
10580 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10581 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
10582 vos_mem_free(pWdaParams->wdaMsgParam) ;
10583 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10584 vos_mem_free(pWdaParams) ;
10585 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10586 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10587 {
10588 pWDA->wdaAmpSessionOn = VOS_TRUE;
10589 }
10590 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10591}
10592
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10593/*
10594 * FUNCTION: WDA_FTMCommandReqCallback
10595 * Handle FTM CMD response came from HAL
10596 * Route responce to HDD FTM
10597 */
10598void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
10599 void *usrData)
10600{
10601 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10602 if((NULL == pWDA) || (NULL == ftmCmdRspData))
10603 {
10604 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]10605 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10606 return;
10607 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10608 /* Release Current FTM Command Request */
10609 vos_mem_free(pWDA->wdaFTMCmdReq);
10610 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10611 /* Post FTM Responce to HDD FTM */
10612 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10613 return;
10614}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10615/*
10616 * FUNCTION: WDA_ProcessFTMCommand
10617 * Send FTM command to WDI
10618 */
10619VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
10620 tPttMsgbuffer *pPTTFtmCmd)
10621{
10622 WDI_Status status = WDI_STATUS_SUCCESS;
10623 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10624 ftmCMDReq = (WDI_FTMCommandReqType *)
10625 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
10626 if(NULL == ftmCMDReq)
10627 {
10628 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10629 "WDA FTM Command buffer alloc fail");
10630 return VOS_STATUS_E_NOMEM;
10631 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10632 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
10633 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10634 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10635 /* Send command to WDI */
10636 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10637 return status;
10638}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10639#ifdef FEATURE_OEM_DATA_SUPPORT
10640/*
10641 * FUNCTION: WDA_StartOemDataReqCallback
10642 *
10643 */
10644void WDA_StartOemDataReqCallback(
10645 WDI_oemDataRspParamsType *wdiOemDataRspParams,
10646 void* pUserData)
10647{
10648 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10649 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10650 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10651 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10652
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10654 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10655
10656 if(NULL == pWdaParams)
10657 {
10658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10659 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10660 VOS_ASSERT(0) ;
10661 return ;
10662 }
10663 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10664
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10665 if(NULL == pWDA)
10666 {
10667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10668 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10669 VOS_ASSERT(0);
10670 return ;
10671 }
10672
10673 /*
10674 * Allocate memory for response params sent to PE
10675 */
10676 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
10677
10678 // Check if memory is allocated for OemdataMeasRsp Params.
10679 if(NULL == pOemDataRspParams)
10680 {
10681 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10682 "OEM DATA WDA callback alloc fail");
10683 VOS_ASSERT(0) ;
10684 return;
10685 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10686
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10687 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10688 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10689 vos_mem_free(pWdaParams->wdaMsgParam);
10690 vos_mem_free(pWdaParams) ;
10691
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10692 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]10693 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10694 * Also, here success always means that we have atleast one BSSID.
10695 */
10696 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
10697
10698 //enable Tx
10699 status = WDA_ResumeDataTx(pWDA);
10700 if(status != VOS_STATUS_SUCCESS)
10701 {
10702 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
10703 }
10704 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
10705 return ;
10706}
10707/*
10708 * FUNCTION: WDA_ProcessStartOemDataReq
10709 * Send Start Oem Data Req to WDI
10710 */
10711VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
10712 tStartOemDataReq *pOemDataReqParams)
10713{
10714 WDI_Status status = WDI_STATUS_SUCCESS;
10715 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10716 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10717
10718 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
10719
10720 if(NULL == wdiOemDataReqParams)
10721 {
10722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10723 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10724 VOS_ASSERT(0);
10725 return VOS_STATUS_E_NOMEM;
10726 }
10727
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10728 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
10729 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
10730 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
10731 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10732
10733 wdiOemDataReqParams->wdiReqStatusCB = NULL;
10734
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10735 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10736 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10737 {
10738 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10739 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10740 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10741 vos_mem_free(pOemDataReqParams);
10742 VOS_ASSERT(0);
10743 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10744 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10745
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]10746 pWdaParams->pWdaContext = (void*)pWDA;
10747 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
10748 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10749
10750 status = WDI_StartOemDataReq(wdiOemDataReqParams,
10751 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10752
10753 if(IS_WDI_STATUS_FAILURE(status))
10754 {
10755 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10756 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10757 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10758 vos_mem_free(pWdaParams->wdaMsgParam);
10759 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10760 }
10761 return CONVERT_WDI2VOS_STATUS(status) ;
10762}
10763#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10764/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10765 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10766 *
10767 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10768void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10769{
10770 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10772 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10773 if(NULL == pWdaParams)
10774 {
10775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10776 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10777 VOS_ASSERT(0) ;
10778 return ;
10779 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10780
10781 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10782 vos_mem_free(pWdaParams->wdaMsgParam);
10783 vos_mem_free(pWdaParams);
10784
10785 return ;
10786}
10787/*
10788 * FUNCTION: WDA_SetTxPerTrackingReqCallback
10789 * Free memory.
10790 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
10791 */
10792void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
10793{
10794 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10795
10796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10797 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10798
10799 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10800 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10802 "%s: pWdaParams received NULL", __func__);
10803 VOS_ASSERT(0);
10804 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10805 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10806
10807 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10808 {
10809 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10810 vos_mem_free(pWdaParams->wdaMsgParam);
10811 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10812 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10813
10814 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10815}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10816#ifdef WLAN_FEATURE_GTK_OFFLOAD
10817/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10818 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10819 *
10820 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10821void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10822 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10823{
10824 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10825
10826 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10827 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]10828 if(NULL == pWdaParams)
10829 {
10830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10831 "%s: pWdaParams received NULL", __func__);
10832 VOS_ASSERT(0);
10833 return;
10834 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10835
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10836 vos_mem_free(pWdaParams->wdaMsgParam) ;
10837 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10838 vos_mem_free(pWdaParams) ;
10839
10840 //print a msg, nothing else to do
10841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10842 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10843
10844 return ;
10845}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10846/*
10847 * FUNCTION: WDA_GTKOffloadReqCallback
10848 * Free memory.
10849 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
10850 */
10851void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
10852{
10853 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10854
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10856 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10857
10858 if(NULL == pWdaParams)
10859 {
10860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10861 "%s: pWdaParams received NULL", __func__);
10862 VOS_ASSERT(0);
10863 return;
10864 }
10865
10866 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10867 {
10868 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10869 vos_mem_free(pWdaParams->wdaMsgParam);
10870 vos_mem_free(pWdaParams);
10871 }
10872
10873 return;
10874}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10875/*
10876 * FUNCTION: WDA_ProcessGTKOffloadReq
10877 * Request to WDI to set the filter to minimize unnecessary host wakeup due
10878 * to broadcast traffic (sta mode).
10879 */
10880VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
10881 tpSirGtkOffloadParams pGtkOffloadParams)
10882{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10883 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10884 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
10885 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
10886 sizeof(WDI_GtkOffloadReqMsg)) ;
10887 tWDA_ReqParams *pWdaParams ;
10888
10889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10890 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10891
10892 if(NULL == wdiGtkOffloadReqMsg)
10893 {
10894 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10895 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10896 VOS_ASSERT(0);
10897 return VOS_STATUS_E_NOMEM;
10898 }
10899
10900 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10901 if(NULL == pWdaParams)
10902 {
10903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10904 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10905 VOS_ASSERT(0);
10906 vos_mem_free(wdiGtkOffloadReqMsg);
10907 return VOS_STATUS_E_NOMEM;
10908 }
10909
10910 //
10911 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
10912 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10913
10914 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10915 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10916
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10917 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
10918 // Copy KCK
10919 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
10920 // Copy KEK
10921 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
10922 // Copy KeyReplayCounter
10923 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
10924 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
10925
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10926 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
10927 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10928
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10929
10930 /* Store Params pass it to WDI */
10931 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
10932 pWdaParams->pWdaContext = pWDA;
10933 /* Store param pointer as passed in by caller */
10934 pWdaParams->wdaMsgParam = pGtkOffloadParams;
10935
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10936 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10937
10938 if(IS_WDI_STATUS_FAILURE(status))
10939 {
10940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10941 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
10942 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10943 vos_mem_free(pWdaParams->wdaMsgParam);
10944 vos_mem_free(pWdaParams);
10945 }
10946
10947 return CONVERT_WDI2VOS_STATUS(status) ;
10948}
10949
10950/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10951 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10952 *
10953 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10954void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10955 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10956{
10957 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10958 tWDA_CbContext *pWDA;
10959 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10960 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10961 vos_msg_t vosMsg;
10962
10963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10964 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10965
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]10966 if(NULL == pWdaParams)
10967 {
10968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10969 "%s: pWdaParams received NULL", __func__);
10970 VOS_ASSERT(0);
10971 return;
10972 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10973
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10974 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
10975 if(NULL == pGtkOffloadGetInfoRsp)
10976 {
10977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10978 "%s: vos_mem_malloc failed ", __func__);
10979 VOS_ASSERT(0);
10980 return;
10981 }
10982
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10983 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10984 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
10985
10986 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
10987 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
10988
10989 /* Message Header */
10990 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]10991 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10992
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10993 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
10994 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
10995 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
10996 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
10997 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10998
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10999 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
11000 pwdiGtkOffloadGetInfoRsparams->bssId,
11001 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11002 /* VOS message wrapper */
11003 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11004 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
11005 vosMsg.bodyval = 0;
11006
11007 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
11008 {
11009 /* free the mem and return */
11010 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
11011 }
11012
11013 vos_mem_free(pWdaParams->wdaMsgParam) ;
11014 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11015 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11016
11017 return;
11018}
11019/*
11020 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
11021 * Free memory and send RSP back to SME.
11022 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
11023 */
11024void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
11025{
11026 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11027 vos_msg_t vosMsg;
11028
11029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11030 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11031
11032 if(NULL == pWdaParams)
11033 {
11034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11035 "%s: pWdaParams received NULL", __func__);
11036 VOS_ASSERT(0);
11037 return;
11038 }
11039
11040 /* VOS message wrapper */
11041 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11042 vosMsg.bodyptr = NULL;
11043 vosMsg.bodyval = 0;
11044
11045 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11046 {
11047 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11048 vos_mem_free(pWdaParams->wdaMsgParam);
11049 vos_mem_free(pWdaParams);
11050 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
11051 }
11052
11053 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11054}
11055#endif
11056
11057/*
11058 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
11059 * Request to WDI to set Tx Per Tracking configurations
11060 */
11061VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
11062{
11063 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11064 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11065 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
11066 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
11067 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
11068 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11069 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11070 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11071 if(NULL == pwdiSetTxPerTrackingReqParams)
11072 {
11073 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11074 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11075 vos_mem_free(pTxPerTrackingParams);
11076 VOS_ASSERT(0);
11077 return VOS_STATUS_E_NOMEM;
11078 }
11079 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11080 if(NULL == pWdaParams)
11081 {
11082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11083 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11084 vos_mem_free(pwdiSetTxPerTrackingReqParams);
11085 vos_mem_free(pTxPerTrackingParams);
11086 VOS_ASSERT(0);
11087 return VOS_STATUS_E_NOMEM;
11088 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11089 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
11090 pTxPerTrackingParams->ucTxPerTrackingEnable;
11091 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
11092 pTxPerTrackingParams->ucTxPerTrackingPeriod;
11093 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
11094 pTxPerTrackingParams->ucTxPerTrackingRatio;
11095 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
11096 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11097 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
11098 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11099 /* Store param pointer as passed in by caller */
11100 /* store Params pass it to WDI
11101 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
11102 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
11103 pWdaParams->pWdaContext = pWDA;
11104 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11105 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11106 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11107 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11108 {
11109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11110 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11111 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11112 vos_mem_free(pWdaParams->wdaMsgParam) ;
11113 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11114 vos_mem_free(pWdaParams) ;
11115 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11116 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11117
11118}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11119/*
11120 * FUNCTION: WDA_HALDumpCmdCallback
11121 * Send the VOS complete .
11122 */
11123void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
11124 void* pUserData)
11125{
11126 tANI_U8 *buffer = NULL;
11127 tWDA_CbContext *pWDA = NULL;
11128 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11129 if(NULL == pWdaParams)
11130 {
11131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11132 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11133 VOS_ASSERT(0) ;
11134 return ;
11135 }
11136
11137 pWDA = pWdaParams->pWdaContext;
11138 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11139 if(wdiRspParams->usBufferLen > 0)
11140 {
11141 /*Copy the Resp data to UMAC supplied buffer*/
11142 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
11143 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11144 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11145 vos_mem_free(pWdaParams);
11146
11147 /* Indicate VOSS about the start complete */
11148 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11149 return ;
11150}
11151
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11152/*
11153 * FUNCTION: WDA_ProcessHALDumpCmdReq
11154 * Send Dump command to WDI
11155 */
11156VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
11157 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
11158 tANI_U32 arg4, tANI_U8 *pBuffer)
11159{
11160 WDI_Status status = WDI_STATUS_SUCCESS;
11161 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
11162 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
11163 tWDA_ReqParams *pWdaParams ;
11164 pVosContextType pVosContext = NULL;
11165 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11166 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
11167 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]11168 if(pVosContext)
11169 {
11170 if (pVosContext->isLogpInProgress)
11171 {
11172 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
11173 "%s:LOGP in Progress. Ignore!!!", __func__);
11174 return VOS_STATUS_E_BUSY;
11175 }
11176 }
11177 else
11178 {
11179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11180 "%s: VOS Context Null", __func__);
11181 return VOS_STATUS_E_RESOURCES;
11182 }
11183
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11184 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11185 if(NULL == pWdaParams)
11186 {
11187 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11188 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11189 return VOS_STATUS_E_NOMEM;
11190 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11191 /* Allocate memory WDI request structure*/
11192 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
11193 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
11194 if(NULL == wdiHALDumpCmdReqParam)
11195 {
11196 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11197 "WDA HAL DUMP Command buffer alloc fail");
11198 vos_mem_free(pWdaParams);
11199 return WDI_STATUS_E_FAILURE;
11200 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11201 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11202 /* Extract the arguments */
11203 wdiHalDumpCmdInfo->command = cmd;
11204 wdiHalDumpCmdInfo->argument1 = arg1;
11205 wdiHalDumpCmdInfo->argument2 = arg2;
11206 wdiHalDumpCmdInfo->argument3 = arg3;
11207 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11208 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11209 pWdaParams->pWdaContext = pVosContext->pWDAContext;
11210
11211 /* Response message will be passed through the buffer */
11212 pWdaParams->wdaMsgParam = (void *)pBuffer;
11213
11214 /* store Params pass it to WDI */
11215 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11216 /* Send command to WDI */
11217 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback, pWdaParams);
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]11218 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent), WDA_DUMPCMD_WAIT_TIMEOUT );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11219 if ( vStatus != VOS_STATUS_SUCCESS )
11220 {
11221 if ( vStatus == VOS_STATUS_E_TIMEOUT )
11222 {
11223 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11224 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11225 }
11226 else
11227 {
11228 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11229 "%s: WDA_HALDUMP reporting other error",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11230 }
11231 VOS_ASSERT(0);
11232 }
11233 return status;
11234}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11235#ifdef WLAN_FEATURE_GTK_OFFLOAD
11236/*
11237 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
11238 * Request to WDI to get GTK Offload Information
11239 */
11240VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
11241 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
11242{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11243 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11244 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
11245 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
11246 tWDA_ReqParams *pWdaParams ;
11247
11248 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
11249 {
11250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11251 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11252 VOS_ASSERT(0);
11253 return VOS_STATUS_E_NOMEM;
11254 }
11255
11256 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11257 if(NULL == pWdaParams)
11258 {
11259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11260 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11261 VOS_ASSERT(0);
11262 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
11263 return VOS_STATUS_E_NOMEM;
11264 }
11265
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11266 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
11267 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11268
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11269 /* Store Params pass it to WDI */
11270 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
11271 pWdaParams->pWdaContext = pWDA;
11272 /* Store param pointer as passed in by caller */
11273 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
11274
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11275 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11276 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11277
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11278 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11279
11280 if(IS_WDI_STATUS_FAILURE(status))
11281 {
11282 /* failure returned by WDI API */
11283 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11284 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
11285 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11286 vos_mem_free(pWdaParams) ;
11287 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
11288 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
11289 }
11290
11291 return CONVERT_WDI2VOS_STATUS(status) ;
11292}
11293#endif // WLAN_FEATURE_GTK_OFFLOAD
11294
11295/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11296 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
11297 *
11298 */
11299VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11300 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
11301{
11302 WDI_Status wdiStatus;
11303 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
11304
11305 addPeriodicTxPtrnParams =
11306 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
11307
11308 if (NULL == addPeriodicTxPtrnParams)
11309 {
11310 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11311 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
11312 __func__);
11313
11314 return VOS_STATUS_E_NOMEM;
11315 }
11316
11317 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
11318 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
11319
11320 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11321 addPeriodicTxPtrnParams->pUserData = pWDA;
11322
11323 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
11324
11325 if (WDI_STATUS_PENDING == wdiStatus)
11326 {
11327 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11328 "Pending received for %s:%d", __func__, __LINE__ );
11329 }
11330 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11331 {
11332 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11333 "Failure in %s:%d", __func__, __LINE__ );
11334 }
11335
11336 vos_mem_free(addPeriodicTxPtrnParams);
11337
11338 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11339}
11340
11341/*
11342 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
11343 *
11344 */
11345VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11346 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
11347{
11348 WDI_Status wdiStatus;
11349 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
11350
11351 delPeriodicTxPtrnParams =
11352 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
11353
11354 if (NULL == delPeriodicTxPtrnParams)
11355 {
11356 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11357 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
11358 __func__);
11359
11360 return VOS_STATUS_E_NOMEM;
11361 }
11362
11363 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
11364 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
11365
11366 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11367 delPeriodicTxPtrnParams->pUserData = pWDA;
11368
11369 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
11370
11371 if (WDI_STATUS_PENDING == wdiStatus)
11372 {
11373 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11374 "Pending received for %s:%d", __func__, __LINE__ );
11375 }
11376 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11377 {
11378 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11379 "Failure in %s:%d", __func__, __LINE__ );
11380 }
11381
11382 vos_mem_free(delPeriodicTxPtrnParams);
11383
11384 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11385}
11386
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11387#ifdef FEATURE_WLAN_BATCH_SCAN
11388/*
11389 * FUNCTION: WDA_ProcessStopBatchScanInd
11390 *
11391 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
11392 *
11393 * PARAM:
11394 * pWDA: pointer to WDA context
11395 * pReq: pointer to stop batch scan request
11396 */
11397VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
11398 tSirStopBatchScanInd *pReq)
11399{
11400 WDI_Status wdiStatus;
11401 WDI_StopBatchScanIndType wdiReq;
11402
11403 wdiReq.param = pReq->param;
11404
11405 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
11406
11407 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11408 {
11409 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11410 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
11411 }
11412
11413 vos_mem_free(pReq);
11414
11415 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11416}
11417/*==========================================================================
11418 FUNCTION WDA_ProcessTriggerBatchScanResultInd
11419
11420 DESCRIPTION
11421 API to pull batch scan result from FW
11422
11423 PARAMETERS
11424 pWDA: Pointer to WDA context
11425 pGetBatchScanReq: Pointer to get batch scan result indication
11426
11427 RETURN VALUE
11428 NONE
11429
11430===========================================================================*/
11431VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
11432 tSirTriggerBatchScanResultInd *pReq)
11433{
11434 WDI_Status wdiStatus;
11435 WDI_TriggerBatchScanResultIndType wdiReq;
11436
11437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11438 "------> %s " ,__func__);
11439
11440 wdiReq.param = pReq->param;
11441
11442 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
11443
11444 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11445 {
11446 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11447 "Trigger batch scan result ind failed %s:%d",
11448 __func__, wdiStatus);
11449 }
11450
11451 vos_mem_free(pReq);
11452
11453 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11454}
11455
11456/*==========================================================================
11457 FUNCTION WDA_SetBatchScanRespCallback
11458
11459 DESCRIPTION
11460 API to process set batch scan response from FW
11461
11462 PARAMETERS
11463 pRsp: Pointer to set batch scan response
11464 pUserData: Pointer to user data
11465
11466 RETURN VALUE
11467 NONE
11468
11469===========================================================================*/
11470void WDA_SetBatchScanRespCallback
11471(
11472 WDI_SetBatchScanRspType *pRsp,
11473 void* pUserData
11474)
11475{
11476 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
11477 tpAniSirGlobal pMac;
11478 void *pCallbackContext;
11479 tWDA_CbContext *pWDA = NULL ;
11480 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11481
11482
11483 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11484 "<------ %s " ,__func__);
11485 if (NULL == pWdaParams)
11486 {
11487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11488 "%s: pWdaParams received NULL", __func__);
11489 VOS_ASSERT(0) ;
11490 return ;
11491 }
11492
11493 /*extract WDA context*/
11494 pWDA = pWdaParams->pWdaContext;
11495 if (NULL == pWDA)
11496 {
11497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11498 "%s:pWDA is NULL can't invole HDD callback",
11499 __func__);
11500 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11501 vos_mem_free(pWdaParams->wdaMsgParam);
11502 vos_mem_free(pWdaParams);
11503 VOS_ASSERT(0);
11504 return;
11505 }
11506
11507 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11508 vos_mem_free(pWdaParams->wdaMsgParam);
11509 vos_mem_free(pWdaParams);
11510
11511 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11512 if (NULL == pMac)
11513 {
11514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11515 "%s:pMac is NULL", __func__);
11516 VOS_ASSERT(0);
11517 return;
11518 }
11519
11520 pHddSetBatchScanRsp =
11521 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
11522 if (NULL == pHddSetBatchScanRsp)
11523 {
11524 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11525 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
11526 VOS_ASSERT(0);
11527 return;
11528 }
11529
11530 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
11531
11532 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
11533 /*call hdd callback with set batch scan response data*/
11534 if(pMac->pmc.setBatchScanReqCallback)
11535 {
11536 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
11537 }
11538 else
11539 {
11540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11541 "%s:HDD callback is null", __func__);
11542 VOS_ASSERT(0);
11543 }
11544
11545 vos_mem_free(pHddSetBatchScanRsp);
11546 return ;
11547}
11548
11549/*==========================================================================
11550 FUNCTION WDA_ProcessSetBatchScanReq
11551
11552 DESCRIPTION
11553 API to send set batch scan request to WDI
11554
11555 PARAMETERS
11556 pWDA: Pointer to WDA context
11557 pSetBatchScanReq: Pointer to set batch scan req
11558
11559 RETURN VALUE
11560 NONE
11561
11562===========================================================================*/
11563VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
11564 tSirSetBatchScanReq *pSetBatchScanReq)
11565{
11566 WDI_Status status;
11567 tWDA_ReqParams *pWdaParams ;
11568 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
11569
11570 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11571 "------> %s " ,__func__);
11572
11573 pWdiSetBatchScanReq =
11574 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
11575 if (NULL == pWdiSetBatchScanReq)
11576 {
11577 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11578 "%s: VOS MEM Alloc Failure", __func__);
11579 vos_mem_free(pSetBatchScanReq);
11580 VOS_ASSERT(0);
11581 return VOS_STATUS_E_NOMEM;
11582 }
11583
11584 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
11585 if (NULL == pWdaParams)
11586 {
11587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11588 "%s: VOS MEM Alloc Failure", __func__);
11589 VOS_ASSERT(0);
11590 vos_mem_free(pSetBatchScanReq);
11591 vos_mem_free(pWdiSetBatchScanReq);
11592 return VOS_STATUS_E_NOMEM;
11593 }
11594
11595 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
11596 pWdiSetBatchScanReq->numberOfScansToBatch =
11597 pSetBatchScanReq->numberOfScansToBatch;
11598 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
11599 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
11600 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
11601
11602 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
11603 pWdaParams->pWdaContext = pWDA;
11604 pWdaParams->wdaMsgParam = pSetBatchScanReq;
11605
11606 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
11607 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
11608 if (IS_WDI_STATUS_FAILURE(status))
11609 {
11610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11611 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
11612 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11613 vos_mem_free(pWdaParams->wdaMsgParam);
11614 vos_mem_free(pWdaParams);
11615 }
11616 return CONVERT_WDI2VOS_STATUS(status);
11617}
11618
11619#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11620/*
11621 * FUNCTION: WDA_ProcessHT40OBSSScanInd
11622 *
11623 * DESCRIPTION: This function sends start/update OBSS scan
11624 * inidcation message to WDI
11625 *
11626 * PARAM:
11627 * pWDA: pointer to WDA context
11628 * pReq: pointer to start OBSS scan request
11629 */
11630VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
11631 tSirHT40OBSSScanInd *pReq)
11632{
11633 WDI_Status status;
11634 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
11635 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11636
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11637 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11638 "------> %s " ,__func__);
11639 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11640 wdiOBSSScanParams.pUserData = pWDA;
11641
11642 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
11643 pWdiOBSSScanInd->cmdType = pReq->cmdType;
11644 pWdiOBSSScanInd->scanType = pReq->scanType;
11645 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
11646 pReq->OBSSScanActiveDwellTime;
11647 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
11648 pReq->OBSSScanPassiveDwellTime;
11649 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
11650 pReq->BSSChannelWidthTriggerScanInterval;
11651 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
11652 pReq->BSSWidthChannelTransitionDelayFactor;
11653 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
11654 pReq->OBSSScanActiveTotalPerChannel;
11655 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
11656 pReq->OBSSScanPassiveTotalPerChannel;
11657 pWdiOBSSScanInd->OBSSScanActivityThreshold =
11658 pReq->OBSSScanActivityThreshold;
11659 pWdiOBSSScanInd->channelCount = pReq->channelCount;
11660 vos_mem_copy(pWdiOBSSScanInd->channels,
11661 pReq->channels,
11662 pReq->channelCount);
11663 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
11664 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
11665 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
11666 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
11667 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
11668
11669 vos_mem_copy(pWdiOBSSScanInd->ieField,
11670 pReq->ieField,
11671 pReq->ieFieldLen);
11672
11673 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
11674 if (WDI_STATUS_PENDING == status)
11675 {
11676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11677 "Pending received for %s:%d ",__func__,__LINE__ );
11678 }
11679 else if (WDI_STATUS_SUCCESS_SYNC != status)
11680 {
11681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11682 "Failure in %s:%d ",__func__,__LINE__ );
11683 }
11684 return CONVERT_WDI2VOS_STATUS(status) ;
11685}
11686/*
11687 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
11688 *
11689 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
11690 *
11691 * PARAM:
11692 * pWDA: pointer to WDA context
11693 * pReq: pointer to stop batch scan request
11694 */
11695VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
11696 tANI_U8 *bssIdx)
11697{
11698 WDI_Status status;
11699
11700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11701 "------> %s " ,__func__);
11702
11703 status = WDI_HT40OBSSStopScanInd(*bssIdx);
11704 if (WDI_STATUS_PENDING == status)
11705 {
11706 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11707 "Pending received for %s:%d ",__func__,__LINE__ );
11708 }
11709 else if (WDI_STATUS_SUCCESS_SYNC != status)
11710 {
11711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11712 "Failure in %s:%d ",__func__,__LINE__ );
11713 }
11714 return CONVERT_WDI2VOS_STATUS(status) ;
11715}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11716/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]11717 * FUNCTION: WDA_ProcessRateUpdateInd
11718 *
11719 */
11720VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
11721 tSirRateUpdateInd *pRateUpdateParams)
11722{
11723 WDI_Status wdiStatus;
11724 WDI_RateUpdateIndParams rateUpdateParams;
11725
11726 vos_mem_copy(rateUpdateParams.bssid,
11727 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
11728
11729 rateUpdateParams.ucastDataRateTxFlag =
11730 pRateUpdateParams->ucastDataRateTxFlag;
11731 rateUpdateParams.reliableMcastDataRateTxFlag =
11732 pRateUpdateParams->reliableMcastDataRateTxFlag;
11733 rateUpdateParams.mcastDataRate24GHzTxFlag =
11734 pRateUpdateParams->mcastDataRate24GHzTxFlag;
11735 rateUpdateParams.mcastDataRate5GHzTxFlag =
11736 pRateUpdateParams->mcastDataRate5GHzTxFlag;
11737
11738 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
11739 rateUpdateParams.reliableMcastDataRate =
11740 pRateUpdateParams->reliableMcastDataRate;
11741 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
11742 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
11743
11744 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11745 rateUpdateParams.pUserData = pWDA;
11746
11747 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
11748
11749 if (WDI_STATUS_PENDING == wdiStatus)
11750 {
11751 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11752 "Pending received for %s:%d", __func__, __LINE__ );
11753 }
11754 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11755 {
11756 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11757 "Failure in %s:%d", __func__, __LINE__ );
11758 }
11759
11760 vos_mem_free(pRateUpdateParams);
11761
11762 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11763}
11764
11765/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11766 * -------------------------------------------------------------------------
11767 * DATA interface with WDI for Mgmt Frames
11768 * -------------------------------------------------------------------------
11769 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11770/*
11771 * FUNCTION: WDA_TxComplete
11772 * Callback function for the WDA_TxPacket
11773 */
11774VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
11775 VOS_STATUS status )
11776{
11777
11778 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
11779 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11780 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11781
11782 if(NULL == wdaContext)
11783 {
11784 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11785 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11786 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11787 VOS_ASSERT(0);
11788 return VOS_STATUS_E_FAILURE;
11789 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11790
11791 /*Check if frame was timed out or not*/
11792 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
11793 (v_PVOID_t)&uUserData);
11794
11795 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
11796 {
11797 /*Discard frame - no further processing is needed*/
11798 vos_pkt_return_packet(pData);
11799 return VOS_STATUS_SUCCESS;
11800 }
11801
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11802 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
11803 if( NULL!=wdaContext->pTxCbFunc)
11804 {
11805 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11806 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]11807 {
11808 wdaContext->pTxCbFunc(pMac, pData);
11809 }
11810 else
11811 {
11812 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]11813 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11814 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11815 //Return from here since we reaching here because the packet already timeout
11816 return status;
11817 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11818 }
11819
11820 /*
11821 * Trigger the event to bring the HAL TL Tx complete function to come
11822 * out of wait
11823 * Let the coe above to complete the packet first. When this event is set,
11824 * the thread waiting for the event may run and set Vospacket_freed causing the original
11825 * packet not being freed.
11826 */
11827 status = vos_event_set(&wdaContext->txFrameEvent);
11828 if(!VOS_IS_STATUS_SUCCESS(status))
11829 {
11830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11831 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11832 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11833 return status;
11834}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11835/*
11836 * FUNCTION: WDA_TxPacket
11837 * Forward TX management frame to WDI
11838 */
11839VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
11840 void *pFrmBuf,
11841 tANI_U16 frmLen,
11842 eFrameType frmType,
11843 eFrameTxDir txDir,
11844 tANI_U8 tid,
11845 pWDATxRxCompFunc pCompFunc,
11846 void *pData,
11847 pWDAAckFnTxComp pAckTxComp,
Kanchanapally, Vidyullathaf9426e52013-12-24 17:28:54 +0530[diff] [blame]11848 tANI_U32 txFlag)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11849{
11850 VOS_STATUS status = VOS_STATUS_SUCCESS ;
11851 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
11852 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
11853 tANI_U8 eventIdx = 0;
11854 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
11855 tpAniSirGlobal pMac;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11856 if((NULL == pWDA)||(NULL == pFrmBuf))
11857 {
11858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]11859 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11860 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11861 VOS_ASSERT(0);
11862 return VOS_STATUS_E_FAILURE;
11863 }
11864
11865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11866 "Tx Mgmt Frame Subtype: %d alloc(%p)", pFc->subType, pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11867 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11868 if(NULL == pMac)
11869 {
11870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11871 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11872 VOS_ASSERT(0);
11873 return VOS_STATUS_E_FAILURE;
11874 }
11875
11876
11877
11878 /* store the call back function in WDA context */
11879 pWDA->pTxCbFunc = pCompFunc;
11880 /* store the call back for the function of ackTxComplete */
11881 if( pAckTxComp )
11882 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11883 if( NULL != pWDA->pAckTxCbFunc )
11884 {
11885 /* Already TxComp is active no need to active again */
11886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11887 "There is already one request pending for tx complete");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11888 pWDA->pAckTxCbFunc( pMac, 0);
11889 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11890
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11891 if( VOS_STATUS_SUCCESS !=
11892 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11893 {
11894 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11895 "Tx Complete timeout Timer Stop Failed ");
11896 }
11897 else
11898 {
11899 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]11900 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11901 }
11902 }
11903
11904 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
11905 pWDA->pAckTxCbFunc = pAckTxComp;
11906 if( VOS_STATUS_SUCCESS !=
11907 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
11908 {
11909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11910 "Tx Complete Timer Start Failed ");
11911 pWDA->pAckTxCbFunc = NULL;
11912 return eHAL_STATUS_FAILURE;
11913 }
11914 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11915 /* Reset the event to be not signalled */
11916 status = vos_event_reset(&pWDA->txFrameEvent);
11917 if(!VOS_IS_STATUS_SUCCESS(status))
11918 {
11919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11920 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11921 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
11922 if( pAckTxComp )
11923 {
11924 pWDA->pAckTxCbFunc = NULL;
11925 if( VOS_STATUS_SUCCESS !=
11926 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11927 {
11928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11929 "Tx Complete timeout Timer Stop Failed ");
11930 }
11931 }
11932 return VOS_STATUS_E_FAILURE;
11933 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11934
11935 /* If Peer Sta mask is set don't overwrite to self sta */
11936 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11937 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11938 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11939 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11940 else
11941 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11942 /* Get system role, use the self station if in unknown role or STA role */
11943 systemRole = wdaGetGlobalSystemRole(pMac);
11944 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
11945 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]11946#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11947 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11948#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11949 ))
11950 {
11951 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
11952 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]11953 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11954
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11955 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
11956 disassoc frame reaches the HW, HAL has already deleted the peer station */
11957 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11958 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]11959 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11960 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11961 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11962 /*Send Probe request frames on self sta idx*/
11963 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11964 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11965 /* Since we donot want probe responses to be retried, send probe responses
11966 through the NO_ACK queues */
11967 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
11968 {
11969 //probe response is sent out using self station and no retries options.
11970 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
11971 }
11972 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
11973 {
11974 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
11975 }
11976 }
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11977 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]11978
11979 /*Set frame tag to 0
11980 We will use the WDA user data in order to tag a frame as expired*/
11981 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
11982 (v_PVOID_t)0);
11983
11984
11985 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
11986 frmLen, ucTypeSubType, tid,
11987 WDA_TxComplete, NULL, txFlag)) != VOS_STATUS_SUCCESS)
11988 {
11989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11990 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11991 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11992 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]11993 if( pAckTxComp )
11994 {
11995 pWDA->pAckTxCbFunc = NULL;
11996 if( VOS_STATUS_SUCCESS !=
11997 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11998 {
11999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12000 "Tx Complete timeout Timer Stop Failed ");
12001 }
12002 }
12003 return VOS_STATUS_E_FAILURE;
12004 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12005 /*
12006 * Wait for the event to be set by the TL, to get the response of TX
12007 * complete, this event should be set by the Callback function called by TL
12008 */
12009 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
12010 &eventIdx);
12011 if(!VOS_IS_STATUS_SUCCESS(status))
12012 {
12013 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12014 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12015 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12016 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
12017 after the packet gets completed(packet freed once)*/
12018
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12019 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]12020 WDA_TransportChannelDebug(pMac, 1, WPAL_DEBUG_TX_DESC_RESYNC);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12021
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12022 /*Tag Frame as timed out for later deletion*/
12023 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12024 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
12025
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12026 /* check whether the packet was freed already,so need not free again when
12027 * TL calls the WDA_Txcomplete routine
12028 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12029 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
12030 /*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]12031 {
12032 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12033 } */
12034
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12035 if( pAckTxComp )
12036 {
12037 pWDA->pAckTxCbFunc = NULL;
12038 if( VOS_STATUS_SUCCESS !=
12039 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12040 {
12041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12042 "Tx Complete timeout Timer Stop Failed ");
12043 }
12044 }
12045 status = VOS_STATUS_E_FAILURE;
12046 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]12047#ifdef WLAN_DUMP_MGMTFRAMES
12048 if (VOS_IS_STATUS_SUCCESS(status))
12049 {
12050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12051 "%s() TX packet : SubType %d", __func__,pFc->subType);
12052 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12053 pData, frmLen);
12054 }
12055#endif
12056
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]12057 if (VOS_IS_STATUS_SUCCESS(status))
12058 {
12059 if (pMac->fEnableDebugLog & 0x1)
12060 {
12061 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
12062 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
12063 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
12064 {
12065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
12066 pFc->type, pFc->subType);
12067 }
12068 }
12069 }
12070
12071
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12072 return status;
12073}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12074/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12075 * FUNCTION: WDA_ProcessDHCPStartInd
12076 * Forward DHCP Start to WDI
12077 */
12078static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
12079 tAniDHCPInd *dhcpStartInd)
12080{
12081 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12082 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12083
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12084 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
12085 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12086 sizeof(tSirMacAddr));
12087
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12088 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12089
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12090 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12091 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12093 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12094 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12095 else if (WDI_STATUS_SUCCESS_SYNC != status)
12096 {
12097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12098 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
12099 }
12100
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12101 vos_mem_free(dhcpStartInd);
12102 return CONVERT_WDI2VOS_STATUS(status) ;
12103}
12104
12105 /*
12106 * FUNCTION: WDA_ProcessDHCPStopInd
12107 * Forward DHCP Stop to WDI
12108 */
12109 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
12110 tAniDHCPInd *dhcpStopInd)
12111 {
12112 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12113 WDI_DHCPInd wdiDHCPInd;
12114
12115 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
12116 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
12117
12118 status = WDI_dhcpStopInd(&wdiDHCPInd);
12119
12120 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12121 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12123 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12124 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12125 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12126 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12127 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12128 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12129 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12130
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12131 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12132
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12133 return CONVERT_WDI2VOS_STATUS(status) ;
12134 }
12135
12136/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12137 * FUNCTION: WDA_McProcessMsg
12138 * Trigger DAL-AL to start CFG download
12139 */
12140VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
12141{
12142 VOS_STATUS status = VOS_STATUS_SUCCESS;
12143 tWDA_CbContext *pWDA = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12144 if(NULL == pMsg)
12145 {
12146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12147 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12148 VOS_ASSERT(0);
12149 return VOS_STATUS_E_FAILURE;
12150 }
12151
12152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12153 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12154
12155 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
12156 if(NULL == pWDA )
12157 {
12158 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12159 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12160 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12161 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12162 return VOS_STATUS_E_FAILURE;
12163 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12164 /* Process all the WDA messages.. */
12165 switch( pMsg->type )
12166 {
12167 case WNI_CFG_DNLD_REQ:
12168 {
12169 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12170 /* call WDA complete event if config download success */
12171 if( VOS_IS_STATUS_SUCCESS(status) )
12172 {
12173 vos_WDAComplete_cback(pVosContext);
12174 }
12175 else
12176 {
12177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12178 "WDA Config Download failure" );
12179 }
12180 break ;
12181 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12182 /*
12183 * Init SCAN request from PE, convert it into DAL format
12184 * and send it to DAL
12185 */
12186 case WDA_INIT_SCAN_REQ:
12187 {
12188 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
12189 break ;
12190 }
12191 /* start SCAN request from PE */
12192 case WDA_START_SCAN_REQ:
12193 {
12194 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
12195 break ;
12196 }
12197 /* end SCAN request from PE */
12198 case WDA_END_SCAN_REQ:
12199 {
12200 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
12201 break ;
12202 }
12203 /* end SCAN request from PE */
12204 case WDA_FINISH_SCAN_REQ:
12205 {
12206 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
12207 break ;
12208 }
12209 /* join request from PE */
12210 case WDA_CHNL_SWITCH_REQ:
12211 {
12212 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
12213 {
12214 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
12215 }
12216 else
12217 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]12218 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
12219 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
12220 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
12221 {
12222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12223 "call ProcessChannelSwitchReq_V1" );
12224 WDA_ProcessChannelSwitchReq_V1(pWDA,
12225 (tSwitchChannelParams*)pMsg->bodyptr) ;
12226 }
12227 else
12228 {
12229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12230 "call ProcessChannelSwitchReq" );
12231 WDA_ProcessChannelSwitchReq(pWDA,
12232 (tSwitchChannelParams*)pMsg->bodyptr) ;
12233 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12234 }
12235 break ;
12236 }
12237 /* ADD BSS request from PE */
12238 case WDA_ADD_BSS_REQ:
12239 {
12240 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
12241 break ;
12242 }
12243 case WDA_ADD_STA_REQ:
12244 {
12245 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
12246 break ;
12247 }
12248 case WDA_DELETE_BSS_REQ:
12249 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12250 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
12251 break ;
12252 }
12253 case WDA_DELETE_STA_REQ:
12254 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12255 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
12256 break ;
12257 }
12258 case WDA_CONFIG_PARAM_UPDATE_REQ:
12259 {
12260 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
12261 break ;
12262 }
12263 case WDA_SET_BSSKEY_REQ:
12264 {
12265 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
12266 break ;
12267 }
12268 case WDA_SET_STAKEY_REQ:
12269 {
12270 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12271 break ;
12272 }
12273 case WDA_SET_STA_BCASTKEY_REQ:
12274 {
12275 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12276 break ;
12277 }
12278 case WDA_REMOVE_BSSKEY_REQ:
12279 {
12280 WDA_ProcessRemoveBssKeyReq(pWDA,
12281 (tRemoveBssKeyParams *)pMsg->bodyptr);
12282 break ;
12283 }
12284 case WDA_REMOVE_STAKEY_REQ:
12285 {
12286 WDA_ProcessRemoveStaKeyReq(pWDA,
12287 (tRemoveStaKeyParams *)pMsg->bodyptr);
12288 break ;
12289 }
12290 case WDA_REMOVE_STA_BCASTKEY_REQ:
12291 {
12292 /* TODO: currently UMAC is not sending this request, Add the code for
12293 handling this request when UMAC supports */
12294 break;
12295 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12296#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12297 case WDA_TSM_STATS_REQ:
12298 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]12299 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12300 break;
12301 }
12302#endif
12303 case WDA_UPDATE_EDCA_PROFILE_IND:
12304 {
12305 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
12306 break;
12307 }
12308 case WDA_ADD_TS_REQ:
12309 {
12310 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
12311 break;
12312 }
12313 case WDA_DEL_TS_REQ:
12314 {
12315 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
12316 break;
12317 }
12318 case WDA_ADDBA_REQ:
12319 {
12320 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
12321 break;
12322 }
12323 case WDA_DELBA_IND:
12324 {
12325 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
12326 break;
12327 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]12328 case WDA_UPDATE_CHAN_LIST_REQ:
12329 {
12330 WDA_ProcessUpdateChannelList(pWDA,
12331 (tSirUpdateChanList *)pMsg->bodyptr);
12332 break;
12333 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12334 case WDA_SET_LINK_STATE:
12335 {
12336 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
12337 break;
12338 }
12339 case WDA_GET_STATISTICS_REQ:
12340 {
12341 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
12342 break;
12343 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12344#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]12345 case WDA_GET_ROAM_RSSI_REQ:
12346 {
12347 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
12348 break;
12349 }
12350#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12351 case WDA_PWR_SAVE_CFG:
12352 {
12353 if(pWDA->wdaState == WDA_READY_STATE)
12354 {
12355 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
12356 }
12357 else
12358 {
12359 if(NULL != pMsg->bodyptr)
12360 {
12361 vos_mem_free(pMsg->bodyptr);
12362 }
12363 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12364 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
12365 }
12366 break;
12367 }
12368 case WDA_ENTER_IMPS_REQ:
12369 {
12370 if(pWDA->wdaState == WDA_READY_STATE)
12371 {
12372 WDA_ProcessEnterImpsReq(pWDA);
12373 }
12374 else
12375 {
12376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12377 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12378 }
12379 break;
12380 }
12381 case WDA_EXIT_IMPS_REQ:
12382 {
12383 if(pWDA->wdaState == WDA_READY_STATE)
12384 {
12385 WDA_ProcessExitImpsReq(pWDA);
12386 }
12387 else
12388 {
12389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12390 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12391 }
12392 break;
12393 }
12394 case WDA_ENTER_BMPS_REQ:
12395 {
12396 if(pWDA->wdaState == WDA_READY_STATE)
12397 {
12398 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
12399 }
12400 else
12401 {
12402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12403 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12404 }
12405 break;
12406 }
12407 case WDA_EXIT_BMPS_REQ:
12408 {
12409 if(pWDA->wdaState == WDA_READY_STATE)
12410 {
12411 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
12412 }
12413 else
12414 {
12415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12416 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12417 }
12418 break;
12419 }
12420 case WDA_ENTER_UAPSD_REQ:
12421 {
12422 if(pWDA->wdaState == WDA_READY_STATE)
12423 {
12424 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
12425 }
12426 else
12427 {
12428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12429 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12430 }
12431 break;
12432 }
12433 case WDA_EXIT_UAPSD_REQ:
12434 {
12435 if(pWDA->wdaState == WDA_READY_STATE)
12436 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12437 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12438 }
12439 else
12440 {
12441 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12442 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12443 }
12444 break;
12445 }
12446 case WDA_UPDATE_UAPSD_IND:
12447 {
12448 if(pWDA->wdaState == WDA_READY_STATE)
12449 {
12450 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
12451 }
12452 else
12453 {
12454 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12455 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
12456 }
12457 break;
12458 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12459 case WDA_REGISTER_PE_CALLBACK :
12460 {
12461 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12462 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
12463 /*TODO: store the PE callback */
12464 /* Do Nothing? MSG Body should be freed at here */
12465 if(NULL != pMsg->bodyptr)
12466 {
12467 vos_mem_free(pMsg->bodyptr);
12468 }
12469 break;
12470 }
12471 case WDA_SYS_READY_IND :
12472 {
12473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12474 "Handling msg type WDA_SYS_READY_IND " );
12475 pWDA->wdaState = WDA_READY_STATE;
12476 if(NULL != pMsg->bodyptr)
12477 {
12478 vos_mem_free(pMsg->bodyptr);
12479 }
12480 break;
12481 }
12482 case WDA_BEACON_FILTER_IND :
12483 {
12484 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
12485 break;
12486 }
12487 case WDA_BTC_SET_CFG:
12488 {
12489 /*TODO: handle this while dealing with BTC */
12490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12491 "Handling msg type WDA_BTC_SET_CFG " );
12492 /* Do Nothing? MSG Body should be freed at here */
12493 if(NULL != pMsg->bodyptr)
12494 {
12495 vos_mem_free(pMsg->bodyptr);
12496 }
12497 break;
12498 }
12499 case WDA_SIGNAL_BT_EVENT:
12500 {
12501 /*TODO: handle this while dealing with BTC */
12502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12503 "Handling msg type WDA_SIGNAL_BT_EVENT " );
12504 /* Do Nothing? MSG Body should be freed at here */
12505 if(NULL != pMsg->bodyptr)
12506 {
12507 vos_mem_free(pMsg->bodyptr);
12508 }
12509 break;
12510 }
12511 case WDA_CFG_RXP_FILTER_REQ:
12512 {
12513 WDA_ProcessConfigureRxpFilterReq(pWDA,
12514 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
12515 break;
12516 }
12517 case WDA_SET_HOST_OFFLOAD:
12518 {
12519 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12520 break;
12521 }
12522 case WDA_SET_KEEP_ALIVE:
12523 {
12524 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
12525 break;
12526 }
12527#ifdef WLAN_NS_OFFLOAD
12528 case WDA_SET_NS_OFFLOAD:
12529 {
12530 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12531 break;
12532 }
12533#endif //WLAN_NS_OFFLOAD
12534 case WDA_ADD_STA_SELF_REQ:
12535 {
12536 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
12537 break;
12538 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12539 case WDA_DEL_STA_SELF_REQ:
12540 {
12541 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
12542 break;
12543 }
12544 case WDA_WOWL_ADD_BCAST_PTRN:
12545 {
12546 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
12547 break;
12548 }
12549 case WDA_WOWL_DEL_BCAST_PTRN:
12550 {
12551 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
12552 break;
12553 }
12554 case WDA_WOWL_ENTER_REQ:
12555 {
12556 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
12557 break;
12558 }
12559 case WDA_WOWL_EXIT_REQ:
12560 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12561 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12562 break;
12563 }
12564 case WDA_TL_FLUSH_AC_REQ:
12565 {
12566 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
12567 break;
12568 }
12569 case WDA_SIGNAL_BTAMP_EVENT:
12570 {
12571 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
12572 break;
12573 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]12574#ifdef WLAN_FEATURE_LINK_LAYER_STATS
12575 case WDA_LINK_LAYER_STATS_SET_REQ:
12576 {
12577 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
12578 break;
12579 }
12580 case WDA_LINK_LAYER_STATS_GET_REQ:
12581 {
12582 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
12583 break;
12584 }
12585 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
12586 {
12587 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
12588 break;
12589 }
12590#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]12591#ifdef WLAN_FEATURE_EXTSCAN
12592 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
12593 {
12594 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
12595 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
12596 break;
12597 }
12598 case WDA_EXTSCAN_START_REQ:
12599 {
12600 WDA_ProcessEXTScanStartReq(pWDA,
12601 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
12602 break;
12603 }
12604 case WDA_EXTSCAN_STOP_REQ:
12605 {
12606 WDA_ProcessEXTScanStopReq(pWDA,
12607 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
12608 break;
12609 }
12610 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
12611 {
12612 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
12613 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
12614 break;
12615 }
12616 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
12617 {
12618 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
12619 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
12620 break;
12621 }
12622 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
12623 {
12624 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
12625 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
12626 break;
12627 }
12628 case WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_REQ:
12629 {
12630 WDA_ProcessEXTScanSetSignfRSSIChangeReq(pWDA,
12631 (tSirEXTScanSetSignificantChangeReqParams *)pMsg->bodyptr);
12632 break;
12633 }
12634 case WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_REQ:
12635 {
12636 WDA_ProcessEXTScanResetSignfRSSIChangeReq(pWDA,
12637 (tSirEXTScanResetSignificantChangeReqParams *)pMsg->bodyptr);
12638 break;
12639 }
12640#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12641#ifdef WDA_UT
12642 case WDA_WDI_EVENT_MSG:
12643 {
12644 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
12645 break ;
12646 }
12647#endif
12648 case WDA_UPDATE_BEACON_IND:
12649 {
12650 WDA_ProcessUpdateBeaconParams(pWDA,
12651 (tUpdateBeaconParams *)pMsg->bodyptr);
12652 break;
12653 }
12654 case WDA_SEND_BEACON_REQ:
12655 {
12656 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
12657 break;
12658 }
12659 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
12660 {
12661 WDA_ProcessUpdateProbeRspTemplate(pWDA,
12662 (tSendProbeRespParams *)pMsg->bodyptr);
12663 break;
12664 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12665#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12666 case WDA_SET_MAX_TX_POWER_REQ:
12667 {
12668 WDA_ProcessSetMaxTxPowerReq(pWDA,
12669 (tMaxTxPowerParams *)pMsg->bodyptr);
12670 break;
12671 }
12672#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]12673 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
12674 {
12675 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
12676 pMsg->bodyptr);
12677 break;
12678 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]12679 case WDA_SET_TX_POWER_REQ:
12680 {
12681 WDA_ProcessSetTxPowerReq(pWDA,
12682 (tSirSetTxPowerReq *)pMsg->bodyptr);
12683 break;
12684 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12685 case WDA_SET_P2P_GO_NOA_REQ:
12686 {
12687 WDA_ProcessSetP2PGONOAReq(pWDA,
12688 (tP2pPsParams *)pMsg->bodyptr);
12689 break;
12690 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12691 /* timer related messages */
12692 case WDA_TIMER_BA_ACTIVITY_REQ:
12693 {
12694 WDA_BaCheckActivity(pWDA) ;
12695 break ;
12696 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]12697
12698 /* timer related messages */
12699 case WDA_TIMER_TRAFFIC_STATS_IND:
12700 {
12701 WDA_TimerTrafficStatsInd(pWDA);
12702 break;
12703 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12704#ifdef WLAN_FEATURE_VOWIFI_11R
12705 case WDA_AGGR_QOS_REQ:
12706 {
12707 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
12708 break;
12709 }
12710#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12711 case WDA_FTM_CMD_REQ:
12712 {
12713 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
12714 break ;
12715 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12716#ifdef FEATURE_OEM_DATA_SUPPORT
12717 case WDA_START_OEM_DATA_REQ:
12718 {
12719 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
12720 break;
12721 }
12722#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12723 /* Tx Complete Time out Indication */
12724 case WDA_TX_COMPLETE_TIMEOUT_IND:
12725 {
12726 WDA_ProcessTxCompleteTimeOutInd(pWDA);
12727 break;
12728 }
12729 case WDA_WLAN_SUSPEND_IND:
12730 {
12731 WDA_ProcessWlanSuspendInd(pWDA,
12732 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
12733 break;
12734 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12735 case WDA_WLAN_RESUME_REQ:
12736 {
12737 WDA_ProcessWlanResumeReq(pWDA,
12738 (tSirWlanResumeParam *)pMsg->bodyptr) ;
12739 break;
12740 }
12741
12742 case WDA_UPDATE_CF_IND:
12743 {
12744 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
12745 pMsg->bodyptr = NULL;
12746 break;
12747 }
12748#ifdef FEATURE_WLAN_SCAN_PNO
12749 case WDA_SET_PNO_REQ:
12750 {
12751 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
12752 break;
12753 }
12754 case WDA_UPDATE_SCAN_PARAMS_REQ:
12755 {
12756 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
12757 break;
12758 }
12759 case WDA_SET_RSSI_FILTER_REQ:
12760 {
12761 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
12762 break;
12763 }
12764#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12765#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12766 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12767 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12768 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12769 break;
12770 }
12771#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12772 case WDA_SET_TX_PER_TRACKING_REQ:
12773 {
12774 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
12775 break;
12776 }
12777
12778#ifdef WLAN_FEATURE_PACKET_FILTERING
12779 case WDA_8023_MULTICAST_LIST_REQ:
12780 {
12781 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
12782 break;
12783 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12784 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
12785 {
12786 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
12787 break;
12788 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12789 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
12790 {
12791 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
12792 break;
12793 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12794 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
12795 {
12796 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
12797 break;
12798 }
12799#endif // WLAN_FEATURE_PACKET_FILTERING
12800
12801
12802 case WDA_TRANSMISSION_CONTROL_IND:
12803 {
12804 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
12805 break;
12806 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12807 case WDA_SET_POWER_PARAMS_REQ:
12808 {
12809 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
12810 break;
12811 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12812#ifdef WLAN_FEATURE_GTK_OFFLOAD
12813 case WDA_GTK_OFFLOAD_REQ:
12814 {
12815 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
12816 break;
12817 }
12818
12819 case WDA_GTK_OFFLOAD_GETINFO_REQ:
12820 {
12821 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
12822 break;
12823 }
12824#endif //WLAN_FEATURE_GTK_OFFLOAD
12825
12826 case WDA_SET_TM_LEVEL_REQ:
12827 {
12828 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
12829 break;
12830 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]12831
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12832 case WDA_UPDATE_OP_MODE:
12833 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]12834 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
12835 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
12836 {
12837 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
12838 }
12839 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12840 {
12841 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
12842 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
12843 else
12844 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12845 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12846 }
12847 else
12848 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12849 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12850 break;
12851 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]12852#ifdef WLAN_FEATURE_11W
12853 case WDA_EXCLUDE_UNENCRYPTED_IND:
12854 {
12855 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
12856 break;
12857 }
12858#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]12859#ifdef FEATURE_WLAN_TDLS
12860 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
12861 {
12862 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
12863 break;
12864 }
12865#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12866 case WDA_DHCP_START_IND:
12867 {
12868 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
12869 break;
12870 }
12871 case WDA_DHCP_STOP_IND:
12872 {
12873 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
12874 break;
12875 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]12876#ifdef FEATURE_WLAN_LPHB
12877 case WDA_LPHB_CONF_REQ:
12878 {
12879 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
12880 break;
12881 }
12882#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]12883 case WDA_ADD_PERIODIC_TX_PTRN_IND:
12884 {
12885 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
12886 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
12887 break;
12888 }
12889 case WDA_DEL_PERIODIC_TX_PTRN_IND:
12890 {
12891 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
12892 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
12893 break;
12894 }
12895
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12896#ifdef FEATURE_WLAN_BATCH_SCAN
12897 case WDA_SET_BATCH_SCAN_REQ:
12898 {
12899 WDA_ProcessSetBatchScanReq(pWDA,
12900 (tSirSetBatchScanReq *)pMsg->bodyptr);
12901 break;
12902 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]12903 case WDA_RATE_UPDATE_IND:
12904 {
12905 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
12906 break;
12907 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12908 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
12909 {
12910 WDA_ProcessTriggerBatchScanResultInd(pWDA,
12911 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
12912 break;
12913 }
12914 case WDA_STOP_BATCH_SCAN_IND:
12915 {
12916 WDA_ProcessStopBatchScanInd(pWDA,
12917 (tSirStopBatchScanInd *)pMsg->bodyptr);
12918 break;
12919 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]12920 case WDA_GET_BCN_MISS_RATE_REQ:
12921 WDA_ProcessGetBcnMissRateReq(pWDA,
12922 (tSirBcnMissRateReq *)pMsg->bodyptr);
12923 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12924#endif
12925
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]12926 case WDA_HT40_OBSS_SCAN_IND:
12927 {
12928 WDA_ProcessHT40OBSSScanInd(pWDA,
12929 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
12930 break;
12931 }
12932 case WDA_HT40_OBSS_STOP_SCAN_IND:
12933 {
12934 WDA_ProcessHT40OBSSStopScanInd(pWDA,
12935 (tANI_U8*)pMsg->bodyptr);
12936 break;
12937 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12938 default:
12939 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]12940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12941 "No Handling for msg type %x in WDA "
12942 ,pMsg->type);
12943 /* Do Nothing? MSG Body should be freed at here */
12944 if(NULL != pMsg->bodyptr)
12945 {
12946 vos_mem_free(pMsg->bodyptr);
12947 }
12948 //WDA_VOS_ASSERT(0) ;
12949 }
12950 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12951 return status ;
12952}
12953
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12954/*
12955 * FUNCTION: WDA_LowLevelIndCallback
12956 * IND API callback from WDI, send Ind to PE
12957 */
12958void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
12959 void* pUserData )
12960{
12961 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
12962#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
12963 tSirRSSINotification rssiNotification;
12964#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12965 if(NULL == pWDA)
12966 {
12967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12968 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12969 VOS_ASSERT(0);
12970 return ;
12971 }
12972
12973 switch(wdiLowLevelInd->wdiIndicationType)
12974 {
12975 case WDI_RSSI_NOTIFICATION_IND:
12976 {
12977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12978 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12979#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
12980 rssiNotification.bReserved =
12981 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
12982 rssiNotification.bRssiThres1NegCross =
12983 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
12984 rssiNotification.bRssiThres1PosCross =
12985 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
12986 rssiNotification.bRssiThres2NegCross =
12987 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
12988 rssiNotification.bRssiThres2PosCross =
12989 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
12990 rssiNotification.bRssiThres3NegCross =
12991 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
12992 rssiNotification.bRssiThres3PosCross =
12993 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]12994 rssiNotification.avgRssi = (v_S7_t)
12995 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12996 WLANTL_BMPSRSSIRegionChangedNotification(
12997 pWDA->pVosContext,
12998 &rssiNotification);
12999#endif
13000 break ;
13001 }
13002 case WDI_MISSED_BEACON_IND:
13003 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13004 tpSirSmeMissedBeaconInd pMissBeacInd =
13005 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13006 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13007 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13008 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13009 if(NULL == pMissBeacInd)
13010 {
13011 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13012 "%s: VOS MEM Alloc Failure", __func__);
13013 break;
13014 }
13015 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
13016 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
13017 pMissBeacInd->bssIdx =
13018 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
13019 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13020 break ;
13021 }
13022 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
13023 {
13024 /* TODO: Decode Ind and send Ind to PE */
13025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13026 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
13027 break ;
13028 }
13029
13030 case WDI_MIC_FAILURE_IND:
13031 {
13032 tpSirSmeMicFailureInd pMicInd =
13033 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
13034
13035 if(NULL == pMicInd)
13036 {
13037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13038 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13039 break;
13040 }
13041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13042 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13043 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
13044 pMicInd->length = sizeof(tSirSmeMicFailureInd);
13045 vos_mem_copy(pMicInd->bssId,
13046 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
13047 sizeof(tSirMacAddr));
13048 vos_mem_copy(pMicInd->info.srcMacAddr,
13049 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
13050 sizeof(tSirMacAddr));
13051 vos_mem_copy(pMicInd->info.taMacAddr,
13052 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
13053 sizeof(tSirMacAddr));
13054 vos_mem_copy(pMicInd->info.dstMacAddr,
13055 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
13056 sizeof(tSirMacAddr));
13057 vos_mem_copy(pMicInd->info.rxMacAddr,
13058 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
13059 sizeof(tSirMacAddr));
13060 pMicInd->info.multicast =
13061 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
13062 pMicInd->info.keyId=
13063 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
13064 pMicInd->info.IV1=
13065 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
13066 vos_mem_copy(pMicInd->info.TSC,
13067 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13068 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
13069 (void *)pMicInd , 0) ;
13070 break ;
13071 }
13072 case WDI_FATAL_ERROR_IND:
13073 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]13074 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13075 /* TODO: Decode Ind and send Ind to PE */
13076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13077 "Received WDI_FATAL_ERROR_IND from WDI ");
13078 break ;
13079 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13080 case WDI_DEL_STA_IND:
13081 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13082 tpDeleteStaContext pDelSTACtx =
13083 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
13084
13085 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13086 "Received WDI_DEL_STA_IND from WDI ");
13087 if(NULL == pDelSTACtx)
13088 {
13089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13090 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13091 break;
13092 }
13093 vos_mem_copy(pDelSTACtx->addr2,
13094 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
13095 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13096 vos_mem_copy(pDelSTACtx->bssId,
13097 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
13098 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13099 pDelSTACtx->assocId =
13100 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
13101 pDelSTACtx->reasonCode =
13102 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
13103 pDelSTACtx->staId =
13104 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13105 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
13106 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13107 break ;
13108 }
13109 case WDI_COEX_IND:
13110 {
13111 tANI_U32 index;
13112 vos_msg_t vosMsg;
13113 tSirSmeCoexInd *pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
13114 if(NULL == pSmeCoexInd)
13115 {
13116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13117 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13118 break;
13119 }
13120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13121 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13122 /* Message Header */
13123 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
13124 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13125 /* Info from WDI Indication */
13126 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
13127 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
13128 {
13129 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
13130 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13131 /* VOS message wrapper */
13132 vosMsg.type = eWNI_SME_COEX_IND;
13133 vosMsg.bodyptr = (void *)pSmeCoexInd;
13134 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13135 /* Send message to SME */
13136 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13137 {
13138 /* free the mem and return */
13139 vos_mem_free((v_VOID_t *)pSmeCoexInd);
13140 }
13141 else
13142 {
13143 /* DEBUG */
13144 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13145 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
13146 pSmeCoexInd->coexIndType,
13147 pSmeCoexInd->coexIndData[0],
13148 pSmeCoexInd->coexIndData[1],
13149 pSmeCoexInd->coexIndData[2],
13150 pSmeCoexInd->coexIndData[3]);
13151 }
13152 break;
13153 }
13154 case WDI_TX_COMPLETE_IND:
13155 {
13156 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
13157 /* Calling TxCompleteAck Indication from wda context*/
13158 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13159 "Complete Indication received from HAL");
13160 if( pWDA->pAckTxCbFunc )
13161 {
13162 if( VOS_STATUS_SUCCESS !=
13163 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13164 {
13165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13166 "Tx Complete timeout Timer Stop Failed ");
13167 }
13168 pWDA->pAckTxCbFunc( pMac, wdiLowLevelInd->wdiIndicationData.tx_complete_status);
13169 pWDA->pAckTxCbFunc = NULL;
13170 }
13171 else
13172 {
13173 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13174 "Tx Complete Indication is received after timeout ");
13175 }
13176 break;
13177 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]13178 case WDI_P2P_NOA_START_IND :
13179 {
13180 tSirP2PNoaStart *pP2pNoaStart =
13181 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
13182
13183 if (NULL == pP2pNoaStart)
13184 {
13185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13186 "Memory allocation failure, "
13187 "WDI_P2P_NOA_START_IND not forwarded");
13188 break;
13189 }
13190 pP2pNoaStart->status =
13191 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
13192 pP2pNoaStart->bssIdx =
13193 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
13194 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
13195 (void *)pP2pNoaStart , 0) ;
13196 break;
13197 }
13198
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13199#ifdef FEATURE_WLAN_TDLS
13200 case WDI_TDLS_IND :
13201 {
13202 tSirTdlsInd *pTdlsInd =
13203 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
13204
13205 if (NULL == pTdlsInd)
13206 {
13207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13208 "Memory allocation failure, "
13209 "WDI_TDLS_IND not forwarded");
13210 break;
13211 }
13212 pTdlsInd->status =
13213 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
13214 pTdlsInd->assocId =
13215 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
13216 pTdlsInd->staIdx =
13217 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
13218 pTdlsInd->reasonCode =
13219 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
13220 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
13221 (void *)pTdlsInd , 0) ;
13222 break;
13223 }
13224#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13225 case WDI_P2P_NOA_ATTR_IND :
13226 {
13227 tSirP2PNoaAttr *pP2pNoaAttr =
13228 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13230 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13231 if (NULL == pP2pNoaAttr)
13232 {
13233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13234 "Memory allocation failure, "
13235 "WDI_P2P_NOA_ATTR_IND not forwarded");
13236 break;
13237 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13238 pP2pNoaAttr->index =
13239 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
13240 pP2pNoaAttr->oppPsFlag =
13241 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
13242 pP2pNoaAttr->ctWin =
13243 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
13244
13245 pP2pNoaAttr->uNoa1IntervalCnt =
13246 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
13247 pP2pNoaAttr->uNoa1Duration =
13248 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
13249 pP2pNoaAttr->uNoa1Interval =
13250 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
13251 pP2pNoaAttr->uNoa1StartTime =
13252 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13253 pP2pNoaAttr->uNoa2IntervalCnt =
13254 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
13255 pP2pNoaAttr->uNoa2Duration =
13256 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
13257 pP2pNoaAttr->uNoa2Interval =
13258 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
13259 pP2pNoaAttr->uNoa2StartTime =
13260 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13261 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
13262 (void *)pP2pNoaAttr , 0) ;
13263 break;
13264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13265#ifdef FEATURE_WLAN_SCAN_PNO
13266 case WDI_PREF_NETWORK_FOUND_IND:
13267 {
13268 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13269 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
13270 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13271 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
13272 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
13273
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13274 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13275 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13276 if (NULL == pPrefNetworkFoundInd)
13277 {
13278 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13279 "Memory allocation failure, "
13280 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]13281 if (NULL !=
13282 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13283 {
13284 wpalMemoryFree(
13285 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
13286 );
13287 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13288 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13289 break;
13290 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13291 /* Message Header */
13292 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13293 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13294
13295 /* Info from WDI Indication */
13296 pPrefNetworkFoundInd->ssId.length =
13297 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13298 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13299 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
13300 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
13301 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13302 if (NULL !=
13303 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13304 {
13305 pPrefNetworkFoundInd->frameLength =
13306 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13307 vos_mem_copy( pPrefNetworkFoundInd->data,
13308 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
13309 pPrefNetworkFoundInd->frameLength);
13310 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
13311 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13312 }
13313 else
13314 {
13315 pPrefNetworkFoundInd->frameLength = 0;
13316 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13317 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13318 /* VOS message wrapper */
13319 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
13320 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
13321 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13322 /* Send message to SME */
13323 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13324 {
13325 /* free the mem and return */
13326 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
13327 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13328 break;
13329 }
13330#endif // FEATURE_WLAN_SCAN_PNO
13331
13332#ifdef WLAN_WAKEUP_EVENTS
13333 case WDI_WAKE_REASON_IND:
13334 {
13335 vos_msg_t vosMsg;
13336 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
13337 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
13338 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
13339
13340 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13341 "[WAKE_REASON WDI] WAKE_REASON_IND Type (0x%x) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
13342 wdiLowLevelInd->wdiIndicationType,
13343 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
13344 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
13345 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13346
13347 if (NULL == pWakeReasonInd)
13348 {
13349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13350 "Memory allocation failure, "
13351 "WDI_WAKE_REASON_IND not forwarded");
13352 break;
13353 }
13354
13355 vos_mem_zero(pWakeReasonInd, allocSize);
13356
13357 /* Message Header */
13358 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
13359 pWakeReasonInd->mesgLen = allocSize;
13360
13361 /* Info from WDI Indication */
13362 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
13363 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
13364 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
13365 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
13366 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
13367 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
13368 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
13369 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13370
13371 /* VOS message wrapper */
13372 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
13373 vosMsg.bodyptr = (void *) pWakeReasonInd;
13374 vosMsg.bodyval = 0;
13375
13376 /* Send message to SME */
13377 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13378 {
13379 /* free the mem and return */
13380 vos_mem_free((v_VOID_t *) pWakeReasonInd);
13381 }
13382
13383 break;
13384 }
13385#endif // WLAN_WAKEUP_EVENTS
13386
13387 case WDI_TX_PER_HIT_IND:
13388 {
13389 vos_msg_t vosMsg;
13390 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
13391 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
13392 /* VOS message wrapper */
13393 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
13394 vosMsg.bodyptr = NULL;
13395 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13396 /* Send message to SME */
13397 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13398 {
13399 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
13400 }
13401 break;
13402 }
13403
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13404#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13405 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13406 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13407 vos_msg_t vosMsg;
13408 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13409
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13410 lphbInd =
13411 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
13412 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13413 {
13414 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13415 "%s: LPHB IND buffer alloc Fail", __func__);
13416 return ;
13417 }
13418
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13419 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13420 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13421 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13422 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13423 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13424 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
13425
13426 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13427 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13428 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
13429
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13430 vosMsg.type = eWNI_SME_LPHB_IND;
13431 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13432 vosMsg.bodyval = 0;
13433 /* Send message to SME */
13434 if (VOS_STATUS_SUCCESS !=
13435 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13436 {
13437 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13438 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13439 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13440 }
13441 break;
13442 }
13443#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13444 case WDI_PERIODIC_TX_PTRN_FW_IND:
13445 {
13446 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13447 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
13448 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
13449 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
13450 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
13451 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
13452 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
13453
13454 break;
13455 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13456
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]13457 case WDI_IBSS_PEER_INACTIVITY_IND:
13458 {
13459 tSirIbssPeerInactivityInd *pIbssInd =
13460 (tSirIbssPeerInactivityInd *)
13461 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
13462
13463 if (NULL == pIbssInd)
13464 {
13465 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13466 "Memory allocation failure, "
13467 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
13468 break;
13469 }
13470
13471 pIbssInd->bssIdx =
13472 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
13473 pIbssInd->staIdx =
13474 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
13475 vos_mem_copy(pIbssInd->peerAddr,
13476 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
13477 sizeof(tSirMacAddr));
13478 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
13479 break;
13480 }
13481
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13482#ifdef FEATURE_WLAN_BATCH_SCAN
13483 case WDI_BATCH_SCAN_RESULT_IND:
13484 {
13485 void *pBatchScanResult;
13486 void *pCallbackContext;
13487 tpAniSirGlobal pMac;
13488
13489 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13490 "Received WDI_BATCHSCAN_RESULT_IND from FW");
13491
13492 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13493 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13494 {
13495 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13496 "%s:pWDA is NULL", __func__);
13497 VOS_ASSERT(0);
13498 return;
13499 }
13500
13501 pBatchScanResult =
13502 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
13503 if (NULL == pBatchScanResult)
13504 {
13505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13506 "%s:Batch scan result from FW is null can't invoke HDD callback",
13507 __func__);
13508 VOS_ASSERT(0);
13509 return;
13510 }
13511
13512 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13513 if (NULL == pMac)
13514 {
13515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13516 "%s:pMac is NULL", __func__);
13517 VOS_ASSERT(0);
13518 return;
13519 }
13520
13521 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
13522 /*call hdd callback with set batch scan response data*/
13523 if(pMac->pmc.batchScanResultCallback)
13524 {
13525 pMac->pmc.batchScanResultCallback(pCallbackContext,
13526 pBatchScanResult);
13527 }
13528 else
13529 {
13530 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13531 "%s:HDD callback is null", __func__);
13532 VOS_ASSERT(0);
13533 }
13534 break;
13535 }
13536#endif
13537
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]13538#ifdef FEATURE_WLAN_CH_AVOID
13539 case WDI_CH_AVOID_IND:
13540 {
13541 vos_msg_t vosMsg;
13542 tSirChAvoidIndType *chAvoidInd;
13543
13544 chAvoidInd =
13545 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
13546 if (NULL == chAvoidInd)
13547 {
13548 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13549 "%s: CH_AVOID IND buffer alloc Fail", __func__);
13550 return ;
13551 }
13552
13553 chAvoidInd->avoidRangeCount =
13554 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
13555 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
13556 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
13557 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
13558
13559 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13560 "%s : WDA CH avoid notification", __func__);
13561
13562 vosMsg.type = eWNI_SME_CH_AVOID_IND;
13563 vosMsg.bodyptr = chAvoidInd;
13564 vosMsg.bodyval = 0;
13565 /* Send message to SME */
13566 if (VOS_STATUS_SUCCESS !=
13567 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13568 {
13569 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13570 "post eWNI_SME_CH_AVOID_IND to SME Failed");
13571 vos_mem_free(chAvoidInd);
13572 }
13573 break;
13574 }
13575#endif /* FEATURE_WLAN_CH_AVOID */
13576
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13577#ifdef WLAN_FEATURE_LINK_LAYER_STATS
13578 case WDI_LL_STATS_RESULTS_IND:
13579 {
13580 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13581 tpAniSirGlobal pMac;
13582
13583 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13584 "Received WDI_LL_STATS_RESULTS_IND from FW");
13585
13586 /*sanity check*/
13587 if (NULL == pWDA)
13588 {
13589 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13590 "%s:pWDA is NULL", __func__);
13591 VOS_ASSERT(0);
13592 return;
13593 }
13594
13595 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13596 (void *)wdiLowLevelInd->
13597 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13598 if (NULL == pLinkLayerStatsInd)
13599 {
13600 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13601 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
13602 __func__);
13603 VOS_ASSERT(0);
13604 return;
13605 }
13606
13607 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13608 if (NULL == pMac)
13609 {
13610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13611 "%s:pMac is NULL", __func__);
13612 VOS_ASSERT(0);
13613 return;
13614 }
13615
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13616 /* call hdd callback with Link Layer Statistics.
13617 * vdev_id/ifacId in link_stats_results will be
13618 * used to retrieve the correct HDD context
13619 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13620 if (pMac->sme.pLinkLayerStatsIndCallback)
13621 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13622 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13623 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13624 pLinkLayerStatsInd,
13625 wdiLowLevelInd->
13626 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13627 }
13628 else
13629 {
13630 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13631 "%s:HDD callback is null", __func__);
13632 }
13633 break;
13634 }
13635#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
13636
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]13637#ifdef WLAN_FEATURE_EXTSCAN
13638 case WDI_EXTSCAN_PROGRESS_IND:
13639 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
13640 case WDI_EXTSCAN_SCAN_RESULT_IND:
13641 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
13642 case WDI_EXTSCAN_SIGN_RSSI_RESULT_IND:
13643 {
13644 void *pEXTScanData;
13645 void *pCallbackContext;
13646 tpAniSirGlobal pMac;
13647 tANI_U16 indType;
13648
13649 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13650 "Received WDI_EXTSCAN Indications from FW");
13651 /*sanity check*/
13652 if (NULL == pWDA)
13653 {
13654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13655 "%s:pWDA is NULL", __func__);
13656 VOS_ASSERT(0);
13657 return;
13658 }
13659 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
13660 {
13661 indType = WDA_EXTSCAN_PROGRESS_IND;
13662
13663 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13664 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
13665 }
13666 if (wdiLowLevelInd->wdiIndicationType ==
13667 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
13668 {
13669 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
13670
13671 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13672 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
13673 }
13674 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
13675 {
13676 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
13677
13678 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13679 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
13680 }
13681 if (wdiLowLevelInd->wdiIndicationType ==
13682 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
13683 {
13684 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
13685
13686 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13687 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
13688 }
13689 if (wdiLowLevelInd->wdiIndicationType ==
13690 WDI_EXTSCAN_SIGN_RSSI_RESULT_IND)
13691 {
13692 indType = WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND;
13693
13694 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13695 "WDI_EXTSCAN Indication is WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND");
13696 }
13697
13698 pEXTScanData =
13699 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
13700 if (NULL == pEXTScanData)
13701 {
13702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13703 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
13704 __func__);
13705 VOS_ASSERT(0);
13706 return;
13707 }
13708
13709 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13710 if (NULL == pMac)
13711 {
13712 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13713 "%s:pMac is NULL", __func__);
13714 VOS_ASSERT(0);
13715 return;
13716 }
13717
13718 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
13719
13720 if(pMac->sme.pEXTScanIndCb)
13721 {
13722 pMac->sme.pEXTScanIndCb(pCallbackContext,
13723 indType,
13724 pEXTScanData);
13725 }
13726 else
13727 {
13728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13729 "%s:HDD callback is null", __func__);
13730 }
13731 break;
13732 }
13733#endif /* WLAN_FEATURE_EXTSCAN */
13734
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13735 default:
13736 {
13737 /* TODO error */
13738 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13739 "Received UNKNOWN Indication from WDI ");
13740 }
13741 }
13742 return ;
13743}
13744
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13745/*
13746 * BA related processing in WDA.
13747 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13748void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
13749 void* pUserData)
13750{
13751 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13752 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13753 if(NULL == pWdaParams)
13754 {
13755 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13756 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13757 VOS_ASSERT(0) ;
13758 return ;
13759 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13760 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13761 vos_mem_free(pWdaParams->wdaMsgParam) ;
13762 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13763 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13764 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13765 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13766 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
13767 {
13768 tANI_U8 i = 0 ;
13769 tBaActivityInd *baActivityInd = NULL ;
13770 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
13771 tANI_U8 allocSize = sizeof(tBaActivityInd)
13772 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
13773 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
13774 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13775 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13776 if(NULL == baActivityInd)
13777 {
13778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13779 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13780 VOS_ASSERT(0) ;
13781 return;
13782 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13783 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
13784 sizeof(tSirMacAddr)) ;
13785 baActivityInd->baCandidateCnt = baCandidateCount ;
13786
13787 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
13788 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
13789
13790 for(i = 0 ; i < baCandidateCount ; i++)
13791 {
13792 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13793 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
13794 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13795 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
13796 {
13797 baCandidate->baInfo[tid].fBaEnable =
13798 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
13799 baCandidate->baInfo[tid].startingSeqNum =
13800 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
13801 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]13802 wdiBaCandidate++ ;
13803 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13804 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13805 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
13806 }
13807 else
13808 {
13809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13810 "BA Trigger RSP with Failure received ");
13811 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13812 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13813}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13814
13815
13816/*
13817 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
13818 * during MCC
13819 */
13820void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
13821{
13822 wpt_uint32 enabled;
13823 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
13824 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
13825 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
13826
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]13827 if (NULL == pMac )
13828 {
13829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13830 "%s: Invoked with invalid MAC context ", __func__ );
13831 VOS_ASSERT(0);
13832 return;
13833 }
13834
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13835 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
13836 != eSIR_SUCCESS)
13837 {
13838 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13839 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
13840 return;
13841 }
13842
13843 if(!enabled)
13844 {
13845 return;
13846 }
13847
13848 if(NULL == pWDA)
13849 {
13850 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13851 "%s:WDA context is NULL", __func__);
13852 VOS_ASSERT(0);
13853 return;
13854 }
13855
13856 if(activate)
13857 {
13858 if( VOS_STATUS_SUCCESS !=
13859 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13860 {
13861 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13862 "Traffic Stats Timer Start Failed ");
13863 return;
13864 }
13865 WDI_DS_ActivateTrafficStats();
13866 }
13867 else
13868 {
13869 WDI_DS_DeactivateTrafficStats();
13870 WDI_DS_ClearTrafficStats();
13871
13872 if( VOS_STATUS_SUCCESS !=
13873 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13874 {
13875 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13876 "Traffic Stats Timer Stop Failed ");
13877 return;
13878 }
13879 }
13880}
13881
13882/*
13883 * Traffic Stats Timer handler
13884 */
13885void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
13886{
13887 WDI_Status wdiStatus;
13888 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
13889 WDI_TrafficStatsIndType trafficStatsIndParams;
13890 wpt_uint32 length, enabled;
13891 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13892
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]13893 if (NULL == pMac )
13894 {
13895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13896 "%s: Invoked with invalid MAC context ", __func__ );
13897 VOS_ASSERT(0);
13898 return;
13899 }
13900
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13901 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
13902 != eSIR_SUCCESS)
13903 {
13904 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13905 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
13906 return;
13907 }
13908
13909 if(!enabled)
13910 {
13911 WDI_DS_DeactivateTrafficStats();
13912 return;
13913 }
13914
13915 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
13916
13917 if(pWdiTrafficStats != NULL)
13918 {
13919 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
13920 trafficStatsIndParams.length = length;
13921 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]13922 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13923 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
13924 trafficStatsIndParams.pUserData = pWDA;
13925
13926 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
13927
13928 if(WDI_STATUS_PENDING == wdiStatus)
13929 {
13930 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13931 "Pending received for %s:%d ",__func__,__LINE__ );
13932 }
13933 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
13934 {
13935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13936 "Failure in %s:%d ",__func__,__LINE__ );
13937 }
13938
13939 WDI_DS_ClearTrafficStats();
13940 }
13941 else
13942 {
13943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13944 "pWdiTrafficStats is Null");
13945 }
13946
13947 if( VOS_STATUS_SUCCESS !=
13948 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13949 {
13950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13951 "Traffic Stats Timer Start Failed ");
13952 return;
13953 }
13954}
13955
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13956/*
13957 * BA Activity check timer handler
13958 */
13959void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
13960{
13961 tANI_U8 curSta = 0 ;
13962 tANI_U8 tid = 0 ;
13963 tANI_U8 size = 0 ;
13964 tANI_U8 baCandidateCount = 0 ;
13965 tANI_U8 newBaCandidate = 0 ;
13966 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
13967
13968 if(NULL == pWDA)
13969 {
13970 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13971 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13972 VOS_ASSERT(0);
13973 return ;
13974 }
13975 if(WDA_MAX_STA < pWDA->wdaMaxSta)
13976 {
13977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13978 "Inconsistent STA entries in WDA");
13979 VOS_ASSERT(0) ;
13980 }
13981 /* walk through all STA entries and find out TX packet count */
13982 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
13983 {
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]13984#ifdef WLAN_SOFTAP_VSTA_FEATURE
13985 // We can only do BA on "hard" STAs.
13986 if (!(IS_HWSTA_IDX(curSta)))
13987 {
13988 continue;
13989 }
13990#endif //WLAN_SOFTAP_VSTA_FEATURE
13991 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
13992 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]13993 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13994 tANI_U32 txPktCount = 0 ;
13995 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13996 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]13997 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
13998 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13999 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
14000 curSta, tid, &txPktCount)))
14001 {
14002#if 0
14003 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14004 "************* %d:%d, %d ",curSta, txPktCount,
14005 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
14006#endif
14007 if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14008 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14009 && (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
14010 curSta, tid)))
14011 {
14012 /* get prepare for sending message to HAL */
14013 //baCandidate[baCandidateCount].staIdx = curSta ;
14014 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
14015 newBaCandidate = WDA_ENABLE_BA ;
14016 }
14017 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
14018 }
14019 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14020 /* fill the entry for all the sta with given TID's */
14021 if(WDA_ENABLE_BA == newBaCandidate)
14022 {
14023 /* move to next BA candidate */
14024 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
14025 size += sizeof(WDI_TriggerBAReqCandidateType) ;
14026 baCandidateCount++ ;
14027 newBaCandidate = WDA_DISABLE_BA ;
14028 }
14029 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14030 /* prepare and send message to hal */
14031 if( 0 < baCandidateCount)
14032 {
14033 WDI_Status status = WDI_STATUS_SUCCESS ;
14034 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
14035 tWDA_ReqParams *pWdaParams =
14036 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14037 if(NULL == pWdaParams)
14038 {
14039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14040 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14041 VOS_ASSERT(0) ;
14042 return;
14043 }
14044 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
14045 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
14046 if(NULL == wdiTriggerBaReq)
14047 {
14048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14049 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14050 VOS_ASSERT(0) ;
14051 vos_mem_free(pWdaParams);
14052 return;
14053 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14054 do
14055 {
14056 WDI_TriggerBAReqinfoType *triggerBaInfo =
14057 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
14058 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
14059 /* TEMP_FIX: Need to see if WDI need check for assoc session for
14060 * for each request */
14061 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
14062 triggerBaInfo->ucBASessionID = 0;
14063 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
14064 } while(0) ;
14065 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
14066 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14067 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14068 pWdaParams->pWdaContext = pWDA;
14069 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
14070 pWdaParams->wdaMsgParam = NULL;
14071 status = WDI_TriggerBAReq(wdiTriggerBaReq,
14072 WDA_TriggerBaReqCallback, pWdaParams) ;
14073 if(IS_WDI_STATUS_FAILURE(status))
14074 {
14075 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14076 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
14077 vos_mem_free(pWdaParams->wdaMsgParam) ;
14078 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14079 vos_mem_free(pWdaParams) ;
14080 }
14081 }
14082 else
14083 {
14084 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14085 "There is no TID for initiating BA");
14086 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14087 if( VOS_STATUS_SUCCESS !=
14088 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14089 {
14090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14091 "BA Activity Timer Stop Failed ");
14092 return ;
14093 }
14094 if( VOS_STATUS_SUCCESS !=
14095 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14096 {
14097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14098 "BA Activity Timer Start Failed ");
14099 return;
14100 }
14101 return ;
14102}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14103/*
14104 * WDA common routine to create timer used by WDA.
14105 */
14106static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
14107{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14108 VOS_STATUS status = VOS_STATUS_SUCCESS ;
14109 tANI_U32 val = 0 ;
14110 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14111
14112 if(NULL == pMac)
14113 {
14114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14115 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14116 VOS_ASSERT(0);
14117 return VOS_STATUS_E_FAILURE;
14118 }
14119 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
14120 != eSIR_SUCCESS)
14121 {
14122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14123 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
14124 return VOS_STATUS_E_FAILURE;
14125 }
14126 val = SYS_MS_TO_TICKS(val) ;
14127
14128 /* BA activity check timer */
14129 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
14130 "BA Activity Check timer", WDA_TimerHandler,
14131 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
14132 if(status != TX_SUCCESS)
14133 {
14134 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14135 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14136 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14137 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14138 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14139 /* Tx Complete Timeout timer */
14140 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
14141 "Tx Complete Check timer", WDA_TimerHandler,
14142 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14143 if(status != TX_SUCCESS)
14144 {
14145 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14146 "Unable to create Tx Complete Timeout timer");
14147 /* Destroy timer of BA activity check timer */
14148 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14149 if(status != TX_SUCCESS)
14150 {
14151 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14152 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14153 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14154 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14155 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14156 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14157
14158 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
14159
14160 /* Traffic Stats timer */
14161 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
14162 "Traffic Stats timer", WDA_TimerHandler,
14163 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
14164 if(status != TX_SUCCESS)
14165 {
14166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14167 "Unable to create traffic stats timer");
14168 /* Destroy timer of BA activity check timer */
14169 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14170 if(status != TX_SUCCESS)
14171 {
14172 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14173 "Unable to Destroy BA activity timer");
14174 }
14175 /* Destroy timer of tx complete timer */
14176 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14177 if(status != TX_SUCCESS)
14178 {
14179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14180 "Unable to Tx complete timer");
14181 }
14182 return VOS_STATUS_E_FAILURE ;
14183 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14184 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14185}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14186/*
14187 * WDA common routine to destroy timer used by WDA.
14188 */
14189static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
14190{
14191 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14192 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14193 if(status != TX_SUCCESS)
14194 {
14195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14196 "Unable to Destroy Tx Complete Timeout timer");
14197 return eSIR_FAILURE ;
14198 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14199 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14200 if(status != TX_SUCCESS)
14201 {
14202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14203 "Unable to Destroy BA activity timer");
14204 return eSIR_FAILURE ;
14205 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14206 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
14207 if(status != TX_SUCCESS)
14208 {
14209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14210 "Unable to Destroy traffic stats timer");
14211 return eSIR_FAILURE ;
14212 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14213 return eSIR_SUCCESS ;
14214}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14215/*
14216 * WDA timer handler.
14217 */
14218void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
14219{
14220 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
14221 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14222 /*
14223 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
14224 */
14225 wdaMsg.type = timerInfo ;
14226 wdaMsg.bodyptr = NULL;
14227 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14228 /* post the message.. */
14229 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
14230 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
14231 {
14232 vosStatus = VOS_STATUS_E_BADMSG;
14233 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14234}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14235/*
14236 * WDA Tx Complete timeout Indication.
14237 */
14238void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
14239{
14240 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14241 if( pWDA->pAckTxCbFunc )
14242 {
14243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14244 "TxComplete timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14245 pWDA->pAckTxCbFunc( pMac, 0);
14246 pWDA->pAckTxCbFunc = NULL;
14247 }
14248 else
14249 {
14250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14251 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14252 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14253}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14254/*
14255 * WDA Set REG Domain to VOS NV
14256 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14257eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
14258 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14259{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14260 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14261 {
14262 return eHAL_STATUS_INVALID_PARAMETER;
14263 }
14264 return eHAL_STATUS_SUCCESS;
14265}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14266
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14267#ifdef FEATURE_WLAN_SCAN_PNO
14268/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14269 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14270 *
14271 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14272void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14273{
14274 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14275 tSirPNOScanReq *pPNOScanReqParams;
14276
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14277 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14278 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14279 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14280 {
14281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14282 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14283 VOS_ASSERT(0) ;
14284 return ;
14285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14286
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14287 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14288 if(pPNOScanReqParams->statusCallback)
14289 {
14290 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14291 (status == WDI_STATUS_SUCCESS) ?
14292 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
14293 }
14294
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14295 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14296 vos_mem_free(pWdaParams->wdaMsgParam);
14297 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14298
14299 return ;
14300}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14301/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14302 * FUNCTION: WDA_PNOScanReqCallback
14303 * Free memory.
14304 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
14305 */
14306void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14307{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14308 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14309 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14310
14311 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14312 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14313
14314 if(NULL == pWdaParams)
14315 {
14316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14317 "%s: pWdaParams received NULL", __func__);
14318 VOS_ASSERT(0);
14319 return;
14320 }
14321
14322 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14323 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14324 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14325 if(pPNOScanReqParams->statusCallback)
14326 {
14327 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14328 VOS_STATUS_E_FAILURE);
14329 }
14330
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14331 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14332 vos_mem_free(pWdaParams->wdaMsgParam);
14333 vos_mem_free(pWdaParams);
14334 }
14335
14336 return;
14337}
14338/*
14339 * FUNCTION: WDA_UpdateScanParamsRespCallback
14340 *
14341 */
14342void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
14343{
14344 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14345 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14346 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14347 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14348 {
14349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14350 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14351 VOS_ASSERT(0) ;
14352 return ;
14353 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14354
14355 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14356 vos_mem_free(pWdaParams->wdaMsgParam);
14357 vos_mem_free(pWdaParams);
14358
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14359 return ;
14360}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14361/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14362 * FUNCTION: WDA_UpdateScanParamsReqCallback
14363 * Free memory.
14364 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
14365 */
14366void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14367{
14368 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14369
14370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14371 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14372
14373 if(NULL == pWdaParams)
14374 {
14375 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14376 "%s: pWdaParams received NULL", __func__);
14377 VOS_ASSERT(0);
14378 return;
14379 }
14380
14381 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14382 {
14383 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14384 vos_mem_free(pWdaParams->wdaMsgParam);
14385 vos_mem_free(pWdaParams);
14386 }
14387
14388 return;
14389}
14390/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14391 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14392 * Request to WDI to set Preferred Network List.Offload
14393 */
14394VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
14395 tSirPNOScanReq *pPNOScanReqParams)
14396{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14397 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14398 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
14399 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
14400 tWDA_ReqParams *pWdaParams ;
14401 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14403 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14404 if(NULL == pwdiPNOScanReqInfo)
14405 {
14406 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14407 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14408 VOS_ASSERT(0);
14409 return VOS_STATUS_E_NOMEM;
14410 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14411 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14412 if(NULL == pWdaParams)
14413 {
14414 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14415 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14416 VOS_ASSERT(0);
14417 vos_mem_free(pwdiPNOScanReqInfo);
14418 return VOS_STATUS_E_NOMEM;
14419 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14420 //
14421 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
14422 //
14423 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
14424 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14425 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
14426 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
14427 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14428 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
14429 {
14430 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
14431 &pPNOScanReqParams->aNetworks[i],
14432 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
14433 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14434 /*Scan timer intervals*/
14435 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
14436 &pPNOScanReqParams->scanTimers,
14437 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14438 /*Probe template for 2.4GHz band*/
14439 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
14440 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14441 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14442 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
14443 pPNOScanReqParams->p24GProbeTemplate,
14444 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14445 /*Probe template for 5GHz band*/
14446 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
14447 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14448 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14449 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
14450 pPNOScanReqParams->p5GProbeTemplate,
14451 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14452 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
14453 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14454
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14455 /* Store Params pass it to WDI */
14456 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
14457 pWdaParams->pWdaContext = pWDA;
14458 /* Store param pointer as passed in by caller */
14459 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14460 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14461 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14462 if(IS_WDI_STATUS_FAILURE(status))
14463 {
14464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14465 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14466 if(pPNOScanReqParams->statusCallback)
14467 {
14468 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14469 VOS_STATUS_E_FAILURE);
14470 }
14471
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14472 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14473 vos_mem_free(pWdaParams->wdaMsgParam);
14474 pWdaParams->wdaWdiApiMsgParam = NULL;
14475 pWdaParams->wdaMsgParam = NULL;
14476 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14477 return CONVERT_WDI2VOS_STATUS(status) ;
14478}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14479
14480#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14481
14482void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
14483{
14484 /*Convert the CSR Auth types to WDI Auth types */
14485 switch (csrAuthType)
14486 {
14487 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
14488 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14489 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14490#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14491 case eCSR_AUTH_TYPE_CCKM_WPA:
14492 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
14493 break;
14494#endif
14495 case eCSR_AUTH_TYPE_WPA:
14496 *AuthType = eWDA_AUTH_TYPE_WPA;
14497 break;
14498 case eCSR_AUTH_TYPE_WPA_PSK:
14499 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
14500 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14501#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14502 case eCSR_AUTH_TYPE_CCKM_RSN:
14503 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
14504 break;
14505#endif
14506 case eCSR_AUTH_TYPE_RSN:
14507 *AuthType = eWDA_AUTH_TYPE_RSN;
14508 break;
14509 case eCSR_AUTH_TYPE_RSN_PSK:
14510 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
14511 break;
14512#if defined WLAN_FEATURE_VOWIFI_11R
14513 case eCSR_AUTH_TYPE_FT_RSN:
14514 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
14515 break;
14516 case eCSR_AUTH_TYPE_FT_RSN_PSK:
14517 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
14518 break;
14519#endif
14520#ifdef FEATURE_WLAN_WAPI
14521 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
14522 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
14523 break;
14524 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
14525 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
14526 break;
14527#endif /* FEATURE_WLAN_WAPI */
14528 case eCSR_AUTH_TYPE_SHARED_KEY:
14529 case eCSR_AUTH_TYPE_AUTOSWITCH:
14530 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14531 break;
14532#if 0
14533 case eCSR_AUTH_TYPE_SHARED_KEY:
14534 *AuthType = eWDA_AUTH_TYPE_SHARED_KEY;
14535 break;
14536 case eCSR_AUTH_TYPE_AUTOSWITCH:
14537 *AuthType = eWDA_AUTH_TYPE_AUTOSWITCH;
14538#endif
14539 default:
14540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14541 "%s: Unknown Auth Type", __func__);
14542 break;
14543 }
14544}
14545void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
14546{
14547 switch (csrEncrType)
14548 {
14549 case eCSR_ENCRYPT_TYPE_NONE:
14550 *EncrType = WDI_ED_NONE;
14551 break;
14552 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
14553 case eCSR_ENCRYPT_TYPE_WEP40:
14554 *EncrType = WDI_ED_WEP40;
14555 break;
14556 case eCSR_ENCRYPT_TYPE_WEP104:
14557 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
14558 *EncrType = WDI_ED_WEP104;
14559 break;
14560 case eCSR_ENCRYPT_TYPE_TKIP:
14561 *EncrType = WDI_ED_TKIP;
14562 break;
14563 case eCSR_ENCRYPT_TYPE_AES:
14564 *EncrType = WDI_ED_CCMP;
14565 break;
14566#ifdef WLAN_FEATURE_11W
14567 case eCSR_ENCRYPT_TYPE_AES_CMAC:
14568 *EncrType = WDI_ED_AES_128_CMAC;
14569 break;
14570#endif
14571#ifdef FEATURE_WLAN_WAPI
14572 case eCSR_ENCRYPT_TYPE_WPI:
14573 *EncrType = WDI_ED_WPI;
14574 break;
14575#endif
14576 case eCSR_ENCRYPT_TYPE_ANY:
14577 *EncrType = WDI_ED_ANY;
14578 break;
14579
14580 default:
14581 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14582 "%s: Unknown Encryption Type", __func__);
14583 break;
14584 }
14585}
14586
14587/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14588 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14589 * Request to WDI to set Roam Offload Scan
14590 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14591VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14592 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
14593{
14594 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14595 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
14596 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14597 tWDA_ReqParams *pWdaParams ;
14598 v_U8_t csrAuthType;
14599 WDI_RoamNetworkType *pwdiRoamNetworkType;
14600 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
14601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14602 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14603 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14604 {
14605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14606 "%s: VOS MEM Alloc Failure", __func__);
14607 VOS_ASSERT(0);
14608 return VOS_STATUS_E_NOMEM;
14609 }
14610 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14611 if (NULL == pWdaParams)
14612 {
14613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14614 "%s: VOS MEM Alloc Failure", __func__);
14615 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14616 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14617 return VOS_STATUS_E_NOMEM;
14618 }
14619
14620 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14621 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14622 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14623 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
14624 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14625 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
14626 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
14627 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
14628 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
14629 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
14630 sizeof(pwdiRoamNetworkType->currAPbssid));
14631 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
14632 csrAuthType);
14633 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
14634 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
14635 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
14636 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
14637 pwdiRoamOffloadScanInfo->LookupThreshold =
14638 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]14639 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
14640 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14641 pwdiRoamOffloadScanInfo->RoamRssiDiff =
14642 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]14643 pwdiRoamOffloadScanInfo->MAWCEnabled =
14644 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14645 pwdiRoamOffloadScanInfo->Command =
14646 pRoamOffloadScanReqParams->Command ;
14647 pwdiRoamOffloadScanInfo->StartScanReason =
14648 pRoamOffloadScanReqParams->StartScanReason ;
14649 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
14650 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
14651 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
14652 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
14653 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
14654 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
14655 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
14656 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
14657 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
14658 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14659 pwdiRoamOffloadScanInfo->IsESEEnabled =
14660 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14661 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
14662 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
14663 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
14664 pwdiRoamNetworkType->ssId.ucLength =
14665 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
14666 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
14667 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
14668 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
14669 pwdiRoamNetworkType->ChannelCount =
14670 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
14671 pwdiRoamOffloadScanInfo->ChannelCacheType =
14672 pRoamOffloadScanReqParams->ChannelCacheType;
14673 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
14674 pRoamOffloadScanReqParams->ValidChannelList,
14675 pRoamOffloadScanReqParams->ValidChannelCount);
14676 pwdiRoamOffloadScanInfo->ValidChannelCount =
14677 pRoamOffloadScanReqParams->ValidChannelCount;
14678 pwdiRoamOffloadScanInfo->us24GProbeSize =
14679 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14680 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14681 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
14682 pRoamOffloadScanReqParams->p24GProbeTemplate,
14683 pwdiRoamOffloadScanInfo->us24GProbeSize);
14684 pwdiRoamOffloadScanInfo->us5GProbeSize =
14685 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14686 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14687 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
14688 pRoamOffloadScanReqParams->p5GProbeTemplate,
14689 pwdiRoamOffloadScanInfo->us5GProbeSize);
14690 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
14691 pRoamOffloadScanReqParams->MDID.mdiePresent;
14692 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
14693 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14694 pwdiRoamOffloadScanInfo->nProbes =
14695 pRoamOffloadScanReqParams->nProbes;
14696 pwdiRoamOffloadScanInfo->HomeAwayTime =
14697 pRoamOffloadScanReqParams->HomeAwayTime;
14698 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14699 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14700 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14701 pWdaParams->pWdaContext = pWDA;
14702 /* Store param pointer as passed in by caller */
14703 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14704 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14705 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
14706 if(IS_WDI_STATUS_FAILURE(status))
14707 {
14708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14709 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
14710 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14711 vos_mem_free(pWdaParams->wdaMsgParam);
14712 pWdaParams->wdaWdiApiMsgParam = NULL;
14713 pWdaParams->wdaMsgParam = NULL;
14714 }
14715 return CONVERT_WDI2VOS_STATUS(status) ;
14716}
14717#endif
14718
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14719/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14720 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14721 *
14722 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14723void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14724{
14725 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14726
14727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14728 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14729
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14730 if(NULL == pWdaParams)
14731 {
14732 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14733 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14734 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14735 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14736 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14737
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14738 vos_mem_free(pWdaParams->wdaMsgParam) ;
14739 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14740 vos_mem_free(pWdaParams) ;
14741
14742 return ;
14743}
14744/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14745 * FUNCTION: WDA_RssiFilterReqCallback
14746 * Free memory.
14747 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
14748 */
14749void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
14750{
14751 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14752
14753 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14754 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14755
14756 if(NULL == pWdaParams)
14757 {
14758 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14759 "%s: pWdaParams received NULL", __func__);
14760 VOS_ASSERT(0);
14761 return;
14762 }
14763
14764 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14765 {
14766 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14767 vos_mem_free(pWdaParams->wdaMsgParam);
14768 vos_mem_free(pWdaParams);
14769 }
14770
14771 return;
14772}
14773/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14774 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14775 * Request to WDI to set Preferred Network List.Offload
14776 */
14777VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
14778 tSirSetRSSIFilterReq* pRssiFilterParams)
14779{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14780 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14781 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
14782 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
14783 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14784 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14785 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14786 if(NULL == pwdiSetRssiFilterReqInfo)
14787 {
14788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14789 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14790 VOS_ASSERT(0);
14791 return VOS_STATUS_E_NOMEM;
14792 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14793 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14794 if(NULL == pWdaParams)
14795 {
14796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14797 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14798 VOS_ASSERT(0);
14799 vos_mem_free(pwdiSetRssiFilterReqInfo);
14800 return VOS_STATUS_E_NOMEM;
14801 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14802 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14803 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
14804 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14805
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14806 /* Store Params pass it to WDI */
14807 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
14808 pWdaParams->pWdaContext = pWDA;
14809 /* Store param pointer as passed in by caller */
14810 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14811 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14812 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14813 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14814 if(IS_WDI_STATUS_FAILURE(status))
14815 {
14816 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14817 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
14818 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14819 vos_mem_free(pWdaParams->wdaMsgParam);
14820 pWdaParams->wdaWdiApiMsgParam = NULL;
14821 pWdaParams->wdaMsgParam = NULL;
14822 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14823 return CONVERT_WDI2VOS_STATUS(status) ;
14824}
14825
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14826/*
14827 * FUNCTION: WDA_ProcessUpdateScanParams
14828 * Request to WDI to update Scan Parameters
14829 */
14830VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
14831 tSirUpdateScanParams *pUpdateScanParams)
14832{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14833 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14834 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
14835 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
14836 sizeof(WDI_UpdateScanParamsInfoType)) ;
14837 tWDA_ReqParams *pWdaParams ;
14838 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14840 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14841 if(NULL == wdiUpdateScanParamsInfoType)
14842 {
14843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14844 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14845 VOS_ASSERT(0);
14846 return VOS_STATUS_E_NOMEM;
14847 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14848 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14849 if ( NULL == pWdaParams )
14850 {
14851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14852 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14853 VOS_ASSERT(0);
14854 vos_mem_free(wdiUpdateScanParamsInfoType);
14855 return VOS_STATUS_E_NOMEM;
14856 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14857 //
14858 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
14859 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14861 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
14862 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
14863 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]14864 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14865 pUpdateScanParams->b11dEnabled,
14866 pUpdateScanParams->b11dResolved,
14867 pUpdateScanParams->ucChannelCount,
14868 pUpdateScanParams->usPassiveMinChTime,
14869 pUpdateScanParams->usPassiveMaxChTime,
14870 pUpdateScanParams->usActiveMinChTime,
14871 pUpdateScanParams->usActiveMaxChTime,
14872 sizeof(tSirUpdateScanParams),
14873 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
14874
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14875 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
14876 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14877 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
14878 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14879 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
14880 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14881 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
14882 pUpdateScanParams->usActiveMaxChTime;
14883 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
14884 pUpdateScanParams->usActiveMinChTime;
14885 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
14886 pUpdateScanParams->usPassiveMaxChTime;
14887 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
14888 pUpdateScanParams->usPassiveMinChTime;
14889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14890 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]14891 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
14892 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14893
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14894 for ( i = 0; i <
14895 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
14896 i++)
14897 {
14898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14899 "Update Scan Parameters channel: %d",
14900 pUpdateScanParams->aChannels[i]);
14901
14902 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
14903 pUpdateScanParams->aChannels[i];
14904 }
14905
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14906 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
14907 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14908
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14909 /* Store Params pass it to WDI */
14910 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
14911 pWdaParams->pWdaContext = pWDA;
14912 /* Store param pointer as passed in by caller */
14913 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]14914
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14915
14916
14917 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14918 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14919 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14920 if(IS_WDI_STATUS_FAILURE(status))
14921 {
14922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14923 "Failure in Update Scan Params EQ WDI API, free all the memory " );
14924 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14925 vos_mem_free(pWdaParams->wdaMsgParam);
14926 vos_mem_free(pWdaParams);
14927 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14928 return CONVERT_WDI2VOS_STATUS(status) ;
14929}
14930#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14931
14932#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14933/*
14934 * FUNCTION: WDA_RoamOffloadScanReqCallback
14935 *
14936 */
14937void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
14938{
14939 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14940 vos_msg_t vosMsg;
14941 wpt_uint8 reason = 0;
14942
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]14943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14944 "<------ %s " ,__func__);
14945 if (NULL == pWdaParams)
14946 {
14947 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14948 "%s: pWdaParams received NULL", __func__);
14949 VOS_ASSERT(0) ;
14950 return ;
14951 }
14952 if ( pWdaParams != NULL )
14953 {
14954 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
14955 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14956 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14957 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14958 }
14959 if ( pWdaParams->wdaMsgParam != NULL)
14960 {
14961 vos_mem_free(pWdaParams->wdaMsgParam);
14962 }
14963
14964 vos_mem_free(pWdaParams) ;
14965 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14966 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
14967 vosMsg.bodyptr = NULL;
14968 if (WDI_STATUS_SUCCESS != status)
14969 {
14970 reason = 0;
14971 }
14972 vosMsg.bodyval = reason;
14973 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
14974 {
14975 /* free the mem and return */
14976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]14977 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14978 }
14979
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14980 return ;
14981}
14982#endif
14983
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14984/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14985 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14986 *
14987 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14988void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14989{
14990 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14991
14992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14993 "<------ %s " ,__func__);
14994
14995 if(NULL == pWdaParams)
14996 {
14997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14998 "%s: pWdaParams received NULL", __func__);
14999 VOS_ASSERT(0);
15000 return;
15001 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15002
15003 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15004 vos_mem_free(pWdaParams->wdaMsgParam);
15005 vos_mem_free(pWdaParams);
15006
15007 return;
15008}
15009/*
15010 * FUNCTION: WDA_SetPowerParamsReqCallback
15011 * Free memory.
15012 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
15013 */
15014void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
15015{
15016 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15017
15018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15019 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15020
15021 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15022 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15024 "%s: pWdaParams received NULL", __func__);
15025 VOS_ASSERT(0);
15026 return;
15027 }
15028
15029 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15030 {
15031 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15032 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15033 vos_mem_free(pWdaParams);
15034 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15035
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15036 return;
15037}
15038
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15039#ifdef WLAN_FEATURE_PACKET_FILTERING
15040/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15041 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15042 *
15043 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15044void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15045 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
15046 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15047{
15048 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15050 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15051 if(NULL == pWdaParams)
15052 {
15053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15054 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15055 VOS_ASSERT(0) ;
15056 return ;
15057 }
15058
15059 vos_mem_free(pWdaParams->wdaMsgParam) ;
15060 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15061 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15062 //print a msg, nothing else to do
15063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15064 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15065 return ;
15066}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15067/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15068 * FUNCTION: WDA_8023MulticastListReqCallback
15069 * Free memory.
15070 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
15071 */
15072void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
15073{
15074 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15075
15076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15077 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15078
15079 if(NULL == pWdaParams)
15080 {
15081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15082 "%s: pWdaParams received NULL", __func__);
15083 VOS_ASSERT(0);
15084 return;
15085 }
15086
15087 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15088 {
15089 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15090 vos_mem_free(pWdaParams->wdaMsgParam);
15091 vos_mem_free(pWdaParams);
15092 }
15093
15094 return;
15095}
15096/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15097 * FUNCTION: WDA_Process8023MulticastListReq
15098 * Request to WDI to add 8023 Multicast List
15099 */
15100VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
15101 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
15102{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15103 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15104 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
15105 tWDA_ReqParams *pWdaParams ;
15106 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15108 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15109 pwdiFltPktSetMcListReqParamsType =
15110 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
15111 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
15112 ) ;
15113 if(NULL == pwdiFltPktSetMcListReqParamsType)
15114 {
15115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15116 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15117 return VOS_STATUS_E_NOMEM;
15118 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15119 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15120 if(NULL == pWdaParams)
15121 {
15122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15123 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15124 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
15125 return VOS_STATUS_E_NOMEM;
15126 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15127
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15128 //
15129 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
15130 //
15131 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15132 pRcvFltMcAddrList->ulMulticastAddrCnt;
15133
15134 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
15135 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
15136 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
15137 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
15138
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15139 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
15140 {
15141 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
15142 &(pRcvFltMcAddrList->multicastAddr[i]),
15143 sizeof(tSirMacAddr));
15144 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15145 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
15146 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15147
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15148 /* Store Params pass it to WDI */
15149 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
15150 pWdaParams->pWdaContext = pWDA;
15151 /* Store param pointer as passed in by caller */
15152 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15153 status = WDI_8023MulticastListReq(
15154 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15155 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15156 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15157 if(IS_WDI_STATUS_FAILURE(status))
15158 {
15159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15160 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
15161 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15162 vos_mem_free(pWdaParams->wdaMsgParam);
15163 vos_mem_free(pWdaParams);
15164 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15165 return CONVERT_WDI2VOS_STATUS(status) ;
15166}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15167/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15168 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15169 *
15170 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15171void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15172 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
15173 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15174{
15175 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15177 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15178 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15179 if(NULL == pWdaParams)
15180 {
15181 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15182 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15183 VOS_ASSERT(0) ;
15184 return ;
15185 }
15186
15187 vos_mem_free(pWdaParams->wdaMsgParam) ;
15188 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15189 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15190 //print a msg, nothing else to do
15191 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15192 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15193 return ;
15194}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15195
15196/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15197 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
15198 * Free memory.
15199 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15200 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15201void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15202 void* pUserData)
15203{
15204 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15205
15206 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15207 "<------ %s, wdiStatus: %d",
15208 __func__, wdiStatus);
15209
15210 if (NULL == pWdaParams)
15211 {
15212 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15213 "%s: Invalid pWdaParams pointer", __func__);
15214 VOS_ASSERT(0);
15215 return;
15216 }
15217
15218 if (IS_WDI_STATUS_FAILURE(wdiStatus))
15219 {
15220 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15221 vos_mem_free(pWdaParams->wdaMsgParam);
15222 vos_mem_free(pWdaParams);
15223 }
15224
15225 return;
15226}
15227
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15228/*
15229 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
15230 * Request to WDI to set Receive Filters
15231 */
15232VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
15233 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
15234{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15235 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15236 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
15237 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
15238 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
15239 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
15240 tWDA_ReqParams *pWdaParams ;
15241 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15242 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15243 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15244 if(NULL == pwdiSetRcvPktFilterReqParamsType)
15245 {
15246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15247 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15248 VOS_ASSERT(0);
15249 return VOS_STATUS_E_NOMEM;
15250 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15251 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15252 if(NULL == pWdaParams)
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 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
15258 return VOS_STATUS_E_NOMEM;
15259 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15260 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
15261 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
15262 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
15263 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15264 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
15265 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
15266
15267 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
15268 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15269
15270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15271 "FID %d FT %d NParams %d CT %d",
15272 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
15273 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
15274 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
15275 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15276 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
15277 {
15278 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
15279 &pRcvPktFilterCfg->paramsData[i],
15280 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15282 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15283 pwdiSetRcvPktFilterReqParamsType->
15284 wdiPktFilterCfg.paramsData[i].protocolLayer,
15285 pwdiSetRcvPktFilterReqParamsType->
15286 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15288 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15289 pwdiSetRcvPktFilterReqParamsType->
15290 wdiPktFilterCfg.paramsData[i].dataOffset,
15291 pwdiSetRcvPktFilterReqParamsType->
15292 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15294 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15295 pwdiSetRcvPktFilterReqParamsType->
15296 wdiPktFilterCfg.paramsData[i].compareData[0],
15297 pwdiSetRcvPktFilterReqParamsType->
15298 wdiPktFilterCfg.paramsData[i].compareData[1],
15299 pwdiSetRcvPktFilterReqParamsType->
15300 wdiPktFilterCfg.paramsData[i].compareData[2],
15301 pwdiSetRcvPktFilterReqParamsType->
15302 wdiPktFilterCfg.paramsData[i].compareData[3],
15303 pwdiSetRcvPktFilterReqParamsType->
15304 wdiPktFilterCfg.paramsData[i].compareData[4],
15305 pwdiSetRcvPktFilterReqParamsType->
15306 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15307 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15308 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15309 pwdiSetRcvPktFilterReqParamsType->
15310 wdiPktFilterCfg.paramsData[i].dataMask[0],
15311 pwdiSetRcvPktFilterReqParamsType->
15312 wdiPktFilterCfg.paramsData[i].dataMask[1],
15313 pwdiSetRcvPktFilterReqParamsType->
15314 wdiPktFilterCfg.paramsData[i].dataMask[2],
15315 pwdiSetRcvPktFilterReqParamsType->
15316 wdiPktFilterCfg.paramsData[i].dataMask[3],
15317 pwdiSetRcvPktFilterReqParamsType->
15318 wdiPktFilterCfg.paramsData[i].dataMask[4],
15319 pwdiSetRcvPktFilterReqParamsType->
15320 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15321 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15322 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15323 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15324 /* Store Params pass it to WDI */
15325 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
15326 pWdaParams->pWdaContext = pWDA;
15327 /* Store param pointer as passed in by caller */
15328 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15329 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15330 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15331 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15332 if(IS_WDI_STATUS_FAILURE(status))
15333 {
15334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15335 "Failure in SetFilter(),free all the memory,status %d ",status);
15336 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15337 vos_mem_free(pWdaParams->wdaMsgParam);
15338 vos_mem_free(pWdaParams);
15339 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15340 return CONVERT_WDI2VOS_STATUS(status) ;
15341}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15342/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15343 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15344 *
15345 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15346void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15347 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
15348 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15349{
15350 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15351 tWDA_CbContext *pWDA;
15352 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
15353 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
15354 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
15355 tANI_U8 i;
15356 vos_msg_t vosMsg;
15357
15358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15359 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15360 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
15361
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15362 if(NULL == pRcvFltPktMatchCntRsp)
15363 {
15364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15365 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15366 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15367 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15368 return ;
15369 }
15370
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15371 if(NULL == pWdaParams)
15372 {
15373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15374 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15375 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15376 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15377 return ;
15378 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15379 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
15380 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15381 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
15382 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
15383
15384 /* Message Header */
15385 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15386 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
15387
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15388 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15389
15390 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
15391 {
15392 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
15393 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
15394 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15395 /* VOS message wrapper */
15396 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15397 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
15398 vosMsg.bodyval = 0;
15399 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15400 {
15401 /* free the mem and return */
15402 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
15403 }
15404
15405 vos_mem_free(pWdaParams->wdaMsgParam) ;
15406 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15407 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15408
15409 return;
15410}
15411/*
15412 * FUNCTION: WDA_FilterMatchCountReqCallback
15413 * Free memory and send RSP back to SME.
15414 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
15415 */
15416void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
15417{
15418 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15419 vos_msg_t vosMsg;
15420
15421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15422 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15423
15424 if(NULL == pWdaParams)
15425 {
15426 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15427 "%s: pWdaParams received NULL", __func__);
15428 VOS_ASSERT(0);
15429 return;
15430 }
15431
15432 /* VOS message wrapper */
15433 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15434 vosMsg.bodyptr = NULL;
15435 vosMsg.bodyval = 0;
15436
15437 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15438 {
15439 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15440 vos_mem_free(pWdaParams->wdaMsgParam);
15441 vos_mem_free(pWdaParams);
15442 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
15443 }
15444
15445 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15446}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15447/*
15448 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
15449 * Request to WDI to get PC Filter Match Count
15450 */
15451VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
15452{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15453 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15454 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
15455 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
15456 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15457 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15458 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15459 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
15460 {
15461 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15462 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15463 VOS_ASSERT(0);
15464 return VOS_STATUS_E_NOMEM;
15465 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15466 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15467 if(NULL == pWdaParams)
15468 {
15469 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15470 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15471 VOS_ASSERT(0);
15472 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
15473 return VOS_STATUS_E_NOMEM;
15474 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15475
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15476 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
15477 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15478
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15479 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
15480 pRcvFltPktMatchRsp->bssId,
15481 sizeof(wpt_macAddr));
15482
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15483 /* Store Params pass it to WDI */
15484 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
15485 pWdaParams->pWdaContext = pWDA;
15486 /* Store param pointer as passed in by caller */
15487 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15488 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15489 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15490 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15491 if(IS_WDI_STATUS_FAILURE(status))
15492 {
15493 /* failure returned by WDI API */
15494 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15495 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
15496 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15497 vos_mem_free(pWdaParams) ;
15498 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
15499 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
15500 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15501 return CONVERT_WDI2VOS_STATUS(status) ;
15502}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15503/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15504 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15505 *
15506 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15507void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15508 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
15509 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15510{
15511 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15512 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15513 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15514/* WDA_VOS_ASSERT(NULL != pWdaParams); */
15515 if(NULL == pWdaParams)
15516 {
15517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15518 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15519 VOS_ASSERT(0) ;
15520 return ;
15521 }
15522
15523 vos_mem_free(pWdaParams->wdaMsgParam) ;
15524 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15525 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15526 //print a msg, nothing else to do
15527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15528 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15529 return ;
15530}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15531/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15532 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
15533 * Free memory.
15534 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
15535 */
15536void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15537{
15538 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15539
15540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15541 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15542
15543 if(NULL == pWdaParams)
15544 {
15545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15546 "%s: Invalid pWdaParams pointer", __func__);
15547 VOS_ASSERT(0);
15548 return;
15549 }
15550
15551 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15552 {
15553 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15554 vos_mem_free(pWdaParams->wdaMsgParam);
15555 vos_mem_free(pWdaParams);
15556 }
15557
15558 return;
15559}
15560/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15561 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
15562 * Request to WDI to clear Receive Filters
15563 */
15564VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
15565 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
15566{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15567 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15568 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
15569 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
15570 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15571 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15572 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15573 if(NULL == pwdiRcvFltPktClearReqParamsType)
15574 {
15575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15576 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15577 VOS_ASSERT(0);
15578 return VOS_STATUS_E_NOMEM;
15579 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15580 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15581 if(NULL == pWdaParams)
15582 {
15583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15584 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15585 VOS_ASSERT(0);
15586 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
15587 return VOS_STATUS_E_NOMEM;
15588 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15589 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
15590 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15591 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
15592 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
15593 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
15594 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15595
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15596 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15597 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15598 /* Store Params pass it to WDI */
15599 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
15600 pWdaParams->pWdaContext = pWDA;
15601 /* Store param pointer as passed in by caller */
15602 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15603 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15604 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15605 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15606 if(IS_WDI_STATUS_FAILURE(status))
15607 {
15608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15609 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
15610 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]15611 vos_mem_free(pWdaParams->wdaMsgParam);
15612 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15613 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15614 return CONVERT_WDI2VOS_STATUS(status) ;
15615}
15616#endif // WLAN_FEATURE_PACKET_FILTERING
15617
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15618/*
15619 * FUNCTION: WDA_ProcessSetPowerParamsReq
15620 * Request to WDI to set power params
15621 */
15622VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
15623 tSirSetPowerParamsReq *pPowerParams)
15624{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15625 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15626 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
15627 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15628 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15630 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15631 if(NULL == pwdiSetPowerParamsReqInfo)
15632 {
15633 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15634 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15635 VOS_ASSERT(0);
15636 return VOS_STATUS_E_NOMEM;
15637 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15638 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15639 if(NULL == pWdaParams)
15640 {
15641 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15642 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15643 VOS_ASSERT(0);
15644 vos_mem_free(pwdiSetPowerParamsReqInfo);
15645 return VOS_STATUS_E_NOMEM;
15646 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15647
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15648
15649 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
15650 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15651 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
15652 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15653 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
15654 pPowerParams->uListenInterval;
15655 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
15656 pPowerParams->uBcastMcastFilter;
15657 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
15658 pPowerParams->uEnableBET;
15659 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
15660 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]15661 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
15662 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15663 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
15664 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15665
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15666 /* Store Params pass it to WDI */
15667 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
15668 pWdaParams->pWdaContext = pWDA;
15669 /* Store param pointer as passed in by caller */
15670 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15671 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15672 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15673 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15674 if(IS_WDI_STATUS_FAILURE(status))
15675 {
15676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15677 "Failure in Set power params REQ WDI API, free all the memory " );
15678 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15679 vos_mem_free(pWdaParams->wdaMsgParam);
15680 pWdaParams->wdaWdiApiMsgParam = NULL;
15681 pWdaParams->wdaMsgParam = NULL;
15682 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15683 return CONVERT_WDI2VOS_STATUS(status) ;
15684}
15685
15686/*
15687 * FUNCTION: WDA_SetTmLevelRspCallback
15688 * Set TM Level response
15689 */
15690void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
15691{
15692 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15693
15694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15695 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15696
15697 if(NULL == pWdaParams)
15698 {
15699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15700 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15701 VOS_ASSERT(0) ;
15702 return ;
15703 }
15704
15705 /* Dose not need to send notification to upper layer
15706 * Just free allocated resources */
15707 if( pWdaParams != NULL )
15708 {
15709 if( pWdaParams->wdaWdiApiMsgParam != NULL )
15710 {
15711 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15712 }
15713 vos_mem_free(pWdaParams->wdaMsgParam) ;
15714 vos_mem_free(pWdaParams) ;
15715 }
15716}
15717
15718/*
15719 * FUNCTION: WDA_ProcessSetTmLevelReq
15720 * Set TM Level request
15721 */
15722VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
15723 tAniSetTmLevelReq *setTmLevelReq)
15724{
15725 WDI_Status status = WDI_STATUS_SUCCESS ;
15726 tWDA_ReqParams *pWdaParams ;
15727 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
15728 (WDI_SetTmLevelReqType *)vos_mem_malloc(
15729 sizeof(WDI_SetTmLevelReqType)) ;
15730 if(NULL == wdiSetTmLevelReq)
15731 {
15732 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15733 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15734 VOS_ASSERT(0);
15735 return VOS_STATUS_E_NOMEM;
15736 }
15737
15738 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15739 if(NULL == pWdaParams)
15740 {
15741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15742 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15743 VOS_ASSERT(0);
15744 vos_mem_free(wdiSetTmLevelReq);
15745 return VOS_STATUS_E_NOMEM;
15746 }
15747
15748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15749 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15750
15751 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
15752 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
15753
15754 pWdaParams->pWdaContext = pWDA;
15755 pWdaParams->wdaMsgParam = setTmLevelReq;
15756 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
15757
15758 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
15759 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
15760
15761 if(IS_WDI_STATUS_FAILURE(status))
15762 {
15763 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]15764 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15765 vos_mem_free(pWdaParams->wdaMsgParam) ;
15766 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15767 vos_mem_free(pWdaParams) ;
15768 }
15769
15770 return CONVERT_WDI2VOS_STATUS(status) ;
15771}
15772
15773VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
15774 tpTxControlParams pTxCtrlParam)
15775{
15776 VOS_STATUS wdaStatus;
15777
15778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15779 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15780 if( pTxCtrlParam == NULL )
15781 {
15782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15783 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15784 return VOS_STATUS_E_FAILURE;
15785 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15786 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
15787 {
15788 wdaStatus = WDA_SuspendDataTx(pWDA);
15789 }
15790 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
15791 {
15792 wdaStatus = WDA_ResumeDataTx(pWDA);
15793 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15794 return wdaStatus;
15795}
15796
15797 /* FUNCTION WDA_featureCapsExchange
15798 * WDA API to invoke capability exchange between host and FW.
15799 */
15800void WDA_featureCapsExchange(v_PVOID_t pVosContext)
15801{
15802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15803 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15804 WDI_featureCapsExchangeReq( NULL, pVosContext);
15805}
15806
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]15807/* FUNCTION WDA_disableCapablityFeature
15808 * WDA API to diable Active mode offload in host.
15809 */
15810void WDA_disableCapablityFeature(tANI_U8 feature_index)
15811{
15812 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15813 "%s:enter", __func__ );
15814 WDI_disableCapablityFeature(feature_index);
15815}
15816
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15817 /* FUNCTION WDA_getHostWlanFeatCaps
15818 * Wrapper for WDI API, that will return if the feature (enum value).passed
15819 * to this API is supported or not in Host
15820 * return value
15821 * 0 - implies feature is NOT Supported
15822 * any non zero value - implies feature is SUPPORTED
15823 */
15824tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
15825{
15826 return WDI_getHostWlanFeatCaps(featEnumValue);
15827}
15828
15829 /* FUNCTION WDA_getFwWlanFeatCaps
15830 * Wrapper for WDI API, that will return if the feature (enum value).passed
15831 * to this API is supported or not in FW
15832 * return value
15833 * 0 - implies feature is NOT Supported
15834 * any non zero value - implies feature is SUPPORTED
15835 */
15836tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
15837{
15838 return WDI_getFwWlanFeatCaps(featEnumValue);
15839}
15840
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]15841
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15842/*
15843 * FUNCTION: WDA_shutdown
15844 * Shutdown WDA/WDI without handshaking with Riva.
15845 * Synchronous function.
15846 */
15847VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
15848{
15849 WDI_Status wdiStatus;
15850 //tANI_U8 eventIdx = 0;
15851 VOS_STATUS status = VOS_STATUS_SUCCESS;
15852 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15853 if (NULL == pWDA)
15854 {
15855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15856 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15857 VOS_ASSERT(0);
15858 return VOS_STATUS_E_FAILURE;
15859 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15860 /* FTM mode stay START_STATE */
15861 if( (WDA_READY_STATE != pWDA->wdaState) &&
15862 (WDA_INIT_STATE != pWDA->wdaState) &&
15863 (WDA_START_STATE != pWDA->wdaState) )
15864 {
15865 VOS_ASSERT(0);
15866 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15867
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]15868 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
15869 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15870 {
15871 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]15872 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15873 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]15874 else
15875 {
15876 vos_event_destroy(&pWDA->ftmStopDoneEvent);
15877 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15878
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15879 /* call WDI shutdown */
15880 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15881 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
15882 {
15883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15884 "error in WDA Stop" );
15885 status = VOS_STATUS_E_FAILURE;
15886 }
15887 /* WDI stop is synchrnous, shutdown is complete when it returns */
15888 pWDA->wdaState = WDA_STOP_STATE;
15889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15890 /* shutdown should perform the stop & close actions. */
15891 /* Destroy the event */
15892 status = vos_event_destroy(&pWDA->txFrameEvent);
15893 if(!VOS_IS_STATUS_SUCCESS(status))
15894 {
15895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15896 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15897 status = VOS_STATUS_E_FAILURE;
15898 }
15899 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
15900 if(!VOS_IS_STATUS_SUCCESS(status))
15901 {
15902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15903 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15904 status = VOS_STATUS_E_FAILURE;
15905 }
15906 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
15907 if(!VOS_IS_STATUS_SUCCESS(status))
15908 {
15909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15910 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15911 status = VOS_STATUS_E_FAILURE;
15912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15913 /* free WDA context */
15914 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
15915 if ( !VOS_IS_STATUS_SUCCESS(status) )
15916 {
15917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15918 "error in WDA close " );
15919 status = VOS_STATUS_E_FAILURE;
15920 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15921 return status;
15922}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15923
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15924/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15925 * FUNCTION: WDA_setNeedShutdown
15926 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15927 */
15928
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15929void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15930{
15931 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]15932 if(pWDA == NULL)
15933 {
15934 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15935 "Could not get the WDA Context pointer" );
15936 return;
15937 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15938 pWDA->needShutdown = TRUE;
15939}
15940/*
15941 * FUNCTION: WDA_needShutdown
15942 * WDA needs a shutdown
15943 */
15944
15945v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
15946{
15947 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]15948 if(pWDA == NULL)
15949 {
15950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15951 "Could not get the WDA Context pointer" );
15952 return 0;
15953 }
15954 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15955}
15956
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15957#ifdef WLAN_FEATURE_11AC
15958/*
15959 * FUNCTION: WDA_SetBeaconFilterReqCallback
15960 *
15961 */
15962void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
15963{
15964 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15966 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15967 if(NULL == pWdaParams)
15968 {
15969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15970 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15971 VOS_ASSERT(0) ;
15972 return ;
15973 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15974
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15975 vos_mem_free(pWdaParams->wdaMsgParam) ;
15976 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15977 vos_mem_free(pWdaParams) ;
15978 /*
15979 * No respone required for SetBeaconFilter req so just free the request
15980 * param here
15981 */
15982
15983 return ;
15984}
15985
15986VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
15987 tUpdateVHTOpMode *pData)
15988{
15989 WDI_Status status = WDI_STATUS_SUCCESS ;
15990 tWDA_ReqParams *pWdaParams ;
15991 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
15992 sizeof(WDI_UpdateVHTOpMode)) ;
15993 if(NULL == wdiTemp)
15994 {
15995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15996 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15997 VOS_ASSERT(0);
15998 return VOS_STATUS_E_NOMEM;
15999 }
16000 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16001 if(NULL == pWdaParams)
16002 {
16003 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16004 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16005 VOS_ASSERT(0);
16006 vos_mem_free(wdiTemp);
16007 return VOS_STATUS_E_NOMEM;
16008 }
16009
16010 wdiTemp->opMode = pData->opMode;
16011 wdiTemp->staId = pData->staId;
16012
16013 pWdaParams->pWdaContext = pWDA;
16014 /* Store Req pointer, as this will be used for response */
16015 pWdaParams->wdaMsgParam = (void *)pData;
16016 /* store Params pass it to WDI */
16017 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
16018
16019 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
16020
16021 if(IS_WDI_STATUS_FAILURE(status))
16022 {
16023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16024 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
16025 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16026 vos_mem_free(pWdaParams->wdaMsgParam);
16027 vos_mem_free(pWdaParams);
16028 }
16029 return CONVERT_WDI2VOS_STATUS(status) ;
16030}
16031#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16032
16033/*==========================================================================
16034 FUNCTION WDA_TransportChannelDebug
16035
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]16036 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16037 Display Transport Channel debugging information
16038 User may request to display DXE channel snapshot
16039 Or if host driver detects any abnormal stcuk may display
16040
16041 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16042 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]16043 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16044 debugFlags : Enable stall detect features
16045 defined by WPAL_DeviceDebugFlags
16046 These features may effect
16047 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16048
16049 RETURN VALUE
16050 NONE
16051
16052===========================================================================*/
16053void WDA_TransportChannelDebug
16054(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16055 tpAniSirGlobal pMac,
16056 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16057 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16058)
16059{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16060 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16061 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16062}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]16063
16064/*==========================================================================
16065 FUNCTION WDA_SetEnableSSR
16066
16067 DESCRIPTION
16068 API to enable/disable SSR on WDI timeout
16069
16070 PARAMETERS
16071 enableSSR : enable/disable SSR
16072
16073 RETURN VALUE
16074 NONE
16075
16076===========================================================================*/
16077void WDA_SetEnableSSR(v_BOOL_t enableSSR)
16078{
16079 WDI_SetEnableSSR(enableSSR);
16080}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]16081
16082#ifdef FEATURE_WLAN_LPHB
16083/*
16084 * FUNCTION: WDA_LPHBconfRspCallback
16085 *
16086 */
16087void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
16088{
16089 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16090
16091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16092 "<------ %s " ,__func__);
16093 if (NULL == pWdaParams)
16094 {
16095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16096 "%s: pWdaParams received NULL", __func__);
16097 VOS_ASSERT(0) ;
16098 return ;
16099 }
16100
16101 /* Do not need to send notification to upper layer
16102 * Just free allocated resources */
16103 if (pWdaParams != NULL)
16104 {
16105 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16106 {
16107 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16108 }
16109 vos_mem_free(pWdaParams->wdaMsgParam) ;
16110 vos_mem_free(pWdaParams) ;
16111 }
16112
16113 return;
16114}
16115
16116/*
16117 * FUNCTION: WDA_ProcessLPHBConfReq
16118 *
16119 */
16120VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
16121 tSirLPHBReq *pData)
16122{
16123 WDI_Status wdiStatus;
16124 tWDA_ReqParams *pWdaParams ;
16125
16126 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16127 "------> %s " , __func__);
16128
16129 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16130 if (NULL == pWdaParams)
16131 {
16132 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16133 "%s: VOS MEM Alloc Failure", __func__);
16134 VOS_ASSERT(0);
16135 vos_mem_free(pData);
16136 return VOS_STATUS_E_NOMEM;
16137 }
16138
16139 pWdaParams->pWdaContext = pWDA;
16140 pWdaParams->wdaMsgParam = (void *)pData;
16141 pWdaParams->wdaWdiApiMsgParam = NULL;
16142
16143 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
16144 if (WDI_STATUS_PENDING == wdiStatus)
16145 {
16146 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16147 "Pending received for %s:%d ", __func__, __LINE__);
16148 }
16149 else if (WDI_STATUS_SUCCESS != wdiStatus)
16150 {
16151 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16152 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
16153 vos_mem_free(pWdaParams->wdaMsgParam);
16154 vos_mem_free(pWdaParams);
16155 }
16156
16157 return CONVERT_WDI2VOS_STATUS(wdiStatus);
16158}
16159#endif /* FEATURE_WLAN_LPHB */
16160
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]16161void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
16162 void* pUserData)
16163{
16164 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
16165
16166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16167 "<------ %s " ,__func__);
16168 if (NULL == pBcnMissRateInfo)
16169 {
16170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16171 "%s: pWdaParams received NULL", __func__);
16172 VOS_ASSERT(0) ;
16173 return ;
16174 }
16175 if (pBcnMissRateInfo->callback)
16176 {
16177 pBcnMissRateInfo->callback(status, bcnMissRate,
16178 pBcnMissRateInfo->data);
16179 }
16180 vos_mem_free(pUserData);
16181
16182 return;
16183}
16184
16185v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
16186 tSirBcnMissRateReq *pData)
16187{
16188 WDI_Status wdiStatus;
16189 tSirBcnMissRateInfo *pBcnMissRateInfo;
16190
16191 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16192 "------> %s " , __func__);
16193
16194 pBcnMissRateInfo =
16195 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
16196 if (NULL == pBcnMissRateInfo)
16197 {
16198 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16199 "%s: VOS MEM Alloc Failure", __func__);
16200 VOS_ASSERT(0);
16201 vos_mem_free(pData);
16202 return;
16203 }
16204
16205 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
16206 pBcnMissRateInfo->data = pData->data;
16207
16208 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
16209 WDA_GetBcnMissRateCallback,
16210 pData->bssid);
16211 if (WDI_STATUS_PENDING == wdiStatus)
16212 {
16213 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16214 "Pending received for %s:%d ", __func__, __LINE__);
16215 }
16216 else if (WDI_STATUS_SUCCESS != wdiStatus)
16217 {
16218 if (pBcnMissRateInfo->callback)
16219 {
16220 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
16221 -1, pBcnMissRateInfo->data);
16222 }
16223 }
16224 vos_mem_free(pData);
16225}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16226
16227#ifdef WLAN_FEATURE_EXTSCAN
16228
16229/*==========================================================================
16230 FUNCTION WDA_EXTScanStartRspCallback
16231
16232 DESCRIPTION
16233 API to send EXTScan Start Response to HDD
16234
16235 PARAMETERS
16236 pEventData: Response from FW
16237 pUserData:
16238===========================================================================*/
16239void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
16240{
16241 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16242 tWDA_CbContext *pWDA = NULL;
16243 void *pCallbackContext;
16244 tpAniSirGlobal pMac;
16245
16246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16247 "%s:", __func__);
16248 if (NULL == pWdaParams)
16249 {
16250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16251 "%s: pWdaParams received NULL", __func__);
16252 VOS_ASSERT(0);
16253 return;
16254 }
16255
16256 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16257
16258 if (NULL == pWDA)
16259 {
16260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16261 "%s: pWDA received NULL", __func__);
16262 VOS_ASSERT(0);
16263 goto error;
16264 }
16265
16266 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16267 if (NULL == pMac)
16268 {
16269 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16270 "%s:pMac is NULL", __func__);
16271 VOS_ASSERT(0);
16272 goto error;
16273 }
16274
16275 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16276
16277 if (pMac->sme.pEXTScanIndCb)
16278 {
16279 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
16280 pEventData);
16281 }
16282 else
16283 {
16284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16285 "%s:HDD callback is null", __func__);
16286 VOS_ASSERT(0);
16287 }
16288
16289error:
16290
16291 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16292 {
16293 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16294 }
16295 if (pWdaParams->wdaMsgParam != NULL)
16296 {
16297 vos_mem_free(pWdaParams->wdaMsgParam);
16298 }
16299 vos_mem_free(pWdaParams) ;
16300
16301 return;
16302}
16303
16304/*==========================================================================
16305 FUNCTION WDA_EXTScanStopRspCallback
16306
16307 DESCRIPTION
16308 API to send EXTScan Stop Response to HDD
16309
16310 PARAMETERS
16311 pEventData: Response from FW
16312 pUserData:
16313===========================================================================*/
16314void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
16315{
16316 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16317 tWDA_CbContext *pWDA = NULL;
16318 void *pCallbackContext;
16319 tpAniSirGlobal pMac;
16320
16321 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16322 "%s:", __func__);
16323 if (NULL == pWdaParams)
16324 {
16325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16326 "%s: pWdaParams received NULL", __func__);
16327 VOS_ASSERT(0);
16328 return;
16329 }
16330
16331 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16332
16333 if (NULL == pWDA)
16334 {
16335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16336 "%s: pWDA received NULL", __func__);
16337 VOS_ASSERT(0);
16338 goto error;
16339 }
16340
16341 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16342 if (NULL == pMac)
16343 {
16344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16345 "%s:pMac is NULL", __func__);
16346 VOS_ASSERT(0);
16347 goto error;
16348 }
16349 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16350
16351 if (pMac->sme.pEXTScanIndCb)
16352 {
16353 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16354 "%s:HDD call back function called", __func__);
16355 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
16356 pEventData);
16357 }
16358 else
16359 {
16360 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16361 "%s:HDD callback is null", __func__);
16362 VOS_ASSERT(0);
16363 }
16364
16365error:
16366
16367 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16368 {
16369 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16370 }
16371 if (pWdaParams->wdaMsgParam != NULL)
16372 {
16373 vos_mem_free(pWdaParams->wdaMsgParam);
16374 }
16375 vos_mem_free(pWdaParams) ;
16376
16377
16378 return;
16379}
16380
16381/*==========================================================================
16382 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
16383
16384 DESCRIPTION
16385 API to send EXTScan Get Cached Results Response to HDD
16386
16387 PARAMETERS
16388 pEventData: Response from FW
16389 pUserData:
16390===========================================================================*/
16391void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
16392{
16393 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16394 tWDA_CbContext *pWDA = NULL;
16395 void *pCallbackContext;
16396 tpAniSirGlobal pMac;
16397
16398 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16399 "%s: ", __func__);
16400 if (NULL == pWdaParams)
16401 {
16402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16403 "%s: pWdaParams received NULL", __func__);
16404 VOS_ASSERT(0);
16405 return;
16406 }
16407
16408 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16409
16410 if (NULL == pWDA)
16411 {
16412 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16413 "%s: pWDA received NULL", __func__);
16414 VOS_ASSERT(0);
16415 goto error;
16416 }
16417
16418 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16419 if (NULL == pMac)
16420 {
16421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16422 "%s:pMac is NULL", __func__);
16423 VOS_ASSERT(0);
16424 goto error;
16425 }
16426
16427 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16428
16429 if (pMac->sme.pEXTScanIndCb)
16430 {
16431 pMac->sme.pEXTScanIndCb(pCallbackContext,
16432 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
16433 pEventData);
16434 }
16435 else
16436 {
16437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16438 "%s:HDD callback is null", __func__);
16439 VOS_ASSERT(0);
16440 }
16441
16442
16443error:
16444
16445 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16446 {
16447 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16448 }
16449 if (pWdaParams->wdaMsgParam != NULL)
16450 {
16451 vos_mem_free(pWdaParams->wdaMsgParam);
16452 }
16453 vos_mem_free(pWdaParams) ;
16454
16455 return;
16456}
16457
16458/*==========================================================================
16459 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
16460
16461 DESCRIPTION
16462 API to send EXTScan Get Capabilities Response to HDD
16463
16464 PARAMETERS
16465 pEventData: Response from FW
16466 pUserData:
16467===========================================================================*/
16468void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
16469{
16470 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16471 tWDA_CbContext *pWDA = NULL;
16472 void *pCallbackContext;
16473 tpAniSirGlobal pMac;
16474
16475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16476 "%s:", __func__);
16477 if (NULL == pWdaParams)
16478 {
16479 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16480 "%s: pWdaParams received NULL", __func__);
16481 VOS_ASSERT(0);
16482 return;
16483 }
16484
16485 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16486
16487 if (NULL == pWDA)
16488 {
16489 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16490 "%s: pWDA received NULL", __func__);
16491 VOS_ASSERT(0);
16492 goto error;
16493 }
16494
16495 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16496 if (NULL == pMac)
16497 {
16498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16499 "%s:pMac is NULL", __func__);
16500 VOS_ASSERT(0);
16501 goto error;
16502 }
16503
16504 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16505
16506 if (pMac->sme.pEXTScanIndCb)
16507 {
16508 pMac->sme.pEXTScanIndCb(pCallbackContext,
16509 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
16510 pEventData);
16511 }
16512 else
16513 {
16514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16515 "%s:HDD callback is null", __func__);
16516 VOS_ASSERT(0);
16517 }
16518
16519
16520error:
16521
16522 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16523 {
16524 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16525 }
16526 if (pWdaParams->wdaMsgParam != NULL)
16527 {
16528 vos_mem_free(pWdaParams->wdaMsgParam);
16529 }
16530 vos_mem_free(pWdaParams) ;
16531
16532 return;
16533}
16534
16535/*==========================================================================
16536 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
16537
16538 DESCRIPTION
16539 API to send EXTScan Set BSSID Hotlist Response to HDD
16540
16541 PARAMETERS
16542 pEventData: Response from FW
16543 pUserData:
16544===========================================================================*/
16545void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16546{
16547 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16548 tWDA_CbContext *pWDA = NULL;
16549 void *pCallbackContext;
16550 tpAniSirGlobal pMac;
16551
16552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16553 "%s: ", __func__);
16554 if (NULL == pWdaParams)
16555 {
16556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16557 "%s: pWdaParams received NULL", __func__);
16558 VOS_ASSERT(0) ;
16559 return;
16560 }
16561
16562 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16563
16564 if (NULL == pWDA)
16565 {
16566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16567 "%s: pWDA received NULL", __func__);
16568 VOS_ASSERT(0);
16569 goto error;
16570 }
16571
16572 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16573 if (NULL == pMac)
16574 {
16575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16576 "%s:pMac is NULL", __func__);
16577 VOS_ASSERT(0);
16578 goto error;
16579 }
16580
16581 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16582
16583 if (pMac->sme.pEXTScanIndCb)
16584 {
16585 pMac->sme.pEXTScanIndCb(pCallbackContext,
16586 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
16587 pEventData);
16588 }
16589 else
16590 {
16591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16592 "%s:HDD callback is null", __func__);
16593 VOS_ASSERT(0);
16594 }
16595
16596
16597error:
16598
16599 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16600 {
16601 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16602 }
16603 if (pWdaParams->wdaMsgParam != NULL)
16604 {
16605 vos_mem_free(pWdaParams->wdaMsgParam);
16606 }
16607 vos_mem_free(pWdaParams) ;
16608
16609 return;
16610}
16611
16612/*==========================================================================
16613 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
16614
16615 DESCRIPTION
16616 API to send EXTScan ReSet BSSID Hotlist Response to HDD
16617
16618 PARAMETERS
16619 pEventData: Response from FW
16620 pUserData:
16621===========================================================================*/
16622void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16623{
16624 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16625 tWDA_CbContext *pWDA = NULL;
16626 void *pCallbackContext;
16627 tpAniSirGlobal pMac;
16628
16629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16630 "%s:", __func__);
16631 if (NULL == pWdaParams)
16632 {
16633 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16634 "%s: pWdaParams received NULL", __func__);
16635 VOS_ASSERT(0) ;
16636 return;
16637 }
16638
16639 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16640
16641 if (NULL == pWDA)
16642 {
16643 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16644 "%s: pWDA received NULL", __func__);
16645 VOS_ASSERT(0);
16646 goto error;
16647 }
16648
16649 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16650 if (NULL == pMac)
16651 {
16652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16653 "%s:pMac is NULL", __func__);
16654 VOS_ASSERT(0);
16655 goto error;
16656 }
16657
16658 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16659
16660 if (pMac->sme.pEXTScanIndCb)
16661 {
16662 pMac->sme.pEXTScanIndCb(pCallbackContext,
16663 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
16664 pEventData);
16665 }
16666 else
16667 {
16668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16669 "%s:HDD callback is null", __func__);
16670 VOS_ASSERT(0);
16671 }
16672
16673
16674error:
16675
16676 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16677 {
16678 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16679 }
16680 if (pWdaParams->wdaMsgParam != NULL)
16681 {
16682 vos_mem_free(pWdaParams->wdaMsgParam);
16683 }
16684 vos_mem_free(pWdaParams) ;
16685
16686 return;
16687}
16688
16689/*==========================================================================
16690 FUNCTION WDA_EXTScanSetSignfRSSIChangeRspCallback
16691
16692 DESCRIPTION
16693 API to send EXTScan Set Significant RSSI Change RSP to HDD
16694
16695 PARAMETERS
16696 pEventData: Response from FW
16697 pUserData:
16698===========================================================================*/
16699void WDA_EXTScanSetSignfRSSIChangeRspCallback(void *pEventData, void* pUserData)
16700{
16701 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16702 tWDA_CbContext *pWDA = NULL;
16703 void *pCallbackContext;
16704 tpAniSirGlobal pMac;
16705
16706 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16707 "%s:", __func__);
16708 if (NULL == pWdaParams)
16709 {
16710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16711 "%s: pWdaParams received NULL", __func__);
16712 VOS_ASSERT(0) ;
16713 return;
16714 }
16715
16716 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16717
16718 if (NULL == pWDA)
16719 {
16720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16721 "%s: pWDA received NULL", __func__);
16722 VOS_ASSERT(0);
16723 goto error;
16724 }
16725
16726 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16727 if (NULL == pMac)
16728 {
16729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16730 "%s:pMac is NULL", __func__);
16731 VOS_ASSERT(0);
16732 goto error;
16733 }
16734
16735 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16736
16737 if (pMac->sme.pEXTScanIndCb)
16738 {
16739 pMac->sme.pEXTScanIndCb(pCallbackContext,
16740 WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_RSP,
16741 pEventData);
16742 }
16743 else
16744 {
16745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16746 "%s:HDD callback is null", __func__);
16747 VOS_ASSERT(0);
16748 }
16749
16750
16751error:
16752
16753 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16754 {
16755 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16756 }
16757 if (pWdaParams->wdaMsgParam != NULL)
16758 {
16759 vos_mem_free(pWdaParams->wdaMsgParam);
16760 }
16761 vos_mem_free(pWdaParams) ;
16762
16763 return;
16764}
16765
16766/*==========================================================================
16767 FUNCTION WDA_EXTScanResetSignfRSSIChangeRspCallback
16768
16769 DESCRIPTION
16770 API to send EXTScan Set Significant RSSI Change RSP to HDD
16771
16772 PARAMETERS
16773 pEventData: Response from FW
16774 pUserData:
16775===========================================================================*/
16776void WDA_EXTScanResetSignfRSSIChangeRspCallback(void *pEventData,
16777 void* pUserData)
16778{
16779 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16780 tWDA_CbContext *pWDA = NULL;
16781 void *pCallbackContext;
16782 tpAniSirGlobal pMac;
16783
16784 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16785 "%s:", __func__);
16786 if (NULL == pWdaParams)
16787 {
16788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16789 "%s: pWdaParams received NULL", __func__);
16790 VOS_ASSERT(0) ;
16791 return;
16792 }
16793
16794 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16795
16796 if (NULL == pWDA)
16797 {
16798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16799 "%s: pWDA received NULL", __func__);
16800 VOS_ASSERT(0);
16801 goto error;
16802 }
16803
16804 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16805 if (NULL == pMac)
16806 {
16807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16808 "%s:pMac is NULL", __func__);
16809 VOS_ASSERT(0);
16810 goto error;
16811 }
16812
16813 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16814
16815 if (pMac->sme.pEXTScanIndCb)
16816 {
16817 pMac->sme.pEXTScanIndCb(pCallbackContext,
16818 WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_RSP,
16819 pEventData);
16820 }
16821 else
16822 {
16823 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16824 "%s:HDD callback is null", __func__);
16825 VOS_ASSERT(0);
16826 }
16827
16828
16829error:
16830
16831 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16832 {
16833 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16834 }
16835 if (pWdaParams->wdaMsgParam != NULL)
16836 {
16837 vos_mem_free(pWdaParams->wdaMsgParam);
16838 }
16839 vos_mem_free(pWdaParams) ;
16840
16841 return;
16842}
16843
16844/*==========================================================================
16845 FUNCTION WDA_ProcessEXTScanStartReq
16846
16847 DESCRIPTION
16848 API to send EXTScan Start Request to WDI
16849
16850 PARAMETERS
16851 pWDA: Pointer to WDA context
16852 wdaRequest: Pointer to EXTScan req parameters
16853===========================================================================*/
16854VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
16855 tSirEXTScanStartReqParams *wdaRequest)
16856{
16857 WDI_Status status = WDI_STATUS_SUCCESS;
16858 tWDA_ReqParams *pWdaParams;
16859
16860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16861 "%s: ", __func__);
16862 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16863 if (NULL == pWdaParams)
16864 {
16865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16866 "%s: VOS MEM Alloc Failure", __func__);
16867 VOS_ASSERT(0);
16868 return VOS_STATUS_E_NOMEM;
16869 }
16870 pWdaParams->pWdaContext = pWDA;
16871 pWdaParams->wdaMsgParam = wdaRequest;
16872 pWdaParams->wdaWdiApiMsgParam = NULL;
16873
16874 status = WDI_EXTScanStartReq((void *)wdaRequest,
16875 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
16876 (void *)pWdaParams);
16877 if (IS_WDI_STATUS_FAILURE(status))
16878 {
16879 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16880 "Failure to request. Free all the memory " );
16881 vos_mem_free(pWdaParams->wdaMsgParam);
16882 vos_mem_free(pWdaParams);
16883 }
16884 return CONVERT_WDI2VOS_STATUS(status);
16885}
16886
16887/*==========================================================================
16888 FUNCTION WDA_ProcessEXTScanStopReq
16889
16890 DESCRIPTION
16891 API to send EXTScan Start Request to WDI
16892
16893 PARAMETERS
16894 pWDA: Pointer to WDA context
16895 wdaRequest: Pointer to EXTScan req parameters
16896===========================================================================*/
16897VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
16898 tSirEXTScanStopReqParams *wdaRequest)
16899{
16900 WDI_Status status = WDI_STATUS_SUCCESS;
16901 tWDA_ReqParams *pWdaParams;
16902
16903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16904 "%s:", __func__);
16905 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16906 if (NULL == pWdaParams)
16907 {
16908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16909 "%s: VOS MEM Alloc Failure", __func__);
16910 VOS_ASSERT(0);
16911 return VOS_STATUS_E_NOMEM;
16912 }
16913 pWdaParams->pWdaContext = pWDA;
16914 pWdaParams->wdaMsgParam = wdaRequest;
16915 pWdaParams->wdaWdiApiMsgParam = NULL;
16916
16917 status = WDI_EXTScanStopReq((void *)wdaRequest,
16918 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
16919 (void *)pWdaParams);
16920 if (IS_WDI_STATUS_FAILURE(status))
16921 {
16922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16923 "Failure to request. Free all the memory " );
16924 vos_mem_free(pWdaParams->wdaMsgParam);
16925 vos_mem_free(pWdaParams);
16926 }
16927 return CONVERT_WDI2VOS_STATUS(status);
16928}
16929
16930/*==========================================================================
16931 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
16932
16933 DESCRIPTION
16934 API to send EXTScan Get Cached Results Request to WDI
16935
16936 PARAMETERS
16937 pWDA: Pointer to WDA context
16938 wdaRequest: Pointer to EXTScan req parameters
16939===========================================================================*/
16940VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
16941 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
16942{
16943 WDI_Status status = WDI_STATUS_SUCCESS;
16944 tWDA_ReqParams *pWdaParams;
16945
16946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16947 "%s: ", __func__);
16948 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16949 if (NULL == pWdaParams)
16950 {
16951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16952 "%s: VOS MEM Alloc Failure", __func__);
16953 VOS_ASSERT(0);
16954 return VOS_STATUS_E_NOMEM;
16955 }
16956 pWdaParams->pWdaContext = pWDA;
16957 pWdaParams->wdaMsgParam = wdaRequest;
16958 pWdaParams->wdaWdiApiMsgParam = NULL;
16959
16960 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
16961 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
16962 (void *)pWdaParams);
16963 if (IS_WDI_STATUS_FAILURE(status))
16964 {
16965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16966 "Failure to request. Free all the memory " );
16967 vos_mem_free(pWdaParams->wdaMsgParam);
16968 vos_mem_free(pWdaParams);
16969 }
16970 return CONVERT_WDI2VOS_STATUS(status);
16971}
16972
16973/*==========================================================================
16974 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
16975
16976 DESCRIPTION
16977 API to send EXTScan Get Capabilities Request to WDI
16978
16979 PARAMETERS
16980 pWDA: Pointer to WDA context
16981 wdaRequest: Pointer to EXTScan req parameters
16982===========================================================================*/
16983VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
16984 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
16985{
16986 WDI_Status status = WDI_STATUS_SUCCESS;
16987 tWDA_ReqParams *pWdaParams;
16988
16989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16990 "%s:", __func__);
16991 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16992 if (NULL == pWdaParams)
16993 {
16994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16995 "%s: VOS MEM Alloc Failure", __func__);
16996 VOS_ASSERT(0);
16997 return VOS_STATUS_E_NOMEM;
16998 }
16999 pWdaParams->pWdaContext = pWDA;
17000 pWdaParams->wdaMsgParam = wdaRequest;
17001 pWdaParams->wdaWdiApiMsgParam = NULL;
17002
17003 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
17004 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
17005 (void *)pWdaParams);
17006 if (IS_WDI_STATUS_FAILURE(status))
17007 {
17008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17009 "Failure to request. Free all the memory " );
17010 vos_mem_free(pWdaParams->wdaMsgParam);
17011 vos_mem_free(pWdaParams);
17012 }
17013 return CONVERT_WDI2VOS_STATUS(status);
17014}
17015
17016/*==========================================================================
17017 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
17018
17019 DESCRIPTION
17020 API to send Set BSSID Hotlist Request to WDI
17021
17022 PARAMETERS
17023 pWDA: Pointer to WDA context
17024 wdaRequest: Pointer to EXTScan req parameters
17025===========================================================================*/
17026VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17027 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
17028{
17029 WDI_Status status = WDI_STATUS_SUCCESS;
17030 tWDA_ReqParams *pWdaParams;
17031
17032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17033 "%s: ", __func__);
17034 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17035 if (NULL == pWdaParams)
17036 {
17037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17038 "%s: VOS MEM Alloc Failure", __func__);
17039 VOS_ASSERT(0);
17040 return VOS_STATUS_E_NOMEM;
17041 }
17042 pWdaParams->pWdaContext = pWDA;
17043 pWdaParams->wdaMsgParam = wdaRequest;
17044 pWdaParams->wdaWdiApiMsgParam = NULL;
17045
17046 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
17047 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
17048 (void *)pWdaParams);
17049 if (IS_WDI_STATUS_FAILURE(status))
17050 {
17051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17052 "Failure to request. Free all the memory " );
17053 vos_mem_free(pWdaParams->wdaMsgParam);
17054 vos_mem_free(pWdaParams);
17055 }
17056 return CONVERT_WDI2VOS_STATUS(status);
17057}
17058
17059/*==========================================================================
17060 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
17061
17062 DESCRIPTION
17063 API to send Reset BSSID Hotlist Request to WDI
17064
17065 PARAMETERS
17066 pWDA: Pointer to WDA context
17067 wdaRequest: Pointer to EXTScan req parameters
17068===========================================================================*/
17069VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17070 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
17071{
17072 WDI_Status status = WDI_STATUS_SUCCESS;
17073 tWDA_ReqParams *pWdaParams;
17074
17075 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17076 "%s:", __func__);
17077 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17078 if (NULL == pWdaParams)
17079 {
17080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17081 "%s: VOS MEM Alloc Failure", __func__);
17082 VOS_ASSERT(0);
17083 return VOS_STATUS_E_NOMEM;
17084 }
17085 pWdaParams->pWdaContext = pWDA;
17086 pWdaParams->wdaMsgParam = wdaRequest;
17087 pWdaParams->wdaWdiApiMsgParam = NULL;
17088
17089 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
17090 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
17091 (void *)pWdaParams);
17092 if (IS_WDI_STATUS_FAILURE(status))
17093 {
17094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17095 "Failure to request. Free all the memory " );
17096 vos_mem_free(pWdaParams->wdaMsgParam);
17097 vos_mem_free(pWdaParams);
17098 }
17099 return CONVERT_WDI2VOS_STATUS(status);
17100}
17101
17102/*==========================================================================
17103 FUNCTION WDA_ProcessEXTScanSetSignfRSSIChangeReq
17104
17105 DESCRIPTION
17106 API to send Set Significant RSSI Change Request to WDI
17107
17108 PARAMETERS
17109 pWDA: Pointer to WDA context
17110 wdaRequest: Pointer to EXTScan req parameters
17111===========================================================================*/
17112VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17113 tSirEXTScanSetSignificantChangeReqParams *wdaRequest)
17114{
17115 WDI_Status status = WDI_STATUS_SUCCESS;
17116 tWDA_ReqParams *pWdaParams;
17117
17118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17119 "%s: ", __func__);
17120 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17121 if (NULL == pWdaParams)
17122 {
17123 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17124 "%s: VOS MEM Alloc Failure", __func__);
17125 VOS_ASSERT(0);
17126 return VOS_STATUS_E_NOMEM;
17127 }
17128 pWdaParams->pWdaContext = pWDA;
17129 pWdaParams->wdaMsgParam = wdaRequest;
17130 pWdaParams->wdaWdiApiMsgParam = NULL;
17131
17132 status = WDI_EXTScanSetSignfRSSIChangeReq((void *)wdaRequest,
17133 (WDI_EXTScanSetSignfRSSIChangeRspCb)WDA_EXTScanSetSignfRSSIChangeRspCallback,
17134 (void *)pWdaParams);
17135 if (IS_WDI_STATUS_FAILURE(status))
17136 {
17137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17138 "Failure to request. Free all the memory " );
17139 vos_mem_free(pWdaParams->wdaMsgParam);
17140 vos_mem_free(pWdaParams);
17141 }
17142 return CONVERT_WDI2VOS_STATUS(status);
17143}
17144
17145/*==========================================================================
17146 FUNCTION WDA_ProcessEXTScanResetSignfRSSIChangeReq
17147
17148 DESCRIPTION
17149 API to send Reset Significant RSSI Change Request to WDI
17150
17151 PARAMETERS
17152 pWDA: Pointer to WDA context
17153 wdaRequest: Pointer to EXTScan req parameters
17154===========================================================================*/
17155VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17156 tSirEXTScanResetSignificantChangeReqParams *wdaRequest)
17157{
17158 WDI_Status status = WDI_STATUS_SUCCESS;
17159 tWDA_ReqParams *pWdaParams;
17160
17161 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17162 "%s:", __func__);
17163 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17164 if (NULL == pWdaParams)
17165 {
17166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17167 "%s: VOS MEM Alloc Failure", __func__);
17168 VOS_ASSERT(0);
17169 return VOS_STATUS_E_NOMEM;
17170 }
17171 pWdaParams->pWdaContext = pWDA;
17172 pWdaParams->wdaMsgParam = wdaRequest;
17173 pWdaParams->wdaWdiApiMsgParam = NULL;
17174
17175 status = WDI_EXTScanResetSignfRSSIChangeReq((void *)wdaRequest,
17176 (WDI_EXTScanResetSignfRSSIChangeRspCb)
17177 WDA_EXTScanResetSignfRSSIChangeRspCallback,
17178 (void *)pWdaParams);
17179 if (IS_WDI_STATUS_FAILURE(status))
17180 {
17181 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17182 "Failure to request. Free all the memory " );
17183 vos_mem_free(pWdaParams->wdaMsgParam);
17184 vos_mem_free(pWdaParams);
17185 }
17186 return CONVERT_WDI2VOS_STATUS(status);
17187}
17188#endif /* WLAN_FEATURE_EXTSCAN */
17189
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]17190#ifdef WLAN_FEATURE_LINK_LAYER_STATS
17191
17192/*==========================================================================
17193 FUNCTION WDA_LLStatsSetRspCallback
17194
17195 DESCRIPTION
17196 API to process set link layer statistics response from FW
17197
17198 PARAMETERS
17199 pRsp: Pointer to set link layer statistics response
17200 pUserData: Pointer to user data
17201
17202 RETURN VALUE
17203 NONE
17204
17205===========================================================================*/
17206void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
17207{
17208 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17209
17210
17211 if (NULL == pWdaParams)
17212 {
17213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17214 "%s: pWdaParams received NULL", __func__);
17215 VOS_ASSERT(0) ;
17216 return ;
17217 }
17218
17219 /* Do not need to send notification to upper layer
17220 * Just free allocated resources */
17221 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17222 {
17223 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17224 }
17225 if (pWdaParams->wdaMsgParam != NULL)
17226 {
17227 vos_mem_free(pWdaParams->wdaMsgParam);
17228 }
17229 vos_mem_free(pWdaParams) ;
17230
17231 return;
17232}
17233
17234/*==========================================================================
17235 FUNCTION WDA_ProcessLLStatsSetReq
17236
17237 DESCRIPTION
17238 API to send Set Link Layer Stats request to WDI
17239
17240 PARAMETERS
17241 pWDA: Pointer to WDA context
17242 wdaRequest: Pointer to set Link Layer Stats req parameters
17243===========================================================================*/
17244VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
17245 tSirLLStatsSetReq *wdaRequest)
17246{
17247 WDI_Status status = WDI_STATUS_SUCCESS;
17248 tWDA_ReqParams *pWdaParams;
17249
17250 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17251 if (NULL == pWdaParams)
17252 {
17253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17254 "%s: VOS MEM Alloc Failure", __func__);
17255 VOS_ASSERT(0);
17256 return VOS_STATUS_E_NOMEM;
17257 }
17258 pWdaParams->pWdaContext = pWDA;
17259 pWdaParams->wdaMsgParam = wdaRequest;
17260 pWdaParams->wdaWdiApiMsgParam = NULL;
17261
17262 status = WDI_LLStatsSetReq((void *)wdaRequest,
17263 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
17264 (void *)pWdaParams);
17265 if (IS_WDI_STATUS_FAILURE(status))
17266 {
17267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17268 "Failure to request. Free all the memory " );
17269 vos_mem_free(pWdaParams->wdaMsgParam);
17270 vos_mem_free(pWdaParams);
17271 }
17272 return CONVERT_WDI2VOS_STATUS(status);
17273}
17274
17275/*==========================================================================
17276 FUNCTION WDA_LLStatsGetRspCallback
17277
17278 DESCRIPTION
17279 API to process get link layer statistics response from FW
17280
17281 PARAMETERS
17282 pRsp: Pointer to get link layer statistics response
17283 pUserData: Pointer to user data
17284
17285 RETURN VALUE
17286 NONE
17287
17288===========================================================================*/
17289void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
17290{
17291 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17292
17293 if (NULL == pWdaParams)
17294 {
17295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17296 "%s: pWdaParams received NULL", __func__);
17297 VOS_ASSERT(0) ;
17298 return ;
17299 }
17300
17301 /* Do not need to send notification to upper layer
17302 * Just free allocated resources */
17303 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17304 {
17305 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17306 }
17307 if (pWdaParams->wdaMsgParam != NULL)
17308 {
17309 vos_mem_free(pWdaParams->wdaMsgParam);
17310 }
17311 vos_mem_free(pWdaParams) ;
17312
17313 return;
17314}
17315
17316/*==========================================================================
17317 FUNCTION WDA_ProcessLLStatsGetReq
17318
17319 DESCRIPTION
17320 API to send Get Link Layer Stats request to WDI
17321
17322 PARAMETERS
17323 pWDA: Pointer to WDA context
17324 wdaRequest: Pointer to get Link Layer Stats req parameters
17325===========================================================================*/
17326VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
17327 tSirLLStatsGetReq *wdaRequest)
17328{
17329 WDI_Status status = WDI_STATUS_SUCCESS;
17330 tWDA_ReqParams *pWdaParams;
17331
17332 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17333 if (NULL == pWdaParams)
17334 {
17335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17336 "%s: VOS MEM Alloc Failure", __func__);
17337 VOS_ASSERT(0);
17338 return VOS_STATUS_E_NOMEM;
17339 }
17340 pWdaParams->pWdaContext = pWDA;
17341 pWdaParams->wdaMsgParam = wdaRequest;
17342 pWdaParams->wdaWdiApiMsgParam = NULL;
17343
17344 status = WDI_LLStatsGetReq((void *) wdaRequest,
17345 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
17346 (void *)pWdaParams);
17347 if (IS_WDI_STATUS_FAILURE(status))
17348 {
17349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17350 "Failure to request. Free all the memory " );
17351 vos_mem_free(pWdaParams->wdaMsgParam);
17352 vos_mem_free(pWdaParams);
17353 }
17354 return CONVERT_WDI2VOS_STATUS(status);
17355}
17356
17357/*==========================================================================
17358 FUNCTION WDA_LLStatsClearRspCallback
17359
17360 DESCRIPTION
17361 API to process clear link layer statistics response from FW
17362
17363 PARAMETERS
17364 pRsp: Pointer to clear link layer statistics response
17365 pUserData: Pointer to user data
17366
17367 RETURN VALUE
17368 NONE
17369
17370===========================================================================*/
17371void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
17372{
17373 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17374
17375
17376 if (NULL == pWdaParams)
17377 {
17378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17379 "%s: pWdaParams received NULL", __func__);
17380 VOS_ASSERT(0) ;
17381 return ;
17382 }
17383 /* Do not need to send notification to upper layer
17384 * Just free allocated resources */
17385 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17386 {
17387 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17388 }
17389 if (pWdaParams->wdaMsgParam != NULL)
17390 {
17391 vos_mem_free(pWdaParams->wdaMsgParam);
17392 }
17393 vos_mem_free(pWdaParams) ;
17394 return;
17395}
17396
17397/*==========================================================================
17398 FUNCTION WDA_ProcessLLStatsClearReq
17399
17400 DESCRIPTION
17401 API to send Clear Link Layer Stats request to WDI
17402
17403 PARAMETERS
17404 pWDA: Pointer to WDA context
17405 wdaRequest: Pointer to earLink Layer Stats req
17406===========================================================================*/
17407VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
17408 tSirLLStatsClearReq *wdaRequest)
17409{
17410 WDI_Status status = WDI_STATUS_SUCCESS;
17411 tWDA_ReqParams *pWdaParams;
17412
17413 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17414 if (NULL == pWdaParams)
17415 {
17416 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17417 "%s: VOS MEM Alloc Failure", __func__);
17418 VOS_ASSERT(0);
17419 return VOS_STATUS_E_NOMEM;
17420 }
17421 pWdaParams->pWdaContext = pWDA;
17422 pWdaParams->wdaMsgParam = wdaRequest;
17423 pWdaParams->wdaWdiApiMsgParam = NULL;
17424
17425 status = WDI_LLStatsClearReq((void *) wdaRequest,
17426 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
17427 (void *)pWdaParams);
17428 if (IS_WDI_STATUS_FAILURE(status))
17429 {
17430 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17431 "Failure to request. Free all the memory " );
17432 vos_mem_free(pWdaParams->wdaMsgParam);
17433 vos_mem_free(pWdaParams);
17434 }
17435 return CONVERT_WDI2VOS_STATUS(status);
17436}
17437
17438#endif /* WLAN_FEATURE_LINK_LAYER_STATS */