Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / c0f739f8cc9de52ee0de75c7b76d8bb96cb5a071 / . / CORE / WDA / src / wlan_qct_wda.c
blob: 33754497dfd630d4cfec537bd7e0395bdbcca517 [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]2 * Copyright (c) 2012-2014 The Linux Foundation. All rights reserved.
3 *
4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
5 *
6 *
7 * Permission to use, copy, modify, and/or distribute this software for
8 * any purpose with or without fee is hereby granted, provided that the
9 * above copyright notice and this permission notice appear in all
10 * copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 * PERFORMANCE OF THIS SOFTWARE.
20 */
21
22/*
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame]23 * This file was originally distributed by Qualcomm Atheros, Inc.
24 * under proprietary terms before Copyright ownership was assigned
25 * to the Linux Foundation.
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]26 */
27
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]28
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame]29
30
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]31/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]32 W L A N _ Q C T _ WDA . C
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]33 OVERVIEW:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]34 This software unit holds the implementation of the WLAN Transport Layer.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]35 The functions externalized by this module are to be called ONLY by other
36 WLAN modules that properly register with the Transport Layer initially.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]37 DEPENDENCIES:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]38 Are listed for each API below.
39
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]40 Copyright (c) 2010-2011 QUALCOMM Incorporated.
41 All Rights Reserved.
42 Qualcomm Confidential and Proprietary
43===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]44/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]45 EDIT HISTORY FOR FILE
46
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]47 This section contains comments describing changes made to the module.
48 Notice that changes are listed in reverse chronological order.
49
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]50 $Header$$DateTime$$Author$
51
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]52 when who what, where, why
53---------- --- -------------------------------------------------
5410/05/2011 haparna Adding support for Keep Alive Feature
552010-12-30 smiryala UMAC convergence changes
562010-08-19 adwivedi WLAN DAL AL(WDA) layer for Prima
57===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]58#include "vos_mq.h"
59#include "vos_api.h"
60#include "vos_packet.h"
61#include "vos_nvitem.h"
62#include "sirApi.h"
63#include "wlan_qct_pal_packet.h"
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]64#include "wlan_qct_pal_device.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]65#include "wlan_qct_wda.h"
66#include "wlan_qct_wda_msg.h"
67#include "wlan_qct_wdi_cfg.h"
68#include "wlan_qct_wdi.h"
69#include "wlan_qct_wdi_ds.h"
70#include "wlan_hal_cfg.h"
71/**********************/
72#include "wniApi.h"
73#include "cfgApi.h"
74#include "limApi.h"
75#include "wlan_qct_tl.h"
76#include "wlan_qct_tli_ba.h"
77#include "limUtils.h"
78#include "btcApi.h"
79#include "vos_sched.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]80#include "pttMsgApi.h"
81#include "wlan_qct_sys.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]82/* Used MACRO's */
83/* Get WDA context from vOSS module */
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]84#define WDA_2_4_GHZ_MAX_FREQ 3000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]85#define VOS_GET_WDA_CTXT(a) vos_get_context(VOS_MODULE_ID_WDA, a)
86#define VOS_GET_MAC_CTXT(a) vos_get_context(VOS_MODULE_ID_PE, a)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]87#define WDA_BA_TX_FRM_THRESHOLD (5)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]88#define CONVERT_WDI2SIR_STATUS(x) \
89 ((WDI_STATUS_SUCCESS != (x)) ? eSIR_FAILURE : eSIR_SUCCESS)
90
91#define IS_WDI_STATUS_FAILURE(status) \
92 ((WDI_STATUS_SUCCESS != (status)) && (WDI_STATUS_PENDING != (status)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]93#define CONVERT_WDI2VOS_STATUS(x) \
94 ((IS_WDI_STATUS_FAILURE(x)) ? VOS_STATUS_E_FAILURE : VOS_STATUS_SUCCESS)
95
96/* macro's for acessing TL API/data structures */
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]97#define WDA_TL_GET_STA_STATE(a, b, c) WLANTL_GetSTAState(a, b, c)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]98#define WDA_TL_GET_TX_PKTCOUNT(a, b, c, d) WLANTL_GetTxPktCount(a, b, c, d)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]99#define WDA_GET_BA_TXFLAG(a, b, c) \
100 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) & (1 << (c)))
101
102#define WDA_SET_BA_TXFLAG(a, b, c) \
103 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) |= (1 << (c)))
104
105#define WDA_CLEAR_BA_TXFLAG(a, b, c) \
106 (((a)->wdaStaInfo[b].ucUseBaBitmap) &= ~(1 << c))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]107#define WDA_TL_BA_SESSION_ADD(a, b, c, d, e, f, g) \
108 WLANTL_BaSessionAdd(a, b, c, d, e, f, g)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]109/* timer related Macros */
110#define WDA_CREATE_TIMER(a, b, c, d, e, f, g) \
111 tx_timer_create(a, b, c, d, e, f, g)
112#define WDA_START_TIMER(a) tx_timer_activate(a)
113#define WDA_STOP_TIMER(a) tx_timer_deactivate(a)
114#define WDA_DESTROY_TIMER(a) tx_timer_delete(a)
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]115#define WDA_WDI_START_TIMEOUT (WDI_RESPONSE_TIMEOUT + 5000)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]116
117#define WDA_LAST_POLLED_THRESHOLD(a, curSta, tid) \
118 ((a)->wdaStaInfo[curSta].framesTxed[tid] + WDA_BA_TX_FRM_THRESHOLD)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]119#define WDA_BA_MAX_WINSIZE (64)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]120#define WDA_INVALID_KEY_INDEX 0xFF
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]121#define WDA_NUM_PWR_SAVE_CFG 11
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]122#define WDA_TX_COMPLETE_TIME_OUT_VALUE 1000
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]123#define WDA_TRAFFIC_STATS_TIME_OUT_VALUE 1000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]124
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]125#define WDA_MAX_RETRIES_TILL_RING_EMPTY 1000 /* MAX 10000 msec = 10 seconds wait */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]126
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]127#define WDA_WAIT_MSEC_TILL_RING_EMPTY 10 /* 10 msec wait per cycle */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]128#define WDA_IS_NULL_MAC_ADDRESS(mac_addr) \
129 ((mac_addr[0] == 0x00) && (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) &&\
130 (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) && (mac_addr[3] == 0x00))
131
132#define WDA_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
133#define WDA_MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]134#define WDA_DUMPCMD_WAIT_TIMEOUT 10000
135
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]136/* extern declarations */
137extern void vos_WDAComplete_cback(v_PVOID_t pVosContext);
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]138extern wpt_uint8 WDI_GetActiveSessionsCount (void *pWDICtx, wpt_macAddr macBSSID, wpt_boolean skipBSSID);
139
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]140/* forward declarations */
141void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
142 void *pBodyptr, tANI_U32 bodyVal) ;
143VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
144 WDI_StartReqParamsType *wdiStartParams ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]145VOS_STATUS WDA_wdiCompleteCB(v_PVOID_t pVosContext) ;
146VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams);
147
148extern v_BOOL_t sys_validateStaConfig( void *pImage, unsigned long cbFile,
149 void **ppStaConfig, v_SIZE_t *pcbStaConfig ) ;
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]150void processCfgDownloadReq(tpAniSirGlobal pMac) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]151void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
152 WDI_ConfigBSSReqInfoType *wdiBssParams, tAddBssParams *wdaBssParams) ;
153void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
154 WDI_ConfigStaReqInfoType *wdiStaParams, tAddStaParams *wdaStaParams) ;
155void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
156 void* pUserData ) ;
157static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA) ;
158static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA);
159void WDA_BaCheckActivity(tWDA_CbContext *pWDA) ;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]160void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]161void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams, void* pUserData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]162#ifdef WLAN_FEATURE_VOWIFI_11R
163VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA, tAggrAddTsParams *pAggrAddTsReqParams);
164#endif /* WLAN_FEATURE_VOWIFI_11R */
165
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]166void WDA_TimerHandler(v_VOID_t *pWDA, tANI_U32 timerInfo) ;
167void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pContext) ;
168VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]169#ifdef FEATURE_WLAN_SCAN_PNO
170static VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA, tSirPNOScanReq *pPNOScanReqParams);
171static VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA, tSirSetRSSIFilterReq* pRssiFilterParams);
172static VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA, tSirUpdateScanParams *pUpdateScanParams);
173#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]174#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]175VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,tSirRoamOffloadScanReq *pRoamOffloadScanReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]176void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData);
177void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType);
178void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType);
179#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]180#ifdef WLAN_FEATURE_PACKET_FILTERING
181static VOS_STATUS WDA_Process8023MulticastListReq (
182 tWDA_CbContext *pWDA,
183 tSirRcvFltMcAddrList *pRcvFltMcAddrLis
184 );
185static VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (
186 tWDA_CbContext *pWDA,
187 tSirRcvPktFilterCfgType *pRcvPktFilterCfg
188 );
189static VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (
190 tWDA_CbContext *pWDA,
191 tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp
192 );
193static VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (
194 tWDA_CbContext *pWDA,
195 tSirRcvFltPktClearParam *pRcvFltPktClearParam
196 );
197#endif // WLAN_FEATURE_PACKET_FILTERING
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]198VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA, tSirSetPowerParamsReq *pPowerParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]199static VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
200 tpTxControlParams pTxCtrlParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]201VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
202 v_U8_t *pDefaultKeyId,
203 v_U8_t *pNumKeys,
204 WDI_KeysType *pWdiKeys );
205
206#ifdef WLAN_FEATURE_GTK_OFFLOAD
207static VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA, tpSirGtkOffloadParams pGtkOffloadParams);
208static VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA, tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp);
209#endif // WLAN_FEATURE_GTK_OFFLOAD
210
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]211v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
212 tSirBcnMissRateReq *pData);
213
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]214VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
215 tAniSetTmLevelReq *setTmLevelReq);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]216#ifdef WLAN_FEATURE_11AC
217VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
218 tUpdateVHTOpMode *pData);
219#endif
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]220
221#ifdef FEATURE_WLAN_LPHB
222VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
223 tSirLPHBReq *pData);
224#endif /* FEATURE_WLAN_LPHB */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]225
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]226#ifdef WLAN_FEATURE_EXTSCAN
227VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
228 tSirEXTScanStartReqParams *wdaRequest);
229VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
230 tSirEXTScanStopReqParams *wdaRequest);
231VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
232 tSirEXTScanGetCachedResultsReqParams *wdaRequest);
233VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
234 tSirGetEXTScanCapabilitiesReqParams *wdaRequest);
235VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
236 tSirEXTScanSetBssidHotListReqParams *wdaRequest);
237VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
238 tSirEXTScanResetBssidHotlistReqParams *wdaRequest);
239VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
240 tSirEXTScanSetSignificantChangeReqParams *wdaRequest);
241VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
242 tSirEXTScanResetSignificantChangeReqParams *wdaRequest);
243#endif /* WLAN_FEATURE_EXTSCAN */
244
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]245#ifdef WLAN_FEATURE_LINK_LAYER_STATS
246VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
247 tSirLLStatsSetReq *wdaRequest);
248
249VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
250 tSirLLStatsGetReq *wdaRequest);
251
252VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
253 tSirLLStatsClearReq *wdaRequest);
254#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]255/*
256 * FUNCTION: WDA_open
257 * Allocate the WDA context
258 */
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]259VOS_STATUS WDA_open(v_PVOID_t pVosContext, v_PVOID_t devHandle,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]260 tMacOpenParameters *pMacParams )
261{
262 tWDA_CbContext *wdaContext;
263 VOS_STATUS status;
264 WDI_DeviceCapabilityType wdiDevCapability = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]265 /* Allocate WDA context */
266 status = vos_alloc_context(pVosContext, VOS_MODULE_ID_WDA,
267 (v_VOID_t **)&wdaContext, sizeof(tWDA_CbContext)) ;
268 if(!VOS_IS_STATUS_SUCCESS(status))
269 {
270 return VOS_STATUS_E_NOMEM;
271 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]272 /*__asm int 3;*/
273 vos_mem_zero(wdaContext,sizeof(tWDA_CbContext));
274
275 /* Initialize data structures */
276 wdaContext->pVosContext = pVosContext;
277 wdaContext->wdaState = WDA_INIT_STATE;
278 wdaContext->uTxFlowMask = WDA_TXFLOWMASK;
279
280 /* Initialize WDA-WDI synchronization event */
281 status = vos_event_init(&wdaContext->wdaWdiEvent);
282 if(!VOS_IS_STATUS_SUCCESS(status))
283 {
284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]285 "WDI Sync Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]286 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]288 /* Init Frame transfer event */
289 status = vos_event_init(&wdaContext->txFrameEvent);
290 if(!VOS_IS_STATUS_SUCCESS(status))
291 {
292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]293 "VOS Mgmt Frame Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]294 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]295 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]296 status = vos_event_init(&wdaContext->suspendDataTxEvent);
297 if(!VOS_IS_STATUS_SUCCESS(status))
298 {
299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]300 "VOS suspend data tx Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]301 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]302 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]303 status = vos_event_init(&wdaContext->waitOnWdiIndicationCallBack);
304 if(!VOS_IS_STATUS_SUCCESS(status))
305 {
306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]307 "VOS wait On Wdi Ind Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]308 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]309 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]310 vos_trace_setLevel(VOS_MODULE_ID_WDA,VOS_TRACE_LEVEL_ERROR);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]311 wdaContext->driverMode = pMacParams->driverType;
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]312 if(WDI_STATUS_SUCCESS != WDI_Init(devHandle, &wdaContext->pWdiContext,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]313 &wdiDevCapability, pMacParams->driverType))
314 {
315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
316 "WDI Init failed" );
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]317 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]318 }
319 else
320 {
321 pMacParams->maxStation = wdiDevCapability.ucMaxSTASupported ;
322 pMacParams->maxBssId = wdiDevCapability.ucMaxBSSSupported;
323 pMacParams->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]324 /* update max STA in WDA used for BA */
325 wdaContext->wdaMaxSta = pMacParams->maxStation;
326 /* store the frameTransRequired flag in wdaContext, to send this to HAL
327 * in WDA_Start
328 */
329 wdaContext->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
330 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]331 return status;
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]332
333error:
334 vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
335 return VOS_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]336}
337
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]338/*
339 * FUNCTION: WDA_preStart
340 * Trigger DAL-AL to start CFG download
341 */
342VOS_STATUS WDA_preStart(v_PVOID_t pVosContext)
343{
344 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
345 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]346 /*
347 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
348 */
349 wdaMsg.type = WNI_CFG_DNLD_REQ ;
350 wdaMsg.bodyptr = NULL;
351 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]352 /* post the message.. */
353 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
354 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
355 {
356 vosStatus = VOS_STATUS_E_BADMSG;
357 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]358 return( vosStatus );
359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]360/*
361 * FUNCTION: WDA_wdiStartCallback
362 * Once WDI_Start is finished, WDI start callback will be called by WDI
363 * to indicate completion of WDI_Start.
364 */
365void WDA_wdiStartCallback(WDI_StartRspParamsType *wdiRspParams,
366 void *pVosContext)
367{
368 tWDA_CbContext *wdaContext;
369 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]370 if (NULL == pVosContext)
371 {
372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]373 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]374 return;
375 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]376 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
377 if (NULL == wdaContext)
378 {
379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]380 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]381 return;
382 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]383 if (WDI_STATUS_SUCCESS != wdiRspParams->wdiStatus)
384 {
385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]386 "%s: WDI_Start() failure reported", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]387 }
388 else
389 {
390 wdaContext->wdaState = WDA_START_STATE;
391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]392 /* extract and save version information from the Start Response */
393 wdaContext->wcnssWlanCompiledVersion.major =
394 wdiRspParams->wlanCompiledVersion.major;
395 wdaContext->wcnssWlanCompiledVersion.minor =
396 wdiRspParams->wlanCompiledVersion.minor;
397 wdaContext->wcnssWlanCompiledVersion.version =
398 wdiRspParams->wlanCompiledVersion.version;
399 wdaContext->wcnssWlanCompiledVersion.revision =
400 wdiRspParams->wlanCompiledVersion.revision;
401 wdaContext->wcnssWlanReportedVersion.major =
402 wdiRspParams->wlanReportedVersion.major;
403 wdaContext->wcnssWlanReportedVersion.minor =
404 wdiRspParams->wlanReportedVersion.minor;
405 wdaContext->wcnssWlanReportedVersion.version =
406 wdiRspParams->wlanReportedVersion.version;
407 wdaContext->wcnssWlanReportedVersion.revision =
408 wdiRspParams->wlanReportedVersion.revision;
409 wpalMemoryCopy(wdaContext->wcnssSoftwareVersionString,
410 wdiRspParams->wcnssSoftwareVersion,
411 sizeof(wdaContext->wcnssSoftwareVersionString));
412 wpalMemoryCopy(wdaContext->wcnssHardwareVersionString,
413 wdiRspParams->wcnssHardwareVersion,
414 sizeof(wdaContext->wcnssHardwareVersionString));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]415 /* Notify WDA_start that WDI_Start has completed */
416 status = vos_event_set(&wdaContext->wdaWdiEvent);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]417 if (VOS_STATUS_SUCCESS != status)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]418 {
419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]420 "%s: Unable to unblock WDA_start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]421 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]422 return;
423}
424
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]425/*
426 * FUNCTION: WDA_start
427 * Prepare TLV configuration and call WDI_Start.
428 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]429VOS_STATUS WDA_start(v_PVOID_t pVosContext)
430{
431 tWDA_CbContext *wdaContext;
432 VOS_STATUS status;
433 WDI_Status wdiStatus;
434 WDI_StartReqParamsType wdiStartParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]435 if (NULL == pVosContext)
436 {
437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]438 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]439 return VOS_STATUS_E_FAILURE;
440 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]441 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
442 if (NULL == wdaContext)
443 {
444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]445 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]446 return VOS_STATUS_E_FAILURE;
447 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]448 /* Non-FTM mode, WDA status for START must be INIT
449 * FTM mode, WDA Status for START can be INIT or STOP */
450 if ( (WDA_INIT_STATE != wdaContext->wdaState) &&
451 (WDA_STOP_STATE != wdaContext->wdaState) )
452 {
453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
454 "%s: Invoked from wrong state %d",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]455 __func__, wdaContext->wdaState );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]456 return VOS_STATUS_E_FAILURE;
457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]458 /* initialize the wdiStartParam. Note that we can create this on
459 the stack since we won't exit until WDI_Start() completes or
460 times out */
461 vos_mem_set(&wdiStartParam, sizeof(wdiStartParam), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]462 wdiStartParam.wdiDriverType = wdaContext->driverMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]463 /* prepare the config TLV for the WDI */
464 status = WDA_prepareConfigTLV(pVosContext, &wdiStartParam);
465 if ( !VOS_IS_STATUS_SUCCESS(status) )
466 {
467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]468 "%s: Unable to prepare Config TLV", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]469 return VOS_STATUS_E_FAILURE;
470 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]471 /* note from here onwards if an error occurs we must
472 reclaim the config TLV buffer */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]473 wdiStartParam.wdiLowLevelIndCB = WDA_lowLevelIndCallback;
474 wdiStartParam.pIndUserData = (v_PVOID_t *)wdaContext;
475 wdiStartParam.wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]476 /* initialize the WDA-WDI synchronization event */
477 vos_event_reset(&wdaContext->wdaWdiEvent);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]478 /* call WDI start */
479 wdiStatus = WDI_Start(&wdiStartParam,
480 (WDI_StartRspCb)WDA_wdiStartCallback,
481 (v_VOID_t *)pVosContext);
482 if ( IS_WDI_STATUS_FAILURE(wdiStatus) )
483 {
484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]485 "%s: WDI Start failed", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]486 vos_mem_free(wdiStartParam.pConfigBuffer);
487 return VOS_STATUS_E_FAILURE;
488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]489 /* wait for WDI start to invoke our callback */
490 status = vos_wait_single_event( &wdaContext->wdaWdiEvent,
491 WDA_WDI_START_TIMEOUT );
492 if ( !VOS_IS_STATUS_SUCCESS(status) )
493 {
494 if ( VOS_STATUS_E_TIMEOUT == status )
495 {
496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]497 "%s: Timeout occurred during WDI_Start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]498 }
499 else
500 {
501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
502 "%s: Error %d while waiting for WDI_Start",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]503 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]504 }
505 vos_mem_free(wdiStartParam.pConfigBuffer);
506 return VOS_STATUS_E_FAILURE;
507 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]508 /* WDI_Start() has completed so we can resume our work */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]509 /* we no longer need the config TLV */
510 vos_mem_free(wdiStartParam.pConfigBuffer);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]511 /* if we are not in the START state then WDI_Start() failed */
512 if (WDA_START_STATE != wdaContext->wdaState)
513 {
514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]515 "%s: WDI_Start() failure detected", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]516 return VOS_STATUS_E_FAILURE;
517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]518 /* FTM mode does not need to monitor BA activity */
519 if ( eDRIVER_TYPE_MFG != wdaContext->driverMode )
520 {
521 status = wdaCreateTimers(wdaContext) ;
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]522 if(VOS_STATUS_SUCCESS == status)
523 {
524 wdaContext->wdaTimersCreated = VOS_TRUE;
525 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]526 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]527 else
528 {
529 vos_event_init(&wdaContext->ftmStopDoneEvent);
530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]531 return status;
532}
533
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]534/*
535 * FUNCTION: WDA_prepareConfigTLV
536 * Function to prepare CFG for DAL(WDA)
537 */
538VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
539 WDI_StartReqParamsType *wdiStartParams )
540{
541 /* get pMac to acess CFG data base */
542 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
543 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
544 tHalCfg *tlvStruct = NULL ;
545 tANI_U8 *tlvStructStart = NULL ;
546 tANI_U32 strLength = WNI_CFG_STA_ID_LEN;
547 v_PVOID_t *configParam;
548 tANI_U32 configParamSize;
549 tANI_U32 *configDataValue;
550 WDI_WlanVersionType wcnssCompiledApiVersion;
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]551 tANI_U8 i;
552
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]553 if ((NULL == pMac)||(NULL == wdaContext))
554 {
555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]556 "%s: Invoked with invalid wdaContext or pMac", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]557 VOS_ASSERT(0);
558 return VOS_STATUS_E_FAILURE;
559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]560 configParamSize = (sizeof(tHalCfg) * QWLAN_HAL_CFG_MAX_PARAMS) +
561 WNI_CFG_STA_ID_LEN +
562 WNI_CFG_EDCA_WME_ACBK_LEN +
563 WNI_CFG_EDCA_WME_ACBE_LEN +
564 WNI_CFG_EDCA_WME_ACVI_LEN +
565 WNI_CFG_EDCA_WME_ACVO_LEN +
566 + (QWLAN_HAL_CFG_INTEGER_PARAM * sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]567 /* malloc memory for all configs in one shot */
568 configParam = vos_mem_malloc(configParamSize);
569
570 if(NULL == configParam )
571 {
572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]573 "%s:configParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]574 VOS_ASSERT(0) ;
575 return VOS_STATUS_E_NOMEM;
576 }
577 vos_mem_set(configParam, configParamSize, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]578 wdiStartParams->pConfigBuffer = configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]579 tlvStruct = (tHalCfg *)configParam;
580 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]581 /* TODO: Remove Later */
582 /* QWLAN_HAL_CFG_STA_ID */
583 tlvStruct->type = QWLAN_HAL_CFG_STA_ID;
584 configDataValue = (tANI_U32*)((tANI_U8 *) tlvStruct + sizeof(tHalCfg));
585 if(wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8*)configDataValue, &strLength) !=
586 eSIR_SUCCESS)
587 {
588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
589 "Failed to get value for WNI_CFG_STA_ID");
590 goto handle_failure;
591 }
592 tlvStruct->length = strLength ;
593 /* calculate the pad bytes to have the CFG in aligned format */
594 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
595 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]596 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
597 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]598 /* QWLAN_HAL_CFG_CURRENT_TX_ANTENNA */
599 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
600 tlvStruct->length = sizeof(tANI_U32);
601 configDataValue = (tANI_U32 *)(tlvStruct + 1);
602 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_TX_ANTENNA, configDataValue )
603 != eSIR_SUCCESS)
604 {
605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
606 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
607 goto handle_failure;
608 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]609 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
610 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]611 /* QWLAN_HAL_CFG_CURRENT_RX_ANTENNA */
612 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
613 tlvStruct->length = sizeof(tANI_U32);
614 configDataValue = (tANI_U32 *)(tlvStruct + 1);
615 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_RX_ANTENNA, configDataValue) !=
616 eSIR_SUCCESS)
617 {
618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
619 "Failed to get value for WNI_CFG_CURRENT_RX_ANTENNA");
620 goto handle_failure;
621 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]622 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
623 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]624 /* QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE */
625 tlvStruct->type = QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
626 tlvStruct->length = sizeof(tANI_U32);
627 configDataValue = (tANI_U32 *)(tlvStruct + 1);
628 if(wlan_cfgGetInt(pMac, WNI_CFG_LOW_GAIN_OVERRIDE, configDataValue )
629 != eSIR_SUCCESS)
630 {
631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
632 "Failed to get value for WNI_CFG_LOW_GAIN_OVERRIDE");
633 goto handle_failure;
634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]635 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
636 + sizeof(tHalCfg) + tlvStruct->length)) ;
637
638 /* QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN */
639 tlvStruct->type = QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
640 tlvStruct->length = sizeof(tANI_U32);
641 configDataValue = (tANI_U32 *)(tlvStruct + 1);
642 if(wlan_cfgGetInt(pMac, WNI_CFG_POWER_STATE_PER_CHAIN,
643 configDataValue ) != eSIR_SUCCESS)
644 {
645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
646 "Failed to get value for WNI_CFG_POWER_STATE_PER_CHAIN");
647 goto handle_failure;
648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]649 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
650 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]651 /* QWLAN_HAL_CFG_CAL_PERIOD */
652 tlvStruct->type = QWLAN_HAL_CFG_CAL_PERIOD;
653 tlvStruct->length = sizeof(tANI_U32);
654 configDataValue = (tANI_U32 *)(tlvStruct + 1);
655 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_PERIOD, configDataValue )
656 != eSIR_SUCCESS)
657 {
658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
659 "Failed to get value for WNI_CFG_CAL_PERIOD");
660 goto handle_failure;
661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]662 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
663 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]664 /* QWLAN_HAL_CFG_CAL_CONTROL */
665 tlvStruct->type = QWLAN_HAL_CFG_CAL_CONTROL ;
666 tlvStruct->length = sizeof(tANI_U32);
667 configDataValue = (tANI_U32 *)(tlvStruct + 1);
668 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_CONTROL, configDataValue )
669 != eSIR_SUCCESS)
670 {
671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
672 "Failed to get value for WNI_CFG_CAL_CONTROL");
673 goto handle_failure;
674 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]675 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
676 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]677 /* QWLAN_HAL_CFG_PROXIMITY */
678 tlvStruct->type = QWLAN_HAL_CFG_PROXIMITY ;
679 tlvStruct->length = sizeof(tANI_U32);
680 configDataValue = (tANI_U32 *)(tlvStruct + 1);
681 if(wlan_cfgGetInt(pMac, WNI_CFG_PROXIMITY, configDataValue )
682 != eSIR_SUCCESS)
683 {
684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
685 "Failed to get value for WNI_CFG_PROXIMITY");
686 goto handle_failure;
687 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]688 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
689 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]690 /* QWLAN_HAL_CFG_NETWORK_DENSITY */
691 tlvStruct->type = QWLAN_HAL_CFG_NETWORK_DENSITY ;
692 tlvStruct->length = sizeof(tANI_U32);
693 configDataValue = (tANI_U32 *)(tlvStruct + 1);
694 if(wlan_cfgGetInt(pMac, WNI_CFG_NETWORK_DENSITY, configDataValue )
695 != eSIR_SUCCESS)
696 {
697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
698 "Failed to get value for WNI_CFG_NETWORK_DENSITY");
699 goto handle_failure;
700 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]701 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
702 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]703 /* QWLAN_HAL_CFG_MAX_MEDIUM_TIME */
704 tlvStruct->type = QWLAN_HAL_CFG_MAX_MEDIUM_TIME ;
705 tlvStruct->length = sizeof(tANI_U32);
706 configDataValue = (tANI_U32 *)(tlvStruct + 1);
707 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MEDIUM_TIME, configDataValue ) !=
708 eSIR_SUCCESS)
709 {
710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
711 "Failed to get value for WNI_CFG_MAX_MEDIUM_TIME");
712 goto handle_failure;
713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]714 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
715 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]716 /* QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU */
717 tlvStruct->type = QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU ;
718 tlvStruct->length = sizeof(tANI_U32);
719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
720 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MPDUS_IN_AMPDU,
721 configDataValue ) != eSIR_SUCCESS)
722 {
723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
724 "Failed to get value for WNI_CFG_MAX_MPDUS_IN_AMPDU");
725 goto handle_failure;
726 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]727 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
728 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]729 /* QWLAN_HAL_CFG_RTS_THRESHOLD */
730 tlvStruct->type = QWLAN_HAL_CFG_RTS_THRESHOLD ;
731 tlvStruct->length = sizeof(tANI_U32);
732 configDataValue = (tANI_U32 *)(tlvStruct + 1);
733 if(wlan_cfgGetInt(pMac, WNI_CFG_RTS_THRESHOLD, configDataValue ) !=
734 eSIR_SUCCESS)
735 {
736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
737 "Failed to get value for WNI_CFG_RTS_THRESHOLD");
738 goto handle_failure;
739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]740 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
741 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]742 /* QWLAN_HAL_CFG_SHORT_RETRY_LIMIT */
743 tlvStruct->type = QWLAN_HAL_CFG_SHORT_RETRY_LIMIT ;
744 tlvStruct->length = sizeof(tANI_U32);
745 configDataValue = (tANI_U32 *)(tlvStruct + 1);
746 if(wlan_cfgGetInt(pMac, WNI_CFG_SHORT_RETRY_LIMIT, configDataValue ) !=
747 eSIR_SUCCESS)
748 {
749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
750 "Failed to get value for WNI_CFG_SHORT_RETRY_LIMIT");
751 goto handle_failure;
752 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]753 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
754 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]755 /* QWLAN_HAL_CFG_LONG_RETRY_LIMIT */
756 tlvStruct->type = QWLAN_HAL_CFG_LONG_RETRY_LIMIT ;
757 tlvStruct->length = sizeof(tANI_U32);
758 configDataValue = (tANI_U32 *)(tlvStruct + 1);
759 if(wlan_cfgGetInt(pMac, WNI_CFG_LONG_RETRY_LIMIT, configDataValue ) !=
760 eSIR_SUCCESS)
761 {
762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
763 "Failed to get value for WNI_CFG_LONG_RETRY_LIMIT");
764 goto handle_failure;
765 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]766 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
767 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]768 /* QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD */
769 tlvStruct->type = QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD ;
770 tlvStruct->length = sizeof(tANI_U32);
771 configDataValue = (tANI_U32 *)(tlvStruct + 1);
772 if(wlan_cfgGetInt(pMac, WNI_CFG_FRAGMENTATION_THRESHOLD,
773 configDataValue ) != eSIR_SUCCESS)
774 {
775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
776 "Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD");
777 goto handle_failure;
778 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]779 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
780 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]781 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO */
782 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO ;
783 tlvStruct->length = sizeof(tANI_U32);
784 configDataValue = (tANI_U32 *)(tlvStruct + 1);
785 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ZERO,
786 configDataValue ) != eSIR_SUCCESS)
787 {
788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
789 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ZERO");
790 goto handle_failure;
791 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]792 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
793 + sizeof(tHalCfg) + tlvStruct->length));
794
795 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE */
796 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE ;
797 tlvStruct->length = sizeof(tANI_U32);
798 configDataValue = (tANI_U32 *)(tlvStruct + 1);
799 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ONE,
800 configDataValue ) != eSIR_SUCCESS)
801 {
802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
803 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ONE");
804 goto handle_failure;
805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]806 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
807 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]808 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO */
809 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO ;
810 tlvStruct->length = sizeof(tANI_U32);
811 configDataValue = (tANI_U32 *)(tlvStruct + 1);
812 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_TWO,
813 configDataValue ) != eSIR_SUCCESS)
814 {
815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
816 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_TWO");
817 goto handle_failure;
818 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]819 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
820 + sizeof(tHalCfg) + tlvStruct->length));
821
822 /* QWLAN_HAL_CFG_FIXED_RATE */
823 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE ;
824 tlvStruct->length = sizeof(tANI_U32);
825 configDataValue = (tANI_U32 *)(tlvStruct + 1);
826 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE, configDataValue)
827 != eSIR_SUCCESS)
828 {
829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
830 "Failed to get value for WNI_CFG_FIXED_RATE");
831 goto handle_failure;
832 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]833 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
834 + sizeof(tHalCfg) + tlvStruct->length));
835
836 /* QWLAN_HAL_CFG_RETRYRATE_POLICY */
837 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_POLICY ;
838 tlvStruct->length = sizeof(tANI_U32);
839 configDataValue = (tANI_U32 *)(tlvStruct + 1);
840 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_POLICY, configDataValue )
841 != eSIR_SUCCESS)
842 {
843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
844 "Failed to get value for WNI_CFG_RETRYRATE_POLICY");
845 goto handle_failure;
846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]847 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
848 + sizeof(tHalCfg) + tlvStruct->length));
849
850 /* QWLAN_HAL_CFG_RETRYRATE_SECONDARY */
851 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_SECONDARY ;
852 tlvStruct->length = sizeof(tANI_U32);
853 configDataValue = (tANI_U32 *)(tlvStruct + 1);
854 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_SECONDARY,
855 configDataValue ) != eSIR_SUCCESS)
856 {
857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
858 "Failed to get value for WNI_CFG_RETRYRATE_SECONDARY");
859 goto handle_failure;
860 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]861 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
862 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]863 /* QWLAN_HAL_CFG_RETRYRATE_TERTIARY */
864 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_TERTIARY ;
865 tlvStruct->length = sizeof(tANI_U32);
866 configDataValue = (tANI_U32 *)(tlvStruct + 1);
867 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_TERTIARY,
868 configDataValue ) != eSIR_SUCCESS)
869 {
870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
871 "Failed to get value for WNI_CFG_RETRYRATE_TERTIARY");
872 goto handle_failure;
873 }
874 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
875 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]876 /* QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION */
877 tlvStruct->type = QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION ;
878 tlvStruct->length = sizeof(tANI_U32);
879 configDataValue = (tANI_U32 *)(tlvStruct + 1);
880 if(wlan_cfgGetInt(pMac, WNI_CFG_FORCE_POLICY_PROTECTION,
881 configDataValue ) != eSIR_SUCCESS)
882 {
883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
884 "Failed to get value for WNI_CFG_FORCE_POLICY_PROTECTION");
885 goto handle_failure;
886 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]887 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
888 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]889 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ */
890 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ ;
891 tlvStruct->length = sizeof(tANI_U32);
892 configDataValue = (tANI_U32 *)(tlvStruct + 1);
893 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_24GHZ,
894 configDataValue ) != eSIR_SUCCESS)
895 {
896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
897 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_24GHZ");
898 goto handle_failure;
899 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
901 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]902 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ */
903 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ ;
904 tlvStruct->length = sizeof(tANI_U32);
905 configDataValue = (tANI_U32 *)(tlvStruct + 1);
906 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_5GHZ,
907 configDataValue ) != eSIR_SUCCESS)
908 {
909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
910 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_5GHZ");
911 goto handle_failure;
912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]913 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
914 + sizeof(tHalCfg) + tlvStruct->length);
915
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]916 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ */
917 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ ;
918 tlvStruct->length = sizeof(tANI_U32);
919 configDataValue = (tANI_U32 *)(tlvStruct + 1);
920 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_24GHZ,
921 configDataValue ) != eSIR_SUCCESS)
922 {
923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
924 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_24GHZ");
925 goto handle_failure;
926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]927 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
928 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]929 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ */
930 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ ;
931 tlvStruct->length = sizeof(tANI_U32);
932 configDataValue = (tANI_U32 *)(tlvStruct + 1);
933 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_5GHZ,
934 configDataValue ) != eSIR_SUCCESS)
935 {
936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
937 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_5GHZ");
938 goto handle_failure;
939 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]940 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
941 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]942 /* QWLAN_HAL_CFG_MAX_BA_SESSIONS */
943 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_SESSIONS ;
944 tlvStruct->length = sizeof(tANI_U32);
945 configDataValue = (tANI_U32 *)(tlvStruct + 1);
946 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_SESSIONS, configDataValue ) !=
947 eSIR_SUCCESS)
948 {
949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
950 "Failed to get value for WNI_CFG_MAX_BA_SESSIONS");
951 goto handle_failure;
952 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]953 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
954 + sizeof(tHalCfg) + tlvStruct->length);
955
956 /* QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT */
957 tlvStruct->type = QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT ;
958 tlvStruct->length = sizeof(tANI_U32);
959 configDataValue = (tANI_U32 *)(tlvStruct + 1);
960 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
961 configDataValue ) != eSIR_SUCCESS)
962 {
963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
964 "Failed to get value for WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
965 goto handle_failure;
966 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]967 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
968 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]969 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER */
970 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER ;
971 tlvStruct->length = sizeof(tANI_U32);
972 configDataValue = (tANI_U32 *)(tlvStruct + 1);
973 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_BCN_FILTER,
974 configDataValue ) != eSIR_SUCCESS)
975 {
976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
977 "Failed to get value for WNI_CFG_PS_ENABLE_BCN_FILTER");
978 goto handle_failure;
979 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]980 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
981 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]982 /* QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR */
983 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR ;
984 tlvStruct->length = sizeof(tANI_U32);
985 configDataValue = (tANI_U32 *)(tlvStruct + 1);
986 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_RSSI_MONITOR,
987 configDataValue ) != eSIR_SUCCESS)
988 {
989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
990 "Failed to get value for WNI_CFG_PS_ENABLE_RSSI_MONITOR");
991 goto handle_failure;
992 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]993 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
994 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]995 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
996 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE ;
997 tlvStruct->length = sizeof(tANI_U32);
998 configDataValue = (tANI_U32 *)(tlvStruct + 1);
999 if(wlan_cfgGetInt(pMac, WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE,
1000 configDataValue ) != eSIR_SUCCESS)
1001 {
1002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1003 "Failed to get value for WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE");
1004 goto handle_failure;
1005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1006 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1007 + sizeof(tHalCfg) + tlvStruct->length);
1008
1009 /* QWLAN_HAL_CFG_STATS_PERIOD */
1010 tlvStruct->type = QWLAN_HAL_CFG_STATS_PERIOD ;
1011 tlvStruct->length = sizeof(tANI_U32);
1012 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1013 if(wlan_cfgGetInt(pMac, WNI_CFG_STATS_PERIOD, configDataValue ) !=
1014 eSIR_SUCCESS)
1015 {
1016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1017 "Failed to get value for WNI_CFG_STATS_PERIOD");
1018 goto handle_failure;
1019 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1021 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1022 /* QWLAN_HAL_CFG_CFP_MAX_DURATION */
1023 tlvStruct->type = QWLAN_HAL_CFG_CFP_MAX_DURATION ;
1024 tlvStruct->length = sizeof(tANI_U32);
1025 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1026 if(wlan_cfgGetInt(pMac, WNI_CFG_CFP_MAX_DURATION, configDataValue ) !=
1027 eSIR_SUCCESS)
1028 {
1029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1030 "Failed to get value for WNI_CFG_CFP_MAX_DURATION");
1031 goto handle_failure;
1032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1033 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1034 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1035 /* QWLAN_HAL_CFG_FRAME_TRANS_ENABLED */
1036 tlvStruct->type = QWLAN_HAL_CFG_FRAME_TRANS_ENABLED ;
1037 tlvStruct->length = sizeof(tANI_U32);
1038 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1039 vos_mem_copy(configDataValue, &wdaContext->frameTransRequired,
1040 sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1041 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1042 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1043 /* QWLAN_HAL_CFG_DTIM_PERIOD */
1044 tlvStruct->type = QWLAN_HAL_CFG_DTIM_PERIOD ;
1045 tlvStruct->length = sizeof(tANI_U32);
1046 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1047 if(wlan_cfgGetInt(pMac, WNI_CFG_DTIM_PERIOD, configDataValue)
1048 != eSIR_SUCCESS)
1049 {
1050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1051 "Failed to get value for WNI_CFG_DTIM_PERIOD");
1052 goto handle_failure;
1053 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1054 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1055 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1056 /* QWLAN_HAL_CFG_EDCA_WMM_ACBK */
1057 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBK ;
1058 strLength = WNI_CFG_EDCA_WME_ACBK_LEN;
1059 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1060 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBK, (tANI_U8 *)configDataValue,
1061 &strLength) != eSIR_SUCCESS)
1062 {
1063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1064 "Failed to get value for WNI_CFG_EDCA_WME_ACBK");
1065 goto handle_failure;
1066 }
1067 tlvStruct->length = strLength;
1068 /* calculate the pad bytes to have the CFG in aligned format */
1069 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1070 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1071 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1072 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1073 /* QWLAN_HAL_CFG_EDCA_WMM_ACBE */
1074 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBE ;
1075 strLength = WNI_CFG_EDCA_WME_ACBE_LEN;
1076 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1077 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBE, (tANI_U8 *)configDataValue,
1078 &strLength) != eSIR_SUCCESS)
1079 {
1080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1081 "Failed to get value for WNI_CFG_EDCA_WME_ACBE");
1082 goto handle_failure;
1083 }
1084 tlvStruct->length = strLength;
1085 /* calculate the pad bytes to have the CFG in aligned format */
1086 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1087 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1088 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1089 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1090 /* QWLAN_HAL_CFG_EDCA_WMM_ACVI */
1091 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVO ;
1092 strLength = WNI_CFG_EDCA_WME_ACVI_LEN;
1093 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1094 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVO, (tANI_U8 *)configDataValue,
1095 &strLength) != eSIR_SUCCESS)
1096 {
1097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1098 "Failed to get value for WNI_CFG_EDCA_WME_ACVI");
1099 goto handle_failure;
1100 }
1101 tlvStruct->length = strLength;
1102 /* calculate the pad bytes to have the CFG in aligned format */
1103 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1104 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1105 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1106 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1107 /* QWLAN_HAL_CFG_EDCA_WMM_ACVO */
1108 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVI ;
1109 strLength = WNI_CFG_EDCA_WME_ACVO_LEN;
1110 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1111 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVI, (tANI_U8 *)configDataValue,
1112 &strLength) != eSIR_SUCCESS)
1113 {
1114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1115 "Failed to get value for WNI_CFG_EDCA_WME_ACVO");
1116 goto handle_failure;
1117 }
1118 tlvStruct->length = strLength;
1119 /* calculate the pad bytes to have the CFG in aligned format */
1120 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1121 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1122 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1123 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1124 /* QWLAN_HAL_CFG_BA_THRESHOLD_HIGH */
1125 tlvStruct->type = QWLAN_HAL_CFG_BA_THRESHOLD_HIGH ;
1126 tlvStruct->length = sizeof(tANI_U32);
1127 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1128 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_THRESHOLD_HIGH, configDataValue)
1129 != eSIR_SUCCESS)
1130 {
1131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1132 "Failed to get value for WNI_CFG_BA_THRESHOLD_HIGH");
1133 goto handle_failure;
1134 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1135 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1136 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1137 /* QWLAN_HAL_CFG_MAX_BA_BUFFERS */
1138 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_BUFFERS ;
1139 tlvStruct->length = sizeof(tANI_U32);
1140 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1141 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_BUFFERS, configDataValue)
1142 != eSIR_SUCCESS)
1143 {
1144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1145 "Failed to get value for WNI_CFG_MAX_BA_BUFFERS");
1146 goto handle_failure;
1147 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1148 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1149 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1150 /* QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE */
1151 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE ;
1152 tlvStruct->length = sizeof(tANI_U32);
1153 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1154 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_PS_POLL_VALUE, configDataValue)
1155 != eSIR_SUCCESS)
1156 {
1157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1158 "Failed to get value for WNI_CFG_DYNAMIC_PS_POLL_VALUE");
1159 goto handle_failure;
1160 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1161 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1162 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1163 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI */
1164 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI ;
1165 tlvStruct->length = sizeof(tANI_U32);
1166 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1167 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI, configDataValue)
1168 != eSIR_SUCCESS)
1169 {
1170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1171 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI");
1172 goto handle_failure;
1173 }
1174 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1175 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1176 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS */
1177 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS ;
1178 tlvStruct->length = sizeof(tANI_U32);
1179 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1180 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, configDataValue)
1181 != eSIR_SUCCESS)
1182 {
1183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1184 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS");
1185 goto handle_failure;
1186 }
1187 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1188 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1189 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI */
1190 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI ;
1191 tlvStruct->length = sizeof(tANI_U32);
1192 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1193 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI, configDataValue)
1194 != eSIR_SUCCESS)
1195 {
1196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1197 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI");
1198 goto handle_failure;
1199 }
1200 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1201 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1202 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS */
1203 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS ;
1204 tlvStruct->length = sizeof(tANI_U32);
1205 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1206 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, configDataValue)
1207 != eSIR_SUCCESS)
1208 {
1209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1210 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS");
1211 goto handle_failure;
1212 }
1213 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1214 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1215 /* QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN */
1216 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN ;
1217 tlvStruct->length = sizeof(tANI_U32);
1218 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1219 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_WAKEUP_EN, configDataValue)
1220 != eSIR_SUCCESS)
1221 {
1222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1223 "Failed to get value for WNI_CFG_TELE_BCN_WAKEUP_EN");
1224 goto handle_failure;
1225 }
1226 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1227 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1228 /* QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD */
1229 tlvStruct->type = QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD ;
1230 tlvStruct->length = sizeof(tANI_U32);
1231 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1232 if(wlan_cfgGetInt(pMac, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, configDataValue)
1233 != eSIR_SUCCESS)
1234 {
1235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1236 "Failed to get value for WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD");
1237 goto handle_failure;
1238 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1239 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1240 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1241 /*QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE*/
1242 tlvStruct->type = QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE ;
1243 tlvStruct->length = sizeof(tANI_U32);
1244 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1245 if(wlan_cfgGetInt(pMac, WNI_CFG_TX_PWR_CTRL_ENABLE, configDataValue)
1246 != eSIR_SUCCESS)
1247 {
1248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1249 "Failed to get value for WNI_CFG_TX_PWR_CTRL_ENABLE");
1250 goto handle_failure;
1251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1252 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1253 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1254 /* QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP */
1255 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP ;
1256 tlvStruct->length = sizeof(tANI_U32);
1257 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1258 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_CLOSE_LOOP, configDataValue)
1259 != eSIR_SUCCESS)
1260 {
1261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1262 "Failed to get value for WNI_CFG_ENABLE_CLOSE_LOOP");
1263 goto handle_failure;
1264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1265 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1266 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1267 /* [COEX] strictly speaking, the Coex parameters are not part of the WLAN_CFG_FILE binary,
1268 * but are from the WLAN_INI_FILE file. However, this is the only parameter download routine
1269 * into FW, so the parameters are added here.
1270 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1271 /* [COEX] QWLAN_HAL_CFG_BTC_EXECUTION_MODE */
1272 tlvStruct->type = QWLAN_HAL_CFG_BTC_EXECUTION_MODE ;
1273 tlvStruct->length = sizeof(tANI_U32);
1274 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1275 *configDataValue = pMac->btc.btcConfig.btcExecutionMode;
1276 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1277 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1278 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK */
1279 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK ;
1280 tlvStruct->length = sizeof(tANI_U32);
1281 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1282 *configDataValue = pMac->btc.btcConfig.btcConsBtSlotsToBlockDuringDhcp;
1283 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1284 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1285 /* [COEX] QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS */
1286 tlvStruct->type = QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS ;
1287 tlvStruct->length = sizeof(tANI_U32);
1288 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1289 *configDataValue = pMac->btc.btcConfig.btcA2DPBtSubIntervalsDuringDhcp;
1290 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1291 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1292 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT */
1293 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT ;
1294 tlvStruct->length = sizeof(tANI_U32);
1295 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1296 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqBt;
1297 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1298 + sizeof(tHalCfg) + tlvStruct->length) ;
1299
1300 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT */
1301 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT ;
1302 tlvStruct->length = sizeof(tANI_U32);
1303 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1304 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageBt;
1305 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1306 + sizeof(tHalCfg) + tlvStruct->length) ;
1307
1308 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT */
1309 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT ;
1310 tlvStruct->length = sizeof(tANI_U32);
1311 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1312 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnBt;
1313 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1314 + sizeof(tHalCfg) + tlvStruct->length) ;
1315
1316 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT */
1317 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT ;
1318 tlvStruct->length = sizeof(tANI_U32);
1319 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1320 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeBt;
1321 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1322 + sizeof(tHalCfg) + tlvStruct->length) ;
1323
1324 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN */
1325 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN ;
1326 tlvStruct->length = sizeof(tANI_U32);
1327 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1328 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqWlan;
1329 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1330 + sizeof(tHalCfg) + tlvStruct->length) ;
1331
1332 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN */
1333 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN ;
1334 tlvStruct->length = sizeof(tANI_U32);
1335 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1336 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageWlan;
1337 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1338 + sizeof(tHalCfg) + tlvStruct->length) ;
1339
1340 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN */
1341 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN ;
1342 tlvStruct->length = sizeof(tANI_U32);
1343 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1344 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnWlan;
1345 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1346 + sizeof(tHalCfg) + tlvStruct->length) ;
1347
1348 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN */
1349 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN ;
1350 tlvStruct->length = sizeof(tANI_U32);
1351 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1352 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeWlan;
1353 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1354 + sizeof(tHalCfg) + tlvStruct->length) ;
1355
1356 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT */
1357 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT ;
1358 tlvStruct->length = sizeof(tANI_U32);
1359 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1360 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenBt;
1361 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1362 + sizeof(tHalCfg) + tlvStruct->length) ;
1363
1364 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN */
1365 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN ;
1366 tlvStruct->length = sizeof(tANI_U32);
1367 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1368 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenWlan;
1369 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1370 + sizeof(tHalCfg) + tlvStruct->length) ;
1371
1372 /* [COEX] QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC */
1373 tlvStruct->type = QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC ;
1374 tlvStruct->length = sizeof(tANI_U32);
1375 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1376 *configDataValue = pMac->btc.btcConfig.btcMaxScoBlockPerc;
1377 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1378 + sizeof(tHalCfg) + tlvStruct->length) ;
1379
1380 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP */
1381 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP ;
1382 tlvStruct->length = sizeof(tANI_U32);
1383 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1384 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnA2dp;
1385 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1386 + sizeof(tHalCfg) + tlvStruct->length) ;
1387
1388 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO */
1389 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO ;
1390 tlvStruct->length = sizeof(tANI_U32);
1391 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1392 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnSco;
1393 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1394 + sizeof(tHalCfg) + tlvStruct->length) ;
1395
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]1396 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_VICTIM; i++)
1397 {
1398 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WAN_FREQ */
1399 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WAN_FREQ + i*4;
1400 tlvStruct->length = sizeof(tANI_U32);
1401 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1402 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWANFreq[i];
1403 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1404 + sizeof(tHalCfg) + tlvStruct->length) ;
1405
1406 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WLAN_FREQ */
1407 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WLAN_FREQ + i*4;
1408 tlvStruct->length = sizeof(tANI_U32);
1409 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1410 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWLANFreq[i];
1411 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1412 + sizeof(tHalCfg) + tlvStruct->length) ;
1413
1414 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG */
1415 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG + i*4;
1416 tlvStruct->length = sizeof(tANI_U32);
1417 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1418 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig[i];
1419 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1420 + sizeof(tHalCfg) + tlvStruct->length) ;
1421
1422 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG2 */
1423 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG2 + i*4;
1424 tlvStruct->length = sizeof(tANI_U32);
1425 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1426 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig2[i];
1427 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1428 + sizeof(tHalCfg) + tlvStruct->length) ;
1429 }
1430
1431 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF */
1432 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF ;
1433 tlvStruct->length = sizeof(tANI_U32);
1434 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1435 *configDataValue = pMac->btc.btcConfig.mwsCoexModemBackoff;
1436 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1437 + sizeof(tHalCfg) + tlvStruct->length) ;
1438
1439 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_CONFIG; i++)
1440 {
1441 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_CONFIGX */
1442 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_CONFIG1 + i;
1443 tlvStruct->length = sizeof(tANI_U32);
1444 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1445 *configDataValue = pMac->btc.btcConfig.mwsCoexConfig[i];
1446 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1447 + sizeof(tHalCfg) + tlvStruct->length) ;
1448 }
1449
1450 /* [COEX] QWLAN_HAL_CFG_SAR_POWER_BACKOFF */
1451 tlvStruct->type = QWLAN_HAL_CFG_SAR_POWER_BACKOFF ;
1452 tlvStruct->length = sizeof(tANI_U32);
1453 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1454 *configDataValue = pMac->btc.btcConfig.SARPowerBackoff;
1455 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1456 + sizeof(tHalCfg) + tlvStruct->length) ;
1457
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1458 /* QWLAN_HAL_CFG_WCNSS_API_VERSION */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1459 tlvStruct->type = QWLAN_HAL_CFG_WCNSS_API_VERSION ;
1460 tlvStruct->length = sizeof(tANI_U32);
1461 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1462 WDI_GetWcnssCompiledApiVersion(&wcnssCompiledApiVersion);
1463 *configDataValue = WLAN_HAL_CONSTRUCT_API_VERSION(wcnssCompiledApiVersion.major,
1464 wcnssCompiledApiVersion.minor,
1465 wcnssCompiledApiVersion.version,
1466 wcnssCompiledApiVersion.revision);
1467 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1468 + sizeof(tHalCfg) + tlvStruct->length) ;
1469
Jeff Johnsond13512a2012-07-17 11:42:19 -0700[diff] [blame]1470 /* QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT */
1471 tlvStruct->type = QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT ;
1472 tlvStruct->length = sizeof(tANI_U32);
1473 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1474 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT,
1475 configDataValue ) != eSIR_SUCCESS)
1476 {
1477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1478 "Failed to get value for WNI_CFG_AP_KEEP_ALIVE_TIMEOUT");
1479 goto handle_failure;
1480 }
1481
1482 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1483 + sizeof(tHalCfg) + tlvStruct->length) ;
1484 /* QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT */
1485 tlvStruct->type = QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT ;
1486 tlvStruct->length = sizeof(tANI_U32);
1487 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1488 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT,
1489 configDataValue ) != eSIR_SUCCESS)
1490 {
1491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1492 "Failed to get value for WNI_CFG_GO_KEEP_ALIVE_TIMEOUT");
1493 goto handle_failure;
1494 }
1495
1496 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1497 + sizeof(tHalCfg) + tlvStruct->length) ;
1498
1499 /* QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST */
1500 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST;
1501 tlvStruct->length = sizeof(tANI_U32);
1502 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1503 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MC_ADDR_LIST, configDataValue)
1504 != eSIR_SUCCESS)
1505 {
1506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1507 "Failed to get value for WNI_CFG_ENABLE_MC_ADDR_LIST");
1508 goto handle_failure;
1509 }
1510
1511 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1512 + sizeof(tHalCfg) + tlvStruct->length) ;
1513
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]1514 /* QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION */
1515 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION ;
1516 tlvStruct->length = sizeof(tANI_U32);
1517 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1518 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION, configDataValue)
1519 != eSIR_SUCCESS)
1520 {
1521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1522 "Failed to get value for WNI_CFG_ENABLE_LPWR_IMG_TRANSITION");
1523 goto handle_failure;
1524 }
1525
1526 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1527 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]1528#ifdef WLAN_SOFTAP_VSTA_FEATURE
1529 tlvStruct->type = QWLAN_HAL_CFG_MAX_ASSOC_LIMIT;
1530 tlvStruct->length = sizeof(tANI_U32);
1531 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1532 if(wlan_cfgGetInt(pMac, WNI_CFG_ASSOC_STA_LIMIT, configDataValue)
1533 != eSIR_SUCCESS)
1534 {
1535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1536 "Failed to get value for WNI_CFG_ASSOC_STA_LIMIT");
1537 goto handle_failure;
1538 }
1539
1540 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1541 + sizeof(tHalCfg) + tlvStruct->length) ;
1542#endif
1543
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]1544 /* QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER */
1545 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER;
1546 tlvStruct->length = sizeof(tANI_U32);
1547 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1548
1549 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, configDataValue)
1550 != eSIR_SUCCESS)
1551 {
1552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1553 "Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
1554 goto handle_failure;
1555 }
1556
1557 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1558 + sizeof(tHalCfg) + tlvStruct->length) ;
1559
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1560/* QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT */
1561 tlvStruct->type = QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT ;
1562 tlvStruct->length = sizeof(tANI_U32);
1563 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1564 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_LINK_MONITOR_TIMEOUT,
1565 configDataValue ) != eSIR_SUCCESS)
1566 {
1567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1568 "Failed to get value for WNI_CFG_AP_LINK_MONITOR_TIMEOUT");
1569 goto handle_failure;
1570 }
1571
1572 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1573 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1574#ifdef FEATURE_WLAN_TDLS
1575 /* QWLAN_HAL_CFG_TDLS_PUAPSD_MASK */
1576 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_MASK;
1577 tlvStruct->length = sizeof(tANI_U32);
1578 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1579 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,
1580 configDataValue ) != eSIR_SUCCESS)
1581 {
1582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1583 "Failed to get value for WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK");
1584 goto handle_failure;
1585 }
1586 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1587 + sizeof(tHalCfg) + tlvStruct->length) ;
1588
1589 /* QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE */
1590 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE;
1591 tlvStruct->length = sizeof(tANI_U32);
1592 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1593 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_BUF_STA_ENABLED,
1594 configDataValue ) != eSIR_SUCCESS)
1595 {
1596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1597 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1598 goto handle_failure;
1599 }
1600 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1601 + sizeof(tHalCfg) + tlvStruct->length) ;
1602 /* QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME */
1603 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME;
1604 tlvStruct->length = sizeof(tANI_U32);
1605 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1606 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_PUAPSD_INACT_TIME,
1607 configDataValue ) != eSIR_SUCCESS)
1608 {
1609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1610 "Failed to get value for WNI_CFG_TDLS_PUAPSD_INACT_TIME");
1611 goto handle_failure;
1612 }
1613 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1614 + sizeof(tHalCfg) + tlvStruct->length) ;
1615 /* QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP */
1616 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP;
1617 tlvStruct->length = sizeof(tANI_U32);
1618 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1619 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,
1620 configDataValue ) != eSIR_SUCCESS)
1621 {
1622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1623 "Failed to get value for WNI_CFG_TDLS_RX_FRAME_THRESHOLD");
1624 goto handle_failure;
1625 }
1626 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1627 + sizeof(tHalCfg) + tlvStruct->length) ;
Naresh Jayaramf73f3762014-02-04 16:13:20 +0530[diff] [blame]1628 /* QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE */
1629 tlvStruct->type = QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE;
1630 tlvStruct->length = sizeof(tANI_U32);
1631 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1632 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_OFF_CHANNEL_ENABLED,
1633 configDataValue ) != eSIR_SUCCESS)
1634 {
1635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1636 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1637 goto handle_failure;
1638 }
1639 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1640 + sizeof(tHalCfg) + tlvStruct->length) ;
1641
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1642#endif
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1643
Sudhir Sattayappa Kohallida1be202013-07-11 12:04:30 -0700[diff] [blame]1644 /* QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN */
1645 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN_FEATURE ;
1646 tlvStruct->length = sizeof(tANI_U32);
1647 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1648 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,
1649 configDataValue ) != eSIR_SUCCESS)
1650 {
1651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1652 "Failed to get value for WNI_CFG_ENABLE_ADAPT_RX_DRAIN");
1653 goto handle_failure;
1654 }
1655
1656 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1657 + sizeof(tHalCfg) + tlvStruct->length) ;
Yue Ma0fd23872013-08-01 15:56:47 -0700[diff] [blame]1658
1659 /* QWLAN_HAL_CFG_FLEX_CONNECT_POWER_FACTOR */
1660 tlvStruct->type = QWLAN_HAL_CFG_FLEXCONNECT_POWER_FACTOR;
1661 tlvStruct->length = sizeof(tANI_U32);
1662 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1663 if(wlan_cfgGetInt(pMac, WNI_CFG_FLEX_CONNECT_POWER_FACTOR, configDataValue)
1664 != eSIR_SUCCESS)
1665 {
1666 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1667 "Failed to get value for WNI_CFG_FLEX_CONNECT_POWER_FACTOR");
1668 goto handle_failure;
1669 }
1670 tlvStruct = (tHalCfg *)(((tANI_U8 *) tlvStruct
1671 + sizeof(tHalCfg) + tlvStruct->length));
1672
Madan Mohan Koyyalamudica454572013-08-07 19:57:03 +0530[diff] [blame]1673 /* QWLAN_HAL_CFG_ANTENNA_DIVERSITY */
1674 tlvStruct->type = QWLAN_HAL_CFG_ANTENNA_DIVERSITY;
1675 tlvStruct->length = sizeof(tANI_U32);
1676 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1677 if (wlan_cfgGetInt(pMac, WNI_CFG_ANTENNA_DIVESITY,
1678 configDataValue ) != eSIR_SUCCESS)
1679 {
1680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1681 "Failed to get value for WNI_CFG_ANTENNA_DIVESITY");
1682 goto handle_failure;
1683 }
1684
1685 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1686 + sizeof(tHalCfg) + tlvStruct->length) ;
1687
Madan Mohan Koyyalamudi2558bc92013-08-24 16:54:31 +0530[diff] [blame]1688 /* QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT */
1689 tlvStruct->type = QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT ;
1690 tlvStruct->length = sizeof(tANI_U32);
1691 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1692 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_LINK_MONITOR_TIMEOUT,
1693 configDataValue ) != eSIR_SUCCESS)
1694 {
1695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1696 "Failed to get value for WNI_CFG_GO_LINK_MONITOR_TIMEOUT");
1697 goto handle_failure;
1698 }
1699 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1700 + sizeof(tHalCfg) + tlvStruct->length) ;
1701
Kiet Lam4bbd3cb2013-11-07 20:03:49 +0530[diff] [blame]1702 /* QWLAN_HAL_CFG_ATH_DISABLE */
1703 tlvStruct->type = QWLAN_HAL_CFG_ATH_DISABLE ;
1704 tlvStruct->length = sizeof(tANI_U32);
1705 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1706 if(wlan_cfgGetInt(pMac, WNI_CFG_ATH_DISABLE,
1707 configDataValue ) != eSIR_SUCCESS)
1708 {
1709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1710 "Failed to get value for WNI_CFG_ATH_DISABLE");
1711 goto handle_failure;
1712 }
1713 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1714 + sizeof(tHalCfg) + tlvStruct->length) ;
1715
c_hpothu6d7dc922013-12-02 12:36:41 +0530[diff] [blame]1716 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_WLAN_LEN */
1717 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1718 tlvStruct->length = sizeof(tANI_U32);
1719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1720 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_WLAN_LEN,
1721 configDataValue ) != eSIR_SUCCESS)
1722 {
1723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1724 "Failed to get value for WNI_CFG_BTC_ACTIVE_WLAN_LEN");
1725 goto handle_failure;
1726 }
1727 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1728 + sizeof(tHalCfg) + tlvStruct->length) ;
1729
1730 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1731 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1732 tlvStruct->length = sizeof(tANI_U32);
1733 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1734 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_BT_LEN,
1735 configDataValue ) != eSIR_SUCCESS)
1736 {
1737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1738 "Failed to get value for WNI_CFG_BTC_ACTIVE_BT_LEN");
1739 goto handle_failure;
1740 }
1741 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1742 + sizeof(tHalCfg) + tlvStruct->length) ;
1743
1744 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN */
1745 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1746 tlvStruct->length = sizeof(tANI_U32);
1747 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1748 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,
1749 configDataValue ) != eSIR_SUCCESS)
1750 {
1751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1752 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN");
1753 goto handle_failure;
1754 }
1755 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1756 + sizeof(tHalCfg) + tlvStruct->length) ;
1757
1758 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1759 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1760 tlvStruct->length = sizeof(tANI_U32);
1761 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1762 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,
1763 configDataValue ) != eSIR_SUCCESS)
1764 {
1765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1766 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_BT_LEN");
1767 goto handle_failure;
1768 }
1769 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1770 + sizeof(tHalCfg) + tlvStruct->length) ;
1771
AnjaneeDevi Kapparapu50239e32014-01-07 18:09:33 +0530[diff] [blame]1772 /* QWLAN_HAL_CFG_ASD_PROBE_INTERVAL */
1773 tlvStruct->type = QWLAN_HAL_CFG_ASD_PROBE_INTERVAL ;
1774 tlvStruct->length = sizeof(tANI_U32);
1775 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1776 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_PROBE_INTERVAL,
1777 configDataValue ) != eSIR_SUCCESS)
1778 {
1779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1780 "Failed to get value for WNI_CFG_ASD_PROBE_INTERVAL");
1781 goto handle_failure;
1782 }
1783 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1784 + sizeof(tHalCfg) + tlvStruct->length) ;
1785
1786 /* QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD */
1787 tlvStruct->type = QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD ;
1788 tlvStruct->length = sizeof(tANI_U32);
1789 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1790 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_TRIGGER_THRESHOLD,
1791 configDataValue ) != eSIR_SUCCESS)
1792 {
1793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1794 "Failed to get value for WNI_CFG_ASD_TRIGGER_THRESHOLD");
1795 goto handle_failure;
1796 }
1797 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1798 + sizeof(tHalCfg) + tlvStruct->length) ;
1799
1800 /* QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD */
1801 tlvStruct->type = QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD ;
1802 tlvStruct->length = sizeof(tANI_U32);
1803 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1804 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD,
1805 configDataValue ) != eSIR_SUCCESS)
1806 {
1807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1808 "Failed to get value for WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD");
1809 goto handle_failure;
1810 }
1811 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1812 + sizeof(tHalCfg) + tlvStruct->length) ;
1813
Leela Venkata Kiran Kumar Reddy Chirala22c159b2013-12-23 18:19:13 -0800[diff] [blame]1814 /* QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO */
1815 tlvStruct->type = QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO ;
1816 tlvStruct->length = sizeof(tANI_U32);
1817 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1818 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CTS2S_DURING_SCO,
1819 configDataValue ) != eSIR_SUCCESS)
1820 {
1821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1822 "Failed to get value for WNI_CFG_BTC_CTS2S_DURING_SCO");
1823 goto handle_failure;
1824 }
1825 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1826 + sizeof(tHalCfg) + tlvStruct->length) ;
1827
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1828 /* QWLAN_HAL_CFG_RA_FILTER_ENABLE */
1829 tlvStruct->type = QWLAN_HAL_CFG_RA_FILTER_ENABLE ;
1830 tlvStruct->length = sizeof(tANI_U32);
1831 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1832
1833 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_FILTER_ENABLE,
1834 configDataValue ) != eSIR_SUCCESS)
1835 {
1836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1837 "Failed to get value for WNI_CFG_RA_FILTER_ENABLE");
1838 goto handle_failure;
1839 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1840 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1841 + sizeof(tHalCfg) + tlvStruct->length) ;
1842
1843 /* QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL */
1844 tlvStruct->type = QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL ;
1845 tlvStruct->length = sizeof(tANI_U32);
1846 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1847
1848 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_RATE_LIMIT_INTERVAL,
1849 configDataValue ) != eSIR_SUCCESS)
1850 {
1851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1852 "Failed to get value for WNI_CFG_RA_RATE_LIMIT_INTERVAL");
1853 goto handle_failure;
1854 }
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1855 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1856 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1857
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1858 /* QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE */
1859 tlvStruct->type = QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE ;
1860 tlvStruct->length = sizeof(tANI_U32);
1861 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1862
1863 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE,
1864 configDataValue ) != eSIR_SUCCESS)
1865 {
1866 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1867 "Failed to get value for WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE");
1868 goto handle_failure;
1869 }
1870 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1871 + sizeof(tHalCfg) + tlvStruct->length) ;
1872
1873 /* QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE */
1874 tlvStruct->type = QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE ;
1875 tlvStruct->length = sizeof(tANI_U32);
1876 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1877
1878 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE,
1879 configDataValue ) != eSIR_SUCCESS)
1880 {
1881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1882 "Failed to get value for WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE");
1883 goto handle_failure;
1884 }
1885 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1886 + sizeof(tHalCfg) + tlvStruct->length) ;
1887
1888 /* QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD */
1889 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD ;
1890 tlvStruct->length = sizeof(tANI_U32);
1891 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1892
1893 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD,
1894 configDataValue ) != eSIR_SUCCESS)
1895 {
1896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1897 "Failed to get value for WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD");
1898 goto handle_failure;
1899 }
1900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1901 + sizeof(tHalCfg) + tlvStruct->length) ;
1902
1903 /* QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD */
1904 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD ;
1905 tlvStruct->length = sizeof(tANI_U32);
1906 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1907
1908 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD,
1909 configDataValue ) != eSIR_SUCCESS)
1910 {
1911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1912 "Failed to get value for WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD");
1913 goto handle_failure;
1914 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1915 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1916 + sizeof(tHalCfg) + tlvStruct->length) ;
1917
Mihir Shetec34258c2014-07-30 17:50:27 +0530[diff] [blame]1918 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP */
1919 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP ;
1920 tlvStruct->length = sizeof(tANI_U32);
1921 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1922
1923 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_SP,
1924 configDataValue ) != eSIR_SUCCESS)
1925 {
1926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1927 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_SP");
1928 goto handle_failure;
1929 }
1930 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1931 + sizeof(tHalCfg) + tlvStruct->length) ;
1932
1933 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT */
1934 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT ;
1935 tlvStruct->length = sizeof(tANI_U32);
1936 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1937
1938 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT,
1939 configDataValue ) != eSIR_SUCCESS)
1940 {
1941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1942 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT");
1943 goto handle_failure;
1944 }
1945 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1946 + sizeof(tHalCfg) + tlvStruct->length) ;
1947
1948 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT */
1949 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT ;
1950 tlvStruct->length = sizeof(tANI_U32);
1951 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1952
1953 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT,
1954 configDataValue ) != eSIR_SUCCESS)
1955 {
1956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1957 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT");
1958 goto handle_failure;
1959 }
1960 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1961 + sizeof(tHalCfg) + tlvStruct->length) ;
1962
1963 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW */
1964 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW ;
1965 tlvStruct->length = sizeof(tANI_U32);
1966 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1967
1968 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW,
1969 configDataValue ) != eSIR_SUCCESS)
1970 {
1971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1972 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW");
1973 goto handle_failure;
1974 }
1975 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1976 + sizeof(tHalCfg) + tlvStruct->length) ;
1977
1978 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW */
1979 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW ;
1980 tlvStruct->length = sizeof(tANI_U32);
1981 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1982
1983 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW,
1984 configDataValue ) != eSIR_SUCCESS)
1985 {
1986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1987 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW");
1988 goto handle_failure;
1989 }
1990 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1991 + sizeof(tHalCfg) + tlvStruct->length) ;
1992
1993 /* QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE */
1994 tlvStruct->type = QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE ;
1995 tlvStruct->length = sizeof(tANI_U32);
1996 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1997
1998 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE,
1999 configDataValue ) != eSIR_SUCCESS)
2000 {
2001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2002 "Failed to get value for WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE");
2003 goto handle_failure;
2004 }
2005 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2006 + sizeof(tHalCfg) + tlvStruct->length) ;
2007
2008 /* QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS */
2009 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS ;
2010 tlvStruct->length = sizeof(tANI_U32);
2011 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2012
2013 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS,
2014 configDataValue ) != eSIR_SUCCESS)
2015 {
2016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2017 "Failed to get value for WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS");
2018 goto handle_failure;
2019 }
2020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2021 + sizeof(tHalCfg) + tlvStruct->length) ;
2022
2023 /* QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS */
2024 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS ;
2025 tlvStruct->length = sizeof(tANI_U32);
2026 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2027
2028 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_DYNAMIC_WMMPS,
2029 configDataValue ) != eSIR_SUCCESS)
2030 {
2031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2032 "Failed to get value for WNI_CFG_ENABLE_DYNAMIC_WMMPS");
2033 goto handle_failure;
2034 }
2035 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2036 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2037 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2038#ifdef WLAN_DEBUG
2039 {
2040 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2041 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2042 "****** Dumping CFG TLV ***** ");
2043 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
2044 {
2045 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2046 "%02x %02x %02x %02x %02x %02x %02x %02x",
2047 tlvStructStart[i],
2048 tlvStructStart[i+1],
2049 tlvStructStart[i+2],
2050 tlvStructStart[i+3],
2051 tlvStructStart[i+4],
2052 tlvStructStart[i+5],
2053 tlvStructStart[i+6],
2054 tlvStructStart[i+7]);
2055 }
2056 /* Dump the bytes in the last line*/
2057 for (; i < wdiStartParams->usConfigBufferLen; i++)
2058 {
2059 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2060 "%02x ",tlvStructStart[i]);
2061 }
2062 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2063 "**************************** ");
2064 }
2065#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2066 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2067handle_failure:
2068 vos_mem_free(configParam);
2069 return VOS_STATUS_E_FAILURE;
2070}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2071/*
2072 * FUNCTION: WDA_wdiCompleteCB
2073 * call the voss call back function
2074 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2075void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2076{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2077 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2078 tWDA_CbContext *wdaContext;
2079
2080 if(NULL == pWdaParams)
2081 {
2082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2083 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2084 VOS_ASSERT(0) ;
2085 return ;
2086 }
2087
2088 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
2089
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2090 if (NULL == wdaContext)
2091 {
2092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2093 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2094 return ;
2095 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2096
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2097 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2098 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2099 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2100 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2101 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2102 vos_mem_free(pWdaParams);
2103
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2104 if(WDI_STATUS_SUCCESS != status)
2105 {
2106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2107 "WDI stop callback returned failure" );
2108 VOS_ASSERT(0) ;
2109 }
2110 else
2111 {
2112 wdaContext->wdaState = WDA_STOP_STATE;
2113 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2114
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2115 /* FTM Driver stop procedure should be synced.
2116 * Stop and Close will happen on same context */
2117 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
2118 {
2119 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2120 {
2121 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2122 "%s: FTM Stop Event Set Fail", __func__);
2123 VOS_ASSERT(0);
2124 }
2125 }
2126
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2127 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2128 vos_WDAComplete_cback(wdaContext->pVosContext);
2129
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2130 return ;
2131}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2132/*
2133 * FUNCTION: WDA_stop
2134 * call WDI_stop
2135 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2136VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2137{
2138 WDI_Status wdiStatus;
2139 VOS_STATUS status = VOS_STATUS_SUCCESS;
2140 WDI_StopReqParamsType *wdiStopReq;
2141 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2142 tWDA_ReqParams *pWdaParams ;
2143
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2144 if (NULL == pWDA)
2145 {
2146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2147 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2148 VOS_ASSERT(0);
2149 return VOS_STATUS_E_FAILURE;
2150 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2151 if (pWDA->wdiFailed == true)
2152 {
2153 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2154 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2155 return VOS_STATUS_E_ALREADY;
2156 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2157
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2158 /* FTM mode stay START_STATE */
2159 if( (WDA_READY_STATE != pWDA->wdaState) &&
2160 (WDA_INIT_STATE != pWDA->wdaState) &&
2161 (WDA_START_STATE != pWDA->wdaState) )
2162 {
2163 VOS_ASSERT(0);
2164 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2165 wdiStopReq = (WDI_StopReqParamsType *)
2166 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2167 if(NULL == wdiStopReq)
2168 {
2169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2170 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2171 VOS_ASSERT(0);
2172 return VOS_STATUS_E_NOMEM;
2173 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2174
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2175 wdiStopReq->wdiStopReason = reason;
2176 wdiStopReq->wdiReqStatusCB = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2177
2178 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2179 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2180 {
2181 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2182 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2183 VOS_ASSERT(0);
2184 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2185 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2186 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2187
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2188 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2189 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2190 {
2191 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2192 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2193 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2194
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2195 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2196 pWdaParams->wdaMsgParam = NULL;
2197 pWdaParams->pWdaContext = pWDA;
2198
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2199 /* call WDI stop */
2200 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2201 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2202
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2203 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2204 {
2205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2206 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2207 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2208 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2209 status = VOS_STATUS_E_FAILURE;
2210 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2211
2212 /* FTM Driver stop procedure should be synced.
2213 * Stop and Close will happen on same context */
2214 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2215 {
2216 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2217 WDI_RESPONSE_TIMEOUT);
2218 if (status != VOS_STATUS_SUCCESS)
2219 {
2220 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2221 "%s: FTM Stop Timepoout", __func__);
2222 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2223 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2224 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2225 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2226 return status;
2227}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2228/*
2229 * FUNCTION: WDA_close
2230 * call WDI_close and free the WDA context
2231 */
2232VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2233{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2234 VOS_STATUS status = VOS_STATUS_SUCCESS;
2235 WDI_Status wstatus;
2236 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2237 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2238 if (NULL == wdaContext)
2239 {
2240 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2241 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2242 return VOS_STATUS_E_FAILURE;
2243 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2244 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2245 (WDA_STOP_STATE != wdaContext->wdaState))
2246 {
2247 VOS_ASSERT(0);
2248 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2249 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2250 wstatus = WDI_Close();
2251 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2252 {
2253 status = VOS_STATUS_E_FAILURE;
2254 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2255 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2256 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2257 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2258 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2259 {
2260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2261 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2262 status = VOS_STATUS_E_FAILURE;
2263 }
2264
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2265 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2266 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2267 {
2268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2269 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2270 status = VOS_STATUS_E_FAILURE;
2271 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2272 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2273 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2274 {
2275 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2276 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2277 status = VOS_STATUS_E_FAILURE;
2278 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2279 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2280 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2281 {
2282 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2283 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2284 status = VOS_STATUS_E_FAILURE;
2285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2286 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2287 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2288 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2289 {
2290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2291 "error in WDA close " );
2292 status = VOS_STATUS_E_FAILURE;
2293 }
2294 return status;
2295}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2296/*
2297 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2298 * returns 1 if the compiled version is greater than or equal to the input version
2299 */
2300
2301uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2302{
2303 VOS_STATUS status = VOS_STATUS_SUCCESS;
2304 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2305 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2306 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2307 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2308 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2309 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2310 (compiledVersion.revision >= revision)))
2311 return 1;
2312 else
2313 return 0;
2314}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2315/*
2316 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2317 * returns 1 if the compiled version is greater than or equal to the input version
2318 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2319uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2320{
2321 VOS_STATUS status = VOS_STATUS_SUCCESS;
2322 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2323 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2324 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2325 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2326 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2327 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2328 (reportedVersion.revision >= revision)))
2329 return 1;
2330 else
2331 return 0;
2332}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2333/*
2334 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2335 * Returns the version of the WCNSS WLAN API with which the HOST
2336 * device driver was compiled
2337 */
2338VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2339 tSirVersionType *pVersion)
2340{
2341 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2342 if ((NULL == pvosGCtx) || (NULL == pVersion))
2343 {
2344 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2345 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2346 VOS_ASSERT(0);
2347 return VOS_STATUS_E_FAILURE;
2348 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2349 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2350 if (NULL == pWDA )
2351 {
2352 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2353 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2354 VOS_ASSERT(0);
2355 return VOS_STATUS_E_FAILURE;
2356 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2357 *pVersion = pWDA->wcnssWlanCompiledVersion;
2358 return VOS_STATUS_SUCCESS;
2359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2360/*
2361 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2362 * Returns the version of the WCNSS WLAN API with which the WCNSS
2363 * device driver was compiled
2364 */
2365VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2366 tSirVersionType *pVersion)
2367{
2368 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2369 if ((NULL == pvosGCtx) || (NULL == pVersion))
2370 {
2371 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2372 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2373 VOS_ASSERT(0);
2374 return VOS_STATUS_E_FAILURE;
2375 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2376 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2377 if (NULL == pWDA )
2378 {
2379 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2380 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2381 VOS_ASSERT(0);
2382 return VOS_STATUS_E_FAILURE;
2383 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2384 *pVersion = pWDA->wcnssWlanReportedVersion;
2385 return VOS_STATUS_SUCCESS;
2386}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2387/*
2388 * FUNCTION: WDA_GetWcnssSoftwareVersion
2389 * Returns the WCNSS Software version string
2390 */
2391VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2392 tANI_U8 *pVersion,
2393 tANI_U32 versionBufferSize)
2394{
2395 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2396 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2397 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2398 if ((NULL == pvosGCtx) || (NULL == pVersion))
2399 {
2400 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2401 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2402 VOS_ASSERT(0);
2403 return VOS_STATUS_E_FAILURE;
2404 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2405 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2406 if (NULL == pWDA )
2407 {
2408 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2409 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2410 VOS_ASSERT(0);
2411 return VOS_STATUS_E_FAILURE;
2412 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2413 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2414 return VOS_STATUS_SUCCESS;
2415}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2416/*
2417 * FUNCTION: WDA_GetWcnssHardwareVersion
2418 * Returns the WCNSS Hardware version string
2419 */
2420VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2421 tANI_U8 *pVersion,
2422 tANI_U32 versionBufferSize)
2423{
2424 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2425 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2426 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2427 if ((NULL == pvosGCtx) || (NULL == pVersion))
2428 {
2429 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2430 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2431 VOS_ASSERT(0);
2432 return VOS_STATUS_E_FAILURE;
2433 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2434 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2435 if (NULL == pWDA )
2436 {
2437 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2438 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2439 VOS_ASSERT(0);
2440 return VOS_STATUS_E_FAILURE;
2441 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2442 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2443 return VOS_STATUS_SUCCESS;
2444}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2445/*
2446 * FUNCTION: WDA_WniCfgDnld
2447 * Trigger CFG Download
2448 */
2449VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2450{
2451 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2452 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2453
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2454 if (NULL == pMac )
2455 {
2456 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2457 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2458 VOS_ASSERT(0);
2459 return VOS_STATUS_E_FAILURE;
2460 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2461 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2462 return vosStatus;
2463}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2464/* -----------------------------------------------------------------
2465 * WDI interface
2466 * -----------------------------------------------------------------
2467 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2468/*
2469 * FUNCTION: WDA_suspendDataTxCallback
2470 * call back function called from TL after suspend Transmission
2471 */
2472VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2473 v_U8_t* ucSTAId,
2474 VOS_STATUS vosStatus)
2475{
2476 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2478 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2479 if (NULL == pWDA )
2480 {
2481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2482 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2483 VOS_ASSERT(0);
2484 return VOS_STATUS_E_FAILURE;
2485 }
2486 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2487 {
2488 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2489 }
2490 else
2491 {
2492 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2493 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2494 /* Trigger the event to bring the WDA TL suspend function to come
2495 * out of wait*/
2496 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2497 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2498 {
2499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2500 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2501 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2502 /* If TL suspended had timedout before this callback was called, resume back
2503 * TL.*/
2504 if (pWDA->txSuspendTimedOut)
2505 {
2506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2507 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2508 WDA_ResumeDataTx(pWDA);
2509 pWDA->txSuspendTimedOut = FALSE;
2510 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2511 return VOS_STATUS_SUCCESS;
2512}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2513/*
2514 * FUNCTION: WDA_suspendDataTx
2515 * Update TL to suspend the data Transmission
2516 */
2517VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2518{
2519 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2520 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2521
2522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2523 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2524 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2525 if (pWDA->txSuspendTimedOut)
2526 {
2527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2528 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2529 return status;
2530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2531 /* Reset the event to be not signalled */
2532 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2533 if(!VOS_IS_STATUS_SUCCESS(status))
2534 {
2535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2536 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2537 return VOS_STATUS_E_FAILURE;
2538 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2539 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2540 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2541 WDA_SuspendDataTxCallback);
2542 if(status != VOS_STATUS_SUCCESS)
2543 {
2544 return status;
2545 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2546 /* Wait for the event to be set by the TL, to get the response of
2547 * suspending the TX queues, this event should be set by the Callback
2548 * function called by TL*/
2549 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2550 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2551 if(!VOS_IS_STATUS_SUCCESS(status))
2552 {
2553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2554 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2555 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2556 /* Set this flag to true when TL suspend times out, so that when TL
2557 * suspend eventually happens and calls the callback, TL can be resumed
2558 * right away by looking at this flag when true.*/
2559 pWDA->txSuspendTimedOut = TRUE;
2560 }
2561 else
2562 {
2563 pWDA->txSuspendTimedOut = FALSE;
2564 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2565 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2566 {
2567 status = VOS_STATUS_SUCCESS;
2568 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2569 return status;
2570}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2571/*
2572 * FUNCTION: WDA_resumeDataTx
2573 * Update TL to resume the data Transmission
2574 */
2575VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2576{
2577 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2578
2579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2580 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2581
2582 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2583 return status;
2584}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2585/*
2586 * FUNCTION: WDA_InitScanReqCallback
2587 * Trigger Init SCAN callback
2588 */
2589void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2590{
2591 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2592 tWDA_CbContext *pWDA;
2593 tInitScanParams *pWDA_ScanParam ;
2594 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2596 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2597 if(NULL == pWdaParams)
2598 {
2599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2600 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2601 VOS_ASSERT(0) ;
2602 return ;
2603 }
2604 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2605 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2606 if(NULL == pWDA_ScanParam)
2607 {
2608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2609 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2610 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2611 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2612 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2613 return ;
2614 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2615 if(WDI_STATUS_SUCCESS != wdiStatus)
2616 {
2617 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2618 if(VOS_STATUS_SUCCESS != status)
2619 {
2620 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2621 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2622 }
2623 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2624 /* free WDI command buffer */
2625 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2626 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2627
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2628
2629 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2630 /* without converting the Status to Failure or Success Just
2631 pass the same status to lim */
2632 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2633 /* send SCAN RSP message back to PE */
2634 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2635 return ;
2636}
2637
2638/*
2639 * FUNCTION: WDA_ProcessInitScanReq
2640 * Trigger Init SCAN in DAL
2641 */
2642VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2643 tInitScanParams *initScanParams)
2644{
2645 WDI_Status status = WDI_STATUS_SUCCESS ;
2646 WDI_InitScanReqParamsType *wdiInitScanParam =
2647 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2648 sizeof(WDI_InitScanReqParamsType)) ;
2649 tWDA_ReqParams *pWdaParams;
2650 tANI_U8 i = 0;
2651
2652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2653 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2654 if(NULL == wdiInitScanParam)
2655 {
2656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2657 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2658 VOS_ASSERT(0);
2659 return VOS_STATUS_E_NOMEM;
2660 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2661 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2662 if(NULL == pWdaParams)
2663 {
2664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2665 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2666 VOS_ASSERT(0);
2667 vos_mem_free(wdiInitScanParam);
2668 return VOS_STATUS_E_NOMEM;
2669 }
2670
2671 /* Copy init Scan params to WDI structure */
2672 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2673 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2674 sizeof(tSirMacAddr)) ;
2675 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2676 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2677 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2678 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2679 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2680 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2681 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2682 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2683 {
2684 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2685 initScanParams->scanEntry.bssIdx[i] ;
2686 }
2687
2688 /* if Frame length, copy macMgmtHdr or WDI structure */
2689 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2690 {
2691 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2692 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2693 }
2694 wdiInitScanParam->wdiReqStatusCB = NULL ;
2695
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2696 /* Store Init Req pointer, as this will be used for response */
2697 pWdaParams->pWdaContext = pWDA;
2698 pWdaParams->wdaMsgParam = initScanParams;
2699 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2700 /* first try to suspend TX */
2701 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2702 if(WDI_STATUS_SUCCESS != status)
2703 {
2704 goto handleWdiFailure;
2705 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2706 /* call DAL API to pass init scan request to DAL */
2707 status = WDI_InitScanReq(wdiInitScanParam,
2708 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2709 if(IS_WDI_STATUS_FAILURE(status))
2710 {
2711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2712 "error in WDA Init Scan, Resume Tx " );
2713 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2714 VOS_ASSERT(0) ;
2715
2716 goto handleWdiFailure;
2717 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2718 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2719handleWdiFailure:
2720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2721 "Failure in WDI Api, free all the memory " );
2722 /* free WDI command buffer */
2723 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2724 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2725 /* send Failure to PE */
2726 initScanParams->status = eSIR_FAILURE ;
2727 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2728 return CONVERT_WDI2VOS_STATUS(status) ;
2729}
2730
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2731/*
2732 * FUNCTION: WDA_StartScanReqCallback
2733 * send Start SCAN RSP back to PE
2734 */
2735void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2736 void* pUserData)
2737{
2738 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2739 tWDA_CbContext *pWDA;
2740 tStartScanParams *pWDA_ScanParam;
2741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2742 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2743 if(NULL == pWdaParams)
2744 {
2745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2746 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2747 VOS_ASSERT(0) ;
2748 return ;
2749 }
2750 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2751 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2752 if(NULL == pWDA_ScanParam)
2753 {
2754 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2755 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2756 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2757 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2758 return ;
2759 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2760 if(NULL == pWdaParams->wdaWdiApiMsgParam)
2761 {
2762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2763 "%s: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2764 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2765 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2766 return ;
2767 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2768 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2769 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2770
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2771
2772 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2773 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2774 /* send SCAN RSP message back to PE */
2775 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2776 return ;
2777}
2778
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2779/*
2780 * FUNCTION: WDA_ProcessStartScanReq
2781 * Trigger start SCAN in WDI
2782 */
2783VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
2784 tStartScanParams *startScanParams)
2785{
2786 WDI_Status status = WDI_STATUS_SUCCESS;
2787 WDI_StartScanReqParamsType *wdiStartScanParams =
2788 (WDI_StartScanReqParamsType *)vos_mem_malloc(
2789 sizeof(WDI_StartScanReqParamsType)) ;
2790 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2792 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2793 if(NULL == wdiStartScanParams)
2794 {
2795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2796 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2797 VOS_ASSERT(0);
2798 return VOS_STATUS_E_NOMEM;
2799 }
2800 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2801 if(NULL == pWdaParams)
2802 {
2803 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2804 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2805 VOS_ASSERT(0);
2806 vos_mem_free(wdiStartScanParams);
2807 return VOS_STATUS_E_NOMEM;
2808 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2809 /* Copy init Scan params to WDI structure */
2810 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
2811 wdiStartScanParams->wdiReqStatusCB = NULL ;
2812
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2813 /* Store Init Req pointer, as this will be used for response */
2814 /* store Params pass it to WDI */
2815 pWdaParams->pWdaContext = pWDA;
2816 pWdaParams->wdaMsgParam = startScanParams;
2817 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2818 /* call DAL API to pass init scan request to DAL */
2819 status = WDI_StartScanReq(wdiStartScanParams,
2820 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2821 /* failure returned by WDI API */
2822 if(IS_WDI_STATUS_FAILURE(status))
2823 {
2824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2825 "Failure in Start Scan WDI API, free all the memory "
2826 "It should be due to previous abort scan." );
2827 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2828 vos_mem_free(pWdaParams) ;
2829 startScanParams->status = eSIR_FAILURE ;
2830 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
2831 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2832 return CONVERT_WDI2VOS_STATUS(status) ;
2833}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2834/*
2835 * FUNCTION: WDA_EndScanReqCallback
2836 * END SCAN callback
2837 */
2838void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
2839{
2840 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2841 tWDA_CbContext *pWDA;
2842 tEndScanParams *endScanParam;
2843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2844 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2845 if(NULL == pWdaParams)
2846 {
2847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2848 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2849 VOS_ASSERT(0) ;
2850 return ;
2851 }
2852 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2853 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2854 if(NULL == endScanParam)
2855 {
2856 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2857 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2858 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2859 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2860 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2861 return ;
2862 }
2863
2864 /* Free WDI command buffer */
2865 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2866 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2867 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2868 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2869 /* send response back to PE */
2870 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
2871 return ;
2872}
2873
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2874/*
2875 * FUNCTION: WDA_ProcessEndScanReq
2876 * Trigger END SCAN in WDI
2877 */
2878VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
2879 tEndScanParams *endScanParams)
2880{
2881 WDI_Status status = WDI_STATUS_SUCCESS;
2882 WDI_EndScanReqParamsType *wdiEndScanParams =
2883 (WDI_EndScanReqParamsType *)vos_mem_malloc(
2884 sizeof(WDI_EndScanReqParamsType)) ;
2885 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2887 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2888 if(NULL == wdiEndScanParams)
2889 {
2890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2891 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2892 VOS_ASSERT(0);
2893 return VOS_STATUS_E_NOMEM;
2894 }
2895 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2896 if(NULL == pWdaParams)
2897 {
2898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2899 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2900 VOS_ASSERT(0);
2901 vos_mem_free(wdiEndScanParams);
2902 return VOS_STATUS_E_NOMEM;
2903 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2904 /* Copy init Scan params to WDI structure */
2905 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
2906 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2907 /* Store Init Req pointer, as this will be used for response */
2908 /* store Params pass it to WDI */
2909 pWdaParams->pWdaContext = pWDA;
2910 pWdaParams->wdaMsgParam = endScanParams;
2911 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2912 /* call DAL API to pass init scan request to DAL */
2913 status = WDI_EndScanReq(wdiEndScanParams,
2914 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2915 if(IS_WDI_STATUS_FAILURE(status))
2916 {
2917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2918 "Failure in End Scan WDI API, free all the memory "
2919 "It should be due to previous abort scan." );
2920 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2921 vos_mem_free(pWdaParams) ;
2922 endScanParams->status = eSIR_FAILURE ;
2923 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
2924 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2925 return CONVERT_WDI2VOS_STATUS(status) ;
2926}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2927/*
2928 * FUNCTION: WDA_FinishScanReqCallback
2929 * Trigger Finish SCAN callback
2930 */
2931void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2932{
2933 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2934 tWDA_CbContext *pWDA;
2935 tFinishScanParams *finishScanParam;
2936 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2938 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2939 if(NULL == pWdaParams)
2940 {
2941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2942 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2943 VOS_ASSERT(0) ;
2944 return ;
2945 }
2946
2947 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2948 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2949 if(NULL == finishScanParam)
2950 {
2951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2952 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2953 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2954 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2955 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2956 return ;
2957 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2958 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2959 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2960 /*
2961 * Now Resume TX, if we reached here means, TX is already suspended, we
2962 * have to resume it unconditionaly
2963 */
2964 status = WDA_ResumeDataTx(pWDA) ;
2965
2966 if(VOS_STATUS_SUCCESS != status)
2967 {
2968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2969 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2970 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2971 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2972 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
2973 return ;
2974}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2975/*
2976 * FUNCTION: WDA_ProcessFinshScanReq
2977 * Trigger Finish SCAN in WDI
2978 */
2979VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
2980 tFinishScanParams *finishScanParams)
2981{
2982 WDI_Status status = WDI_STATUS_SUCCESS;
2983 WDI_FinishScanReqParamsType *wdiFinishScanParams =
2984 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
2985 sizeof(WDI_FinishScanReqParamsType)) ;
2986 tWDA_ReqParams *pWdaParams ;
2987 tANI_U8 i = 0;
2988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2989 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2990 if(NULL == wdiFinishScanParams)
2991 {
2992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2993 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2994 VOS_ASSERT(0);
2995 return VOS_STATUS_E_NOMEM;
2996 }
2997 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2998 if(NULL == pWdaParams)
2999 {
3000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3001 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3002 VOS_ASSERT(0);
3003 vos_mem_free(wdiFinishScanParams);
3004 return VOS_STATUS_E_NOMEM;
3005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3006 /* Copy init Scan params to WDI structure */
3007 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
3008 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
3009 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3010 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
3011 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
3012 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
3013 finishScanParams->frameLength ;
3014 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
3015 finishScanParams->currentOperChannel ;
3016 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
3017 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
3018 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3019 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
3020 {
3021 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
3022 finishScanParams->scanEntry.bssIdx[i] ;
3023 }
3024
3025
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3026 /* if Frame length, copy macMgmtHdr ro WDI structure */
3027 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
3028 {
3029 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
3030 &finishScanParams->macMgmtHdr,
3031 sizeof(WDI_MacMgmtHdr)) ;
3032 }
3033 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3034 /* Store Init Req pointer, as this will be used for response */
3035 /* store Params pass it to WDI */
3036 pWdaParams->pWdaContext = pWDA;
3037 pWdaParams->wdaMsgParam = finishScanParams;
3038 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3039 /* call DAL API to pass init scan request to DAL */
3040 status = WDI_FinishScanReq(wdiFinishScanParams,
3041 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3042
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3043
3044 /*
3045 * WDI API returns failure..
3046 */
3047 if(IS_WDI_STATUS_FAILURE( status))
3048 {
3049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3050 "Failure in Finish Scan WDI API, free all the memory " );
3051 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3052 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3053 finishScanParams->status = eSIR_FAILURE ;
3054 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
3055 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3056 return CONVERT_WDI2VOS_STATUS(status) ;
3057}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3058/*---------------------------------------------------------------------
3059 * ASSOC API's
3060 *---------------------------------------------------------------------
3061 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3062/*
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3063 * FUNCTION: WDA_JoinRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3064 * Trigger Init SCAN callback
3065 */
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3066void WDA_JoinRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3067{
3068 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3069 tWDA_CbContext *pWDA;
3070 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3071 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3072 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3073 if(NULL == pWdaParams)
3074 {
3075 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3076 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3077 VOS_ASSERT(0) ;
3078 return ;
3079 }
3080 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3081 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3082 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3083 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3084 /* reset macBSSID */
3085 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3086 /* reset macSTASelf */
3087 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3088 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3089 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3090 return ;
3091}
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3092
3093/*
3094 * FUNCTION: WDA_JoinReqCallback
3095 * Free memory and send SWITCH CHANNEL RSP back to PE.
3096 * Invoked when Enter JOIN REQ failed in WDI and no RSP callback is generated.
3097 */
3098void WDA_JoinReqCallback(WDI_Status wdiStatus, void* pUserData)
3099{
3100 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3101 tWDA_CbContext *pWDA;
3102 tSwitchChannelParams *joinReqParam;
3103
3104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3105 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
3106
3107 if(NULL == pWdaParams)
3108 {
3109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3110 "%s: pWdaParams received NULL", __func__);
3111 VOS_ASSERT(0);
3112 return;
3113 }
3114
3115 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3116 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3117 joinReqParam->status = wdiStatus;
3118
3119 if(IS_WDI_STATUS_FAILURE(wdiStatus))
3120 {
3121 /* reset macBSSID */
3122 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
3123 /* reset macSTASelf */
3124 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
3125
3126 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3127 vos_mem_free(pWdaParams);
3128 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
3129 }
3130
3131 return;
3132}
3133
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3134/*
3135 * FUNCTION: WDA_ProcessJoinReq
3136 * Trigger Join REQ in WDI
3137 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3138VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
3139 tSwitchChannelParams* joinReqParam)
3140{
3141 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3142 WDI_JoinReqParamsType *wdiJoinReqParam =
3143 (WDI_JoinReqParamsType *)vos_mem_malloc(
3144 sizeof(WDI_JoinReqParamsType)) ;
3145 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3147 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3148 if(NULL == wdiJoinReqParam)
3149 {
3150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3151 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3152 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3153 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3154 return VOS_STATUS_E_NOMEM;
3155 }
3156 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3157 if(NULL == pWdaParams)
3158 {
3159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3160 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3161 VOS_ASSERT(0);
3162 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3163 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3164 return VOS_STATUS_E_NOMEM;
3165 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3166
3167 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3168 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3169 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3170 {
3171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3172 "%s: received join request when BSSID or self-STA is NULL "
3173 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3174 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3175 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3176 VOS_ASSERT(0);
3177 vos_mem_free(wdiJoinReqParam);
3178 vos_mem_free(pWdaParams);
3179 joinReqParam->status = eSIR_FAILURE ;
3180 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3181 return VOS_STATUS_E_INVAL;
3182 }
3183
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3184 /* copy the BSSID for pWDA */
3185 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3186 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3187 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3188 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3189 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3190 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3191#ifdef WLAN_FEATURE_VOWIFI
3192 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3193 joinReqParam->maxTxPower ;
3194#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3195 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3196 joinReqParam->localPowerConstraint ;
3197#endif
3198 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3199 joinReqParam->secondaryChannelOffset ;
3200 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3201
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3202 wdiJoinReqParam->wdiReqStatusCB = WDA_JoinReqCallback;
3203 wdiJoinReqParam->pUserData = pWdaParams;
3204
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3205 /* Store Init Req pointer, as this will be used for response */
3206 /* store Params pass it to WDI */
3207 pWdaParams->pWdaContext = pWDA;
3208 pWdaParams->wdaMsgParam = joinReqParam;
3209 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3210 status = WDI_JoinReq(wdiJoinReqParam,
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3211 (WDI_JoinRspCb )WDA_JoinRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3212 if(IS_WDI_STATUS_FAILURE(status))
3213 {
3214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3215 "Failure in Join WDI API, free all the memory " );
3216 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3217 vos_mem_free(pWdaParams) ;
3218 joinReqParam->status = eSIR_FAILURE ;
3219 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3220 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3221 return CONVERT_WDI2VOS_STATUS(status) ;
3222}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3223/*
3224 * FUNCTION: WDA_SwitchChannelReqCallback
3225 * send Switch channel RSP back to PE
3226 */
3227void WDA_SwitchChannelReqCallback(
3228 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3229{
3230 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3231 tWDA_CbContext *pWDA;
3232 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3234 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3235 if(NULL == pWdaParams)
3236 {
3237 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3238 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3239 VOS_ASSERT(0) ;
3240 return ;
3241 }
3242 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3243 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3244
3245#ifdef WLAN_FEATURE_VOWIFI
3246 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3247#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3248 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3249 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3250 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3251 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3252 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3253 return ;
3254}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3255/*
3256 * FUNCTION: WDA_ProcessChannelSwitchReq
3257 * Request to WDI to switch channel REQ params.
3258 */
3259VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3260 tSwitchChannelParams *pSwitchChanParams)
3261{
3262 WDI_Status status = WDI_STATUS_SUCCESS ;
3263 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3264 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3265 sizeof(WDI_SwitchChReqParamsType)) ;
3266 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3268 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3269 if(NULL == wdiSwitchChanParam)
3270 {
3271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3272 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3273 VOS_ASSERT(0);
3274 return VOS_STATUS_E_NOMEM;
3275 }
3276 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3277 if(NULL == pWdaParams)
3278 {
3279 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3280 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3281 VOS_ASSERT(0);
3282 vos_mem_free(wdiSwitchChanParam);
3283 return VOS_STATUS_E_NOMEM;
3284 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3285 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3286#ifndef WLAN_FEATURE_VOWIFI
3287 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3288 pSwitchChanParams->localPowerConstraint;
3289#endif
3290 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3291 pSwitchChanParams->secondaryChannelOffset;
3292 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3293 /* Store req pointer, as this will be used for response */
3294 /* store Params pass it to WDI */
3295 pWdaParams->pWdaContext = pWDA;
3296 pWdaParams->wdaMsgParam = pSwitchChanParams;
3297 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3298#ifdef WLAN_FEATURE_VOWIFI
3299 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3300 = pSwitchChanParams->maxTxPower;
3301 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3302 pSwitchChanParams ->selfStaMacAddr,
3303 sizeof(tSirMacAddr));
3304#endif
3305 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3306 pSwitchChanParams->bssId,
3307 sizeof(tSirMacAddr));
3308
3309 status = WDI_SwitchChReq(wdiSwitchChanParam,
3310 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3311 if(IS_WDI_STATUS_FAILURE(status))
3312 {
3313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3314 "Failure in process channel switch Req WDI API, free all the memory " );
3315 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3316 vos_mem_free(pWdaParams) ;
3317 pSwitchChanParams->status = eSIR_FAILURE ;
3318 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3319 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3320 return CONVERT_WDI2VOS_STATUS(status) ;
3321}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3322
3323/*
3324 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3325 * send Switch channel RSP back to PE
3326 */
3327void WDA_SwitchChannelReqCallback_V1(
3328 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3329 void* pUserData)
3330{
3331 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3332 tWDA_CbContext *pWDA;
3333 tSwitchChannelParams *pSwitchChanParams;
3334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3335 "<------ %s " ,__func__);
3336
3337 if (NULL == pWdaParams)
3338 {
3339 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3340 "%s: pWdaParams received NULL", __func__);
3341 VOS_ASSERT(0);
3342 return ;
3343 }
3344 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3345 pSwitchChanParams =
3346 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3347 pSwitchChanParams->channelSwitchSrc =
3348 wdiSwitchChanRsp->channelSwitchSrc;
3349#ifdef WLAN_FEATURE_VOWIFI
3350 pSwitchChanParams->txMgmtPower =
3351 wdiSwitchChanRsp->ucTxMgmtPower;
3352#endif
3353 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3354 vos_mem_free(pWdaParams);
3355 pSwitchChanParams->status =
3356 wdiSwitchChanRsp->wdiStatus ;
3357 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3358 (void *)pSwitchChanParams , 0);
3359 return;
3360}
3361
3362/*
3363 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3364 * Request to WDI to switch channel REQ params.
3365 */
3366VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3367 tSwitchChannelParams *pSwitchChanParams)
3368{
3369 WDI_Status status = WDI_STATUS_SUCCESS ;
3370 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3371 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3372 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3373 tWDA_ReqParams *pWdaParams ;
3374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3375 "------> %s " ,__func__);
3376 if (NULL == wdiSwitchChanParam)
3377 {
3378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3379 "%s: VOS MEM Alloc Failure", __func__);
3380 VOS_ASSERT(0);
3381 return VOS_STATUS_E_NOMEM;
3382 }
3383 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3384 if (NULL == pWdaParams)
3385 {
3386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3387 "%s: VOS MEM Alloc Failure", __func__);
3388 VOS_ASSERT(0);
3389 vos_mem_free(wdiSwitchChanParam);
3390 return VOS_STATUS_E_NOMEM;
3391 }
3392 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3393 pSwitchChanParams->channelSwitchSrc;
3394
3395 wdiSwitchChanParam->wdiChInfo.ucChannel =
3396 pSwitchChanParams->channelNumber;
3397#ifndef WLAN_FEATURE_VOWIFI
3398 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3399 pSwitchChanParams->localPowerConstraint;
3400#endif
3401 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3402 pSwitchChanParams->secondaryChannelOffset;
3403 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3404 /* Store req pointer, as this will be used for response */
3405 /* store Params pass it to WDI */
3406 pWdaParams->pWdaContext = pWDA;
3407 pWdaParams->wdaMsgParam = pSwitchChanParams;
3408 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3409#ifdef WLAN_FEATURE_VOWIFI
3410 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3411 pSwitchChanParams->maxTxPower;
3412 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3413 pSwitchChanParams ->selfStaMacAddr,
3414 sizeof(tSirMacAddr));
3415#endif
3416 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3417 pSwitchChanParams->bssId,
3418 sizeof(tSirMacAddr));
3419
3420 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3421 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3422 pWdaParams);
3423 if (IS_WDI_STATUS_FAILURE(status))
3424 {
3425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3426 "Failure in process channel switch Req WDI "
3427 "API, free all the memory " );
3428 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3429 vos_mem_free(pWdaParams) ;
3430 pSwitchChanParams->status = eSIR_FAILURE ;
3431 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3432 (void *)pSwitchChanParams, 0) ;
3433 }
3434 return CONVERT_WDI2VOS_STATUS(status) ;
3435}
3436
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3437/*
3438 * FUNCTION: WDA_ConfigBssReqCallback
3439 * config BSS Req Callback, called by WDI
3440 */
3441void WDA_ConfigBssReqCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
3442 ,void* pUserData)
3443{
3444 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3445 tWDA_CbContext *pWDA;
3446 tAddBssParams *configBssReqParam;
3447 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3449 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3450 if(NULL == pWdaParams)
3451 {
3452 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3453 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3454 VOS_ASSERT(0) ;
3455 return ;
3456 }
3457 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3458 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3459 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3460 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3461 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3462 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3463 {
3464 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3465 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3466 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3467 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3468 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3469
3470 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3471 {
3472 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3473 {
3474 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3475 staConfigBssParam->staType = STA_ENTRY_BSSID;
3476 }
3477 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3478 (staConfigBssParam->staType == STA_ENTRY_SELF))
3479 {
3480 /* This is the 1st add BSS Req for the BTAMP STA */
3481 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3482 staConfigBssParam->staType = STA_ENTRY_BSSID;
3483 }
3484 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3485 (staConfigBssParam->staType == STA_ENTRY_PEER))
3486 {
3487 /* This is the 2nd ADD BSS Request that is sent
3488 * on the BTAMP STA side. The Sta type is
3489 * set to STA_ENTRY_PEER here.*/
3490 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3491 }
3492 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3493 (staConfigBssParam->staType == STA_ENTRY_SELF))
3494 {
3495 /* statype is already set by PE.
3496 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3497 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3498 staConfigBssParam->staType = STA_ENTRY_BSSID;
3499 }
3500 else
3501 {
3502 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3503 staConfigBssParam->staType = STA_ENTRY_PEER;
3504 }
3505 }
3506 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3507 {
3508 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3509 staConfigBssParam->staType = STA_ENTRY_SELF;
3510 }
3511 else
3512 {
3513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3514 "Invalid operation mode specified");
3515 VOS_ASSERT(0);
3516 }
3517
3518 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3519 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3520 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3521 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3522 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3523 sizeof(tSirMacAddr));
3524 staConfigBssParam->txChannelWidthSet =
3525 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3526 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3527 staConfigBssParam->htCapable)
3528 {
3529 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3530 wdiConfigBssRsp->ucBSSIdx;
3531 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3532 WDA_VALID_STA_INDEX ;
3533 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3534 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3535 wdiConfigBssRsp->ucBSSIdx,
3536 wdiConfigBssRsp->ucSTAIdx))
3537 {
3538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3539 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3540 VOS_ASSERT(0) ;
3541 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3542 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3543 {
3544 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3545 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3546 VOS_ASSERT(0) ;
3547 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3548#ifdef WLAN_FEATURE_VOWIFI
3549 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3550#endif
3551 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3552 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3553 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3554 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3555 return ;
3556}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3557/*
3558 * FUNCTION: WDA_UpdateEdcaParamsForAC
3559 * Update WDI EDCA params with PE edca params
3560 */
3561void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3562 WDI_EdcaParamRecord *wdiEdcaParam,
3563 tSirMacEdcaParamRecord *macEdcaParam)
3564{
3565 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3566 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3567 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3568 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3569 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3570 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3571}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3572/*
3573 * FUNCTION: WDA_ProcessConfigBssReq
3574 * Configure BSS before starting Assoc with AP
3575 */
3576VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3577 tAddBssParams* configBssReqParam)
3578{
3579 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3580 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3581 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3583 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3584 if (NULL == configBssReqParam)
3585 {
3586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3587 "%s: configBssReqParam is NULL", __func__);
3588 return VOS_STATUS_E_INVAL;
3589 }
3590
3591 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3592 sizeof(WDI_ConfigBSSReqParamsType)) ;
3593
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3594 if(NULL == wdiConfigBssReqParam)
3595 {
3596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3597 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3598 VOS_ASSERT(0);
3599 return VOS_STATUS_E_NOMEM;
3600 }
3601 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3602 if(NULL == pWdaParams)
3603 {
3604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3605 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3606 VOS_ASSERT(0);
3607 vos_mem_free(wdiConfigBssReqParam);
3608 return VOS_STATUS_E_NOMEM;
3609 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3611 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3612 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3613 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3614 configBssReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3615 /* Store Init Req pointer, as this will be used for response */
3616 /* store Params pass it to WDI */
3617 pWdaParams->pWdaContext = pWDA;
3618 pWdaParams->wdaMsgParam = configBssReqParam;
3619 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3620 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
3621 (WDI_ConfigBSSRspCb )WDA_ConfigBssReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3622 if(IS_WDI_STATUS_FAILURE(status))
3623 {
3624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3625 "Failure in Config BSS WDI API, free all the memory " );
3626 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3627 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3628 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3629 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3630 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3631 return CONVERT_WDI2VOS_STATUS(status) ;
3632}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3633#ifdef ENABLE_HAL_COMBINED_MESSAGES
3634/*
3635 * FUNCTION: WDA_PostAssocReqCallback
3636 * Post ASSOC req callback, send RSP back to PE
3637 */
3638void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3639 void* pUserData)
3640{
3641 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3642 tPostAssocParams *postAssocReqParam =
3643 (tPostAssocParams *)pWDA->wdaMsgParam ;
3644 /*STA context within the BSS Params*/
3645 tAddStaParams *staPostAssocParam =
3646 &postAssocReqParam->addBssParams.staContext ;
3647 /*STA Params for self STA*/
3648 tAddStaParams *selfStaPostAssocParam =
3649 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3651 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3652 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3653 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3654 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3655 {
3656 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3657 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3658 sizeof(tSirMacAddr)) ;
3659 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3660 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3661 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3662 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3663 }
3664 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3665 pWDA->wdaWdiApiMsgParam = NULL;
3666 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3667 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3668 return ;
3669}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3670/*
3671 * FUNCTION: WDA_ProcessPostAssocReq
3672 * Trigger POST ASSOC processing in WDI
3673 */
3674VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3675 tPostAssocParams *postAssocReqParam)
3676{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3677 WDI_Status status = WDI_STATUS_SUCCESS ;
3678
3679 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3680 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3681 sizeof(WDI_PostAssocReqParamsType)) ;
3682 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3683 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3684
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3685 if(NULL == wdiPostAssocReqParam)
3686 {
3687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3688 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3689 VOS_ASSERT(0);
3690 return VOS_STATUS_E_NOMEM;
3691 }
3692
3693 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3694 {
3695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3696 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3697 VOS_ASSERT(0);
3698 return VOS_STATUS_E_FAILURE;
3699 }
3700
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3701 /* update BSS params into WDI structure */
3702 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3703 &postAssocReqParam->addBssParams) ;
3704 /* update STA params into WDI structure */
3705 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3706 &postAssocReqParam->addStaParams) ;
3707
3708 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
3709 postAssocReqParam->addBssParams.highPerformance;
3710 WDA_UpdateEdcaParamsForAC(pWDA,
3711 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
3712 &postAssocReqParam->addBssParams.acbe);
3713 WDA_UpdateEdcaParamsForAC(pWDA,
3714 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
3715 &postAssocReqParam->addBssParams.acbk);
3716 WDA_UpdateEdcaParamsForAC(pWDA,
3717 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
3718 &postAssocReqParam->addBssParams.acvi);
3719 WDA_UpdateEdcaParamsForAC(pWDA,
3720 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
3721 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3722 /* Store Init Req pointer, as this will be used for response */
3723 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3724 /* store Params pass it to WDI */
3725 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3726 status = WDI_PostAssocReq(wdiPostAssocReqParam,
3727 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3728 if(IS_WDI_STATUS_FAILURE(status))
3729 {
3730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3731 "Failure in Post Assoc WDI API, free all the memory " );
3732 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3733 pWDA->wdaWdiApiMsgParam = NULL;
3734 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3735 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3736 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
3737 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3738 return CONVERT_WDI2VOS_STATUS(status) ;
3739}
3740#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3741/*
3742 * FUNCTION: WDA_AddStaReqCallback
3743 * ADD STA req callback, send RSP back to PE
3744 */
3745void WDA_AddStaReqCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
3746 void* pUserData)
3747{
3748 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3749 tWDA_CbContext *pWDA;
3750 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3752 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3753 if(NULL == pWdaParams)
3754 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3755 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,"%s: pWdaParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3756 VOS_ASSERT(0) ;
3757 return ;
3758 }
3759 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3760 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3761 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3762 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3763 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
3764 {
3765 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
3766 /*TODO: UMAC structure doesn't have these fields*/
3767 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
3768 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
3769 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
3770 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
3771 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
3772 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3773#ifdef FEATURE_WLAN_TDLS
3774 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
3775 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
3776#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3777 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3778#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3779 {
3780 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
3781 wdiConfigStaRsp->ucBssIdx;
3782 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
3783 WDA_VALID_STA_INDEX ;
3784 }
3785 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
3786 {
3787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3788 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3789 VOS_ASSERT(0) ;
3790 return ;
3791 }
3792 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3793 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3794 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3795 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3796 return ;
3797}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3798/*
3799 * FUNCTION: WDA_ConfigStaReq
3800 * Trigger Config STA processing in WDI
3801 */
3802VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
3803 tAddStaParams *addStaReqParam)
3804{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3805 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3806 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
3807 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
3808 sizeof(WDI_ConfigSTAReqParamsType)) ;
3809 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3810 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3811 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3812 if(NULL == wdiConfigStaReqParam)
3813 {
3814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3815 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3816 VOS_ASSERT(0);
3817 return VOS_STATUS_E_NOMEM;
3818 }
3819 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3820 if(NULL == pWdaParams)
3821 {
3822 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3823 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3824 VOS_ASSERT(0);
3825 vos_mem_free(wdiConfigStaReqParam);
3826 return VOS_STATUS_E_NOMEM;
3827 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3828 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3829 /* update STA params into WDI structure */
3830 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
3831 addStaReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3832 /* Store Init Req pointer, as this will be used for response */
3833 /* store Params pass it to WDI */
3834 pWdaParams->pWdaContext = pWDA;
3835 pWdaParams->wdaMsgParam = addStaReqParam;
3836 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3837 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
3838 (WDI_ConfigSTARspCb )WDA_AddStaReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3839 if(IS_WDI_STATUS_FAILURE(status))
3840 {
3841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3842 "Failure in Config STA WDI API, free all the memory " );
3843 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3844 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3845 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3846 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
3847 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3848 return CONVERT_WDI2VOS_STATUS(status) ;
3849}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3850/*
3851 * FUNCTION: WDA_DelBSSReqCallback
3852 * Dens DEL BSS RSP back to PE
3853 */
3854void WDA_DelBSSReqCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
3855 void* pUserData)
3856{
3857 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3858 tWDA_CbContext *pWDA;
3859 tDeleteBssParams *delBssReqParam;
3860 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3862 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3863 if(NULL == pWdaParams)
3864 {
3865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3866 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3867 VOS_ASSERT(0) ;
3868 return ;
3869 }
3870 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3871 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3872 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3873 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
3874 {
3875 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
3876 sizeof(tSirMacAddr)) ;
3877 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3878 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
3879 {
3880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3881 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3882 VOS_ASSERT(0) ;
3883 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3884 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
3885 {
3886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3887 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3888 VOS_ASSERT(0) ;
3889 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3890 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
3891 {
3892 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3893 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3894 VOS_ASSERT(0) ;
3895 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3896
3897 WLANTL_StartForwarding(staIdx,0,0);
3898
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3899 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3900 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3901 /* reset the the system role*/
3902 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
3903
3904 /* Reset the BA related information */
3905 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
3906 {
3907 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
3908 {
3909 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
3910 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
3911 /* Reset framesTxed counters here */
3912 for(tid = 0; tid < STACFG_MAX_TC; tid++)
3913 {
3914 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
3915 }
3916 }
3917 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3918 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3919 return ;
3920}
3921
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3922/*
3923 * FUNCTION: WDA_ProcessDelBssReq
3924 * Init DEL BSS req with WDI
3925 */
3926VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
3927 tDeleteBssParams *delBssParam)
3928{
3929 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3930 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
3931 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
3932 sizeof(WDI_DelBSSReqParamsType)) ;
3933 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3934 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3935 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3936 if(NULL == wdiDelBssReqParam)
3937 {
3938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3939 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3940 VOS_ASSERT(0);
3941 return VOS_STATUS_E_NOMEM;
3942 }
3943 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3944 if(NULL == pWdaParams)
3945 {
3946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3947 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3948 VOS_ASSERT(0);
3949 vos_mem_free(wdiDelBssReqParam);
3950 return VOS_STATUS_E_NOMEM;
3951 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3952 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
3953 wdiDelBssReqParam->wdiReqStatusCB = NULL ;
3954
3955 /* Store Init Req pointer, as this will be used for response */
3956 /* store Params pass it to WDI */
3957 pWdaParams->pWdaContext = pWDA;
3958 pWdaParams->wdaMsgParam = delBssParam;
3959 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3960 status = WDI_DelBSSReq(wdiDelBssReqParam,
3961 (WDI_DelBSSRspCb )WDA_DelBSSReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3962 if(IS_WDI_STATUS_FAILURE(status))
3963 {
3964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3965 "Failure in Del BSS WDI API, free all the memory " );
3966 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3967 vos_mem_free(pWdaParams) ;
3968 delBssParam->status = eSIR_FAILURE ;
3969 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
3970 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3971 return CONVERT_WDI2VOS_STATUS(status) ;
3972}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3973/*
3974 * FUNCTION: WDA_DelSTAReqCallback
3975 * Dens DEL STA RSP back to PE
3976 */
3977void WDA_DelSTAReqCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
3978 void* pUserData)
3979{
3980 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3981 tWDA_CbContext *pWDA;
3982 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3984 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3985 if(NULL == pWdaParams)
3986 {
3987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3988 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3989 VOS_ASSERT(0) ;
3990 return ;
3991 }
3992 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3993 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3994 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3995 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
3996 {
3997 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
3998 {
3999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4000 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4001 VOS_ASSERT(0) ;
4002 }
4003 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4004 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4005 }
4006 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4007 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4008 /*Reset the BA information corresponding to this STAIdx */
4009 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
4010 WDA_INVALID_STA_INDEX;
4011 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
4012
4013 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4014 return ;
4015}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4016/*
4017 * FUNCTION: WDA_ProcessDelStaReq
4018 * Init DEL STA req with WDI
4019 */
4020VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
4021 tDeleteStaParams *delStaParam)
4022{
4023 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4024 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
4025 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
4026 sizeof(WDI_DelSTAReqParamsType)) ;
4027 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4029 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4030 if(NULL == wdiDelStaReqParam)
4031 {
4032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4033 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4034 VOS_ASSERT(0);
4035 return VOS_STATUS_E_NOMEM;
4036 }
4037 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4038 if(NULL == pWdaParams)
4039 {
4040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4041 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4042 VOS_ASSERT(0);
4043 vos_mem_free(wdiDelStaReqParam);
4044 return VOS_STATUS_E_NOMEM;
4045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4046 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
4047 wdiDelStaReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4048 /* Store Init Req pointer, as this will be used for response */
4049 /* store Params pass it to WDI */
4050 pWdaParams->pWdaContext = pWDA;
4051 pWdaParams->wdaMsgParam = delStaParam;
4052 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4053 status = WDI_DelSTAReq(wdiDelStaReqParam,
4054 (WDI_DelSTARspCb )WDA_DelSTAReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4055 if(IS_WDI_STATUS_FAILURE(status))
4056 {
4057 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4058 "Failure in Del STA WDI API, free all the memory status = %d",
4059 status );
4060 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4061 vos_mem_free(pWdaParams) ;
4062 delStaParam->status = eSIR_FAILURE ;
4063 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
4064 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4065 return CONVERT_WDI2VOS_STATUS(status) ;
4066}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4067void WDA_ProcessAddStaSelfRsp(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
4068{
4069 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4070 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4071 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4072 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4073 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4074 if(NULL == pWdaParams)
4075 {
4076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4077 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4078 VOS_ASSERT(0) ;
4079 return ;
4080 }
4081 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4082 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4083 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4084 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4085 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
4086 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
4087 pwdiAddSTASelfRsp->macSelfSta,
4088 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4089 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
4090 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
4091 if (pAddStaSelfRsp->status == eSIR_FAILURE)
4092 {
4093 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
4094 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
4095 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4096 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4097 return ;
4098}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4099
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4100/*
4101 * FUNCTION: WDA_ProcessAddStaSelfReq
4102 *
4103 */
4104VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
4105{
4106 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4107 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4108 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
4109 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
4110 sizeof(WDI_AddSTASelfReqParamsType)) ;
4111 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4113 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4114 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4115 if( NULL == wdiAddStaSelfReq )
4116 {
4117 VOS_ASSERT( 0 );
4118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4119 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4120 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4121 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4122 return( VOS_STATUS_E_NOMEM );
4123 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4124 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4125 if( NULL == pWdaParams )
4126 {
4127 VOS_ASSERT( 0 );
4128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4129 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4130 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4131 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4132 vos_mem_free(wdiAddStaSelfReq) ;
4133 return( VOS_STATUS_E_NOMEM );
4134 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4135 wdiAddStaSelfReq->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4136 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]4137 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4138 /* Store Init Req pointer, as this will be used for response */
4139 /* store Params pass it to WDI */
4140 pWdaParams->pWdaContext = pWDA;
4141 pWdaParams->wdaMsgParam = pAddStaSelfReq;
4142 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4143 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq, WDA_ProcessAddStaSelfRsp, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4144
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4145 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4146 {
4147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4148 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4149 wstatus );
4150 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4151 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4152 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4153 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
4154 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4155 pAddStaSelfReq->status = eSIR_FAILURE ;
4156 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
4157 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4158 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4159}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4160/*
4161 * FUNCTION: WDA_DelSTASelfRespCallback
4162 *
4163 */
4164void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4165 wdiDelStaSelfRspParams , void* pUserData)
4166{
4167 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4168 tWDA_CbContext *pWDA;
4169 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4171 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4172 if (NULL == pWdaParams)
4173 {
4174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4175 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4176 VOS_ASSERT(0);
4177 return;
4178 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4179 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4180 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4181 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4182 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4183
4184 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4185 vos_mem_free(pWdaParams) ;
4186
4187 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4188 return ;
4189}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4190/*
4191 * FUNCTION: WDA_DelSTASelfReqCallback
4192 *
4193 */
4194void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4195 void* pUserData)
4196{
4197 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4198 tWDA_CbContext *pWDA;
4199 tDelStaSelfParams *delStaSelfParams;
4200
4201 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4202 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4203 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4204
4205 if (NULL == pWdaParams)
4206 {
4207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4208 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4209 VOS_ASSERT(0);
4210 return;
4211 }
4212
4213 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4214 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4215
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4216 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4217
4218 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4219 {
4220 VOS_ASSERT(0);
4221 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4222 vos_mem_free(pWdaParams) ;
4223 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4224 }
4225
4226 return ;
4227}
4228
4229/*
4230 * FUNCTION: WDA_DelSTASelfReq
4231 * Trigger Config STA processing in WDI
4232 */
4233VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4234 tDelStaSelfParams* pDelStaSelfReqParam)
4235{
4236 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4237 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4238 tWDA_ReqParams *pWdaParams = NULL;
4239 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4240 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4241 sizeof(WDI_DelSTASelfReqParamsType)) ;
4242
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4244 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4245 if( NULL == wdiDelStaSelfReq )
4246 {
4247 VOS_ASSERT( 0 );
4248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4249 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4250 return( VOS_STATUS_E_NOMEM );
4251 }
4252
4253 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4254 if( NULL == pWdaParams )
4255 {
4256 VOS_ASSERT( 0 );
4257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4258 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4259 vos_mem_free(wdiDelStaSelfReq) ;
4260 return( VOS_STATUS_E_NOMEM );
4261 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4262 pWdaParams->pWdaContext = pWDA;
4263 /* Store param pointer as passed in by caller */
4264 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4265 /* store Params pass it to WDI */
4266 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4267 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4268 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4269
4270 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4271 wdiDelStaSelfReq->pUserData = pWdaParams;
4272
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4273 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4274 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4275
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4276 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4277 {
4278 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4279 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4280 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4281 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4282 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4283 vos_mem_free(pWdaParams) ;
4284 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4285 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4286 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4287 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4288}
4289
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4290/*
4291 * FUNCTION: WDA_SendMsg
4292 * Send Message back to PE
4293 */
4294void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4295 void *pBodyptr, tANI_U32 bodyVal)
4296{
4297 tSirMsgQ msg = {0} ;
4298 tANI_U32 status = VOS_STATUS_SUCCESS ;
4299 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4300 msg.type = msgType;
4301 msg.bodyval = bodyVal;
4302 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4303 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4304 if (VOS_STATUS_SUCCESS != status)
4305 {
4306 if(NULL != pBodyptr)
4307 {
4308 vos_mem_free(pBodyptr);
4309 }
4310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4311 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4312 VOS_ASSERT(0) ;
4313 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4314 return ;
4315}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4316/*
4317 * FUNCTION: WDA_UpdateBSSParams
4318 * Translated WDA/PE BSS info into WDI BSS info..
4319 */
4320void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4321 WDI_ConfigBSSReqInfoType *wdiBssParams,
4322 tAddBssParams *wdaBssParams)
4323{
4324 v_U8_t keyIndex = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4325 /* copy bssReq Params to WDI structure */
4326 vos_mem_copy(wdiBssParams->macBSSID,
4327 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4328 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4329 sizeof(tSirMacAddr)) ;
4330 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4331 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4332 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4333 wdiBssParams->ucShortSlotTimeSupported =
4334 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4335 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4336 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4337 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4338 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4339 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4340
4341 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4342 wdiBssParams->ucTXOPProtectionFullSupport =
4343 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4344 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4345 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4346 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4347 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4348 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4349 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4350 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4351
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4352 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4353
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4354 /* copy SSID into WDI structure */
4355 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4356 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4357 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4358 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4359 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4360 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4361#ifdef WLAN_FEATURE_VOWIFI
4362 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4363#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4364 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4365 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4366#ifdef WLAN_FEATURE_VOWIFI_11R
4367 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4368 if(wdiBssParams->bExtSetStaKeyParamValid)
4369 {
4370 /* copy set STA key params to WDI structure */
4371 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4372 wdaBssParams->extSetStaKeyParam.staIdx;
4373 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4374 wdaBssParams->extSetStaKeyParam.encType;
4375 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4376 wdaBssParams->extSetStaKeyParam.wepType;
4377 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4378 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4379 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4380 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4381 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4382 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4383 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4384 {
4385 WDA_GetWepKeysFromCfg( pWDA,
4386 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4387 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4388 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4389 }
4390 else
4391 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4392 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4393 keyIndex++)
4394 {
4395 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4396 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4397 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4398 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4399 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4400 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4401 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4402 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4403 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4404 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4405 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4406 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
4407 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4408 wdaBssParams->extSetStaKeyParam.key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4409 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4410 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
4411 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4412 }
4413 }
4414 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4415 }
4416 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4417 {
4418 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4419 sizeof(wdaBssParams->extSetStaKeyParam) );
4420 }
4421#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4422#ifdef WLAN_FEATURE_11AC
4423 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4424 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4425#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4426
4427 return ;
4428}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4429/*
4430 * FUNCTION: WDA_UpdateSTAParams
4431 * Translated WDA/PE BSS info into WDI BSS info..
4432 */
4433void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4434 WDI_ConfigStaReqInfoType *wdiStaParams,
4435 tAddStaParams *wdaStaParams)
4436{
4437 tANI_U8 i = 0;
4438 /* Update STA params */
4439 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4440 sizeof(tSirMacAddr)) ;
4441 wdiStaParams->usAssocId = wdaStaParams->assocId;
4442 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4443 wdiStaParams->staIdx = wdaStaParams->staIdx;
4444
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4445 wdiStaParams->ucShortPreambleSupported =
4446 wdaStaParams->shortPreambleSupported;
4447 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4448 sizeof(tSirMacAddr)) ;
4449 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4450
4451 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4452
4453 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4454 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4455 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4456 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
4457 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
4458 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
4459 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
4460
4461 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
4462 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4463 wdiStaParams->wdiSupportedRates.opRateMode =
4464 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4465 for(i = 0;i < WDI_NUM_11B_RATES;i++)
4466 {
4467 wdiStaParams->wdiSupportedRates.llbRates[i] =
4468 wdaStaParams->supportedRates.llbRates[i];
4469 }
4470 for(i = 0;i < WDI_NUM_11A_RATES;i++)
4471 {
4472 wdiStaParams->wdiSupportedRates.llaRates[i] =
4473 wdaStaParams->supportedRates.llaRates[i];
4474 }
4475 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
4476 {
4477 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
4478 wdaStaParams->supportedRates.aniLegacyRates[i];
4479 }
4480 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
4481 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4482#ifdef WLAN_FEATURE_11AC
4483 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
4484 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
4485 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
4486 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
4487#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4488 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
4489 {
4490 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
4491 wdaStaParams->supportedRates.supportedMCSSet[i];
4492 }
4493 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
4494 wdaStaParams->supportedRates.rxHighestDataRate;
4495
4496 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
4497
4498 wdiStaParams->wdiAction = wdaStaParams->updateSta;
4499
4500 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
4501 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
4502 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
4503
4504 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
4505 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
4506 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
4507 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4508 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4509#ifdef WLAN_FEATURE_11AC
4510 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
4511 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]4512 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]4513 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
4514 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
4515 * must be set by default */
4516 if ( wdiStaParams->vhtTxMUBformeeCapable )
4517 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4518#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]4519 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
4520 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4521 return ;
4522}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4523/*
4524 * -------------------------------------------------------------------------
4525 * CFG update to WDI
4526 * -------------------------------------------------------------------------
4527 */
4528
4529 /*
4530 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
4531 * Convert the WNI CFG ID to HAL CFG ID
4532 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4533static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4534{
4535 switch(wniCfgId)
4536 {
4537 case WNI_CFG_STA_ID:
4538 return QWLAN_HAL_CFG_STA_ID;
4539 case WNI_CFG_CURRENT_TX_ANTENNA:
4540 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
4541 case WNI_CFG_CURRENT_RX_ANTENNA:
4542 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
4543 case WNI_CFG_LOW_GAIN_OVERRIDE:
4544 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
4545 case WNI_CFG_POWER_STATE_PER_CHAIN:
4546 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
4547 case WNI_CFG_CAL_PERIOD:
4548 return QWLAN_HAL_CFG_CAL_PERIOD;
4549 case WNI_CFG_CAL_CONTROL:
4550 return QWLAN_HAL_CFG_CAL_CONTROL;
4551 case WNI_CFG_PROXIMITY:
4552 return QWLAN_HAL_CFG_PROXIMITY;
4553 case WNI_CFG_NETWORK_DENSITY:
4554 return QWLAN_HAL_CFG_NETWORK_DENSITY;
4555 case WNI_CFG_MAX_MEDIUM_TIME:
4556 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
4557 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
4558 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
4559 case WNI_CFG_RTS_THRESHOLD:
4560 return QWLAN_HAL_CFG_RTS_THRESHOLD;
4561 case WNI_CFG_SHORT_RETRY_LIMIT:
4562 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
4563 case WNI_CFG_LONG_RETRY_LIMIT:
4564 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
4565 case WNI_CFG_FRAGMENTATION_THRESHOLD:
4566 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
4567 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
4568 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
4569 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
4570 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
4571 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
4572 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
4573 case WNI_CFG_FIXED_RATE:
4574 return QWLAN_HAL_CFG_FIXED_RATE;
4575 case WNI_CFG_RETRYRATE_POLICY:
4576 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
4577 case WNI_CFG_RETRYRATE_SECONDARY:
4578 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
4579 case WNI_CFG_RETRYRATE_TERTIARY:
4580 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
4581 case WNI_CFG_FORCE_POLICY_PROTECTION:
4582 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
4583 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
4584 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
4585 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
4586 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
4587 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
4588 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
4589 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
4590 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
4591 case WNI_CFG_MAX_BA_SESSIONS:
4592 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
4593 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
4594 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
4595 case WNI_CFG_PS_ENABLE_BCN_FILTER:
4596 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
4597 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
4598 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
4599 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
4600 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
4601 case WNI_CFG_STATS_PERIOD:
4602 return QWLAN_HAL_CFG_STATS_PERIOD;
4603 case WNI_CFG_CFP_MAX_DURATION:
4604 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
4605#if 0 /*This is not part of CFG*/
4606 case WNI_CFG_FRAME_TRANS_ENABLED:
4607 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
4608#endif
4609 case WNI_CFG_DTIM_PERIOD:
4610 return QWLAN_HAL_CFG_DTIM_PERIOD;
4611 case WNI_CFG_EDCA_WME_ACBK:
4612 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
4613 case WNI_CFG_EDCA_WME_ACBE:
4614 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
4615 case WNI_CFG_EDCA_WME_ACVI:
4616 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
4617 case WNI_CFG_EDCA_WME_ACVO:
4618 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
4619#if 0
4620 case WNI_CFG_TELE_BCN_WAKEUP_EN:
4621 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
4622 case WNI_CFG_TELE_BCN_TRANS_LI:
4623 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
4624 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
4625 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
4626 case WNI_CFG_TELE_BCN_MAX_LI:
4627 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
4628 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
4629 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
4630#endif
4631 case WNI_CFG_ENABLE_CLOSE_LOOP:
4632 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]4633 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
4634 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4635 default:
4636 {
4637 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4638 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4639 wniCfgId);
4640 return VOS_STATUS_E_INVAL;
4641 }
4642 }
4643}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4644/*
4645 * FUNCTION: WDA_UpdateCfgCallback
4646 *
4647 */
4648void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
4649{
4650 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4651 WDI_UpdateCfgReqParamsType *wdiCfgParam =
4652 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4654 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4655 /*
4656 * currently there is no response message is expected between PE and
4657 * WDA, Failure return from WDI is a ASSERT condition
4658 */
4659 if(WDI_STATUS_SUCCESS != wdiStatus)
4660 {
4661 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4662 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4663 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
4664 }
4665
4666 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
4667 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4668 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4669 return ;
4670}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4671/*
4672 * FUNCTION: WDA_UpdateCfg
4673 *
4674 */
4675VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
4676{
4677
4678 WDI_Status status = WDI_STATUS_SUCCESS ;
4679 tANI_U32 val =0;
4680 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
4681 tHalCfg *configData;
4682 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
4683 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4685 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4686 if (NULL == pMac )
4687 {
4688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4689 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4690 return VOS_STATUS_E_FAILURE;
4691 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4692 if(WDA_START_STATE != pWDA->wdaState)
4693 {
4694 return VOS_STATUS_E_FAILURE;
4695 }
4696
4697 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
4698 {
4699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4700 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4701 VOS_ASSERT(0);
4702 return VOS_STATUS_E_FAILURE;
4703 }
4704
4705 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
4706 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4707 if(NULL == wdiCfgReqParam)
4708 {
4709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4710 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4711 VOS_ASSERT(0);
4712 return VOS_STATUS_E_NOMEM;
4713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4714 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
4715 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4716 if(NULL == wdiCfgReqParam->pConfigBuffer)
4717 {
4718 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4719 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4720 vos_mem_free(wdiCfgReqParam);
4721 VOS_ASSERT(0);
4722 return VOS_STATUS_E_NOMEM;
4723 }
4724
4725 /*convert the WNI CFG Id to HAL CFG Id*/
4726 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
4727 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
4728
4729 /*TODO: revisit this for handling string parameters */
4730 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
4731 &val) != eSIR_SUCCESS)
4732 {
4733 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4734 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4735 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
4736 vos_mem_free(wdiCfgReqParam);
4737 return eSIR_FAILURE;
4738 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4739 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
4740 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
4741 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
4742 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
4743 wdiCfgReqParam->wdiReqStatusCB = NULL ;
4744
4745 /* store Params pass it to WDI */
4746 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4747#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
4748 status = WDI_UpdateCfgReq(wdiCfgReqParam,
4749 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4750 if(IS_WDI_STATUS_FAILURE(status))
4751 {
4752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4753 "Failure in Update CFG WDI API, free all the memory " );
4754 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4755 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4756 pWDA->wdaWdiCfgApiMsgParam = NULL;
4757 /* Failure is not expected */
4758 VOS_ASSERT(0) ;
4759 }
4760#else
4761 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4762 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4763 pWDA->wdaWdiCfgApiMsgParam = NULL;
4764#endif
4765 return CONVERT_WDI2VOS_STATUS(status) ;
4766}
4767
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4768VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
4769 v_U8_t *pDefaultKeyId,
4770 v_U8_t *pNumKeys,
4771 WDI_KeysType *pWdiKeys )
4772{
4773 v_U32_t i, j, defKeyId = 0;
4774 v_U32_t val = SIR_MAC_KEY_LENGTH;
4775 VOS_STATUS status = WDI_STATUS_SUCCESS;
4776 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4777 if (NULL == pMac )
4778 {
4779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4780 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4781 return VOS_STATUS_E_FAILURE;
4782 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4783 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
4784 &defKeyId ))
4785 {
4786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4787 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
4788 }
4789
4790 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4791 /* Need to extract ALL of the configured WEP Keys */
4792 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
4793 {
4794 val = SIR_MAC_KEY_LENGTH;
4795 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
4796 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
4797 pWdiKeys[j].key,
4798 &val ))
4799 {
4800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4801 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4802 }
4803 else
4804 {
4805 pWdiKeys[j].keyId = (tANI_U8) i;
4806 /*
4807 * Actually, a DC (Don't Care) because
4808 * this is determined (and set) by PE/MLME
4809 */
4810 pWdiKeys[j].unicast = 0;
4811 /*
4812 * Another DC (Don't Care)
4813 */
4814 pWdiKeys[j].keyDirection = eSIR_TX_RX;
4815 /* Another DC (Don't Care). Unused for WEP */
4816 pWdiKeys[j].paeRole = 0;
4817 /* Determined from wlan_cfgGetStr() above.*/
4818 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4819 j++;
4820 *pNumKeys = (tANI_U8) j;
4821 }
4822 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4823 return status;
4824}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4825/*
4826 * FUNCTION: WDA_SetBssKeyReqCallback
4827 * send SET BSS key RSP back to PE
4828 */
4829void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
4830{
4831 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4832 tWDA_CbContext *pWDA;
4833 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4834 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4835 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4836 if(NULL == pWdaParams)
4837 {
4838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4839 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4840 VOS_ASSERT(0) ;
4841 return ;
4842 }
4843 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4844 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4845 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4846 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4847 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4848 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4849 return ;
4850}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4851/*
4852 * FUNCTION: WDA_ProcessSetBssKeyReq
4853 * Request to WDI for programming the BSS key( key for
4854 * broadcast/multicast frames Encryption)
4855 */
4856VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
4857 tSetBssKeyParams *setBssKeyParams )
4858{
4859 WDI_Status status = WDI_STATUS_SUCCESS ;
4860 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
4861 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
4862 sizeof(WDI_SetBSSKeyReqParamsType)) ;
4863 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4864 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4866 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4867 if(NULL == wdiSetBssKeyParam)
4868 {
4869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4870 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4871 VOS_ASSERT(0);
4872 return VOS_STATUS_E_NOMEM;
4873 }
4874 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4875 if(NULL == pWdaParams)
4876 {
4877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4878 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4879 VOS_ASSERT(0);
4880 vos_mem_free(wdiSetBssKeyParam);
4881 return VOS_STATUS_E_NOMEM;
4882 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4883 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4884 /* copy set BSS params to WDI structure */
4885 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
4886 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
4887 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4888 if(setBssKeyParams->encType != eSIR_ED_NONE)
4889 {
4890 if( setBssKeyParams->numKeys == 0 &&
4891 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
4892 setBssKeyParams->encType == eSIR_ED_WEP104))
4893 {
4894 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4895 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
4896 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
4897 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
4898 }
4899 else
4900 {
4901 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
4902 {
4903 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
4904 setBssKeyParams->key[keyIndex].keyId;
4905 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
4906 setBssKeyParams->key[keyIndex].unicast;
4907 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
4908 setBssKeyParams->key[keyIndex].keyDirection;
4909 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
4910 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4911 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
4912 setBssKeyParams->key[keyIndex].paeRole;
4913 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
4914 setBssKeyParams->key[keyIndex].keyLength;
4915 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
4916 setBssKeyParams->key[keyIndex].key,
4917 SIR_MAC_MAX_KEY_LENGTH);
4918 }
4919 }
4920 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4921 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
4922 setBssKeyParams->singleTidRc;
4923 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4924 /* Store set key pointer, as this will be used for response */
4925 /* store Params pass it to WDI */
4926 pWdaParams->pWdaContext = pWDA;
4927 pWdaParams->wdaMsgParam = setBssKeyParams;
4928 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4929 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
4930 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
4931
4932 if(IS_WDI_STATUS_FAILURE(status))
4933 {
4934 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4935 "Failure in Set BSS Key Req WDI API, free all the memory " );
4936 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4937 vos_mem_free(pWdaParams) ;
4938 setBssKeyParams->status = eSIR_FAILURE ;
4939 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
4940 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4941 return CONVERT_WDI2VOS_STATUS(status) ;
4942}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4943/*
4944 * FUNCTION: WDA_RemoveBssKeyReqCallback
4945 * send SET BSS key RSP back to PE
4946 */
4947void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
4948{
4949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4950 tWDA_CbContext *pWDA;
4951 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4953 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4954 if(NULL == pWdaParams)
4955 {
4956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4957 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4958 VOS_ASSERT(0) ;
4959 return ;
4960 }
4961 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4962 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4963 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4964 vos_mem_free(pWdaParams) ;
4965
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4966 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4967 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4968 return ;
4969}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4970/*
4971 * FUNCTION: WDA_ProcessRemoveBssKeyReq
4972 * Request to WDI to remove the BSS key( key for broadcast/multicast
4973 * frames Encryption)
4974 */
4975VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
4976 tRemoveBssKeyParams *removeBssKeyParams )
4977{
4978 WDI_Status status = WDI_STATUS_SUCCESS ;
4979 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
4980 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
4981 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
4982 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4984 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4985 if(NULL == wdiRemoveBssKeyParam)
4986 {
4987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4988 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4989 VOS_ASSERT(0);
4990 return VOS_STATUS_E_NOMEM;
4991 }
4992 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4993 if(NULL == pWdaParams)
4994 {
4995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4996 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4997 VOS_ASSERT(0);
4998 vos_mem_free(wdiRemoveBssKeyParam);
4999 return VOS_STATUS_E_NOMEM;
5000 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5001 /* copy Remove BSS key params to WDI structure*/
5002 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
5003 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
5004 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
5005 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
5006 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5007 /* Store remove key pointer, as this will be used for response */
5008 /* store Params pass it to WDI */
5009 pWdaParams->pWdaContext = pWDA;
5010 pWdaParams->wdaMsgParam = removeBssKeyParams;
5011 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5012 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
5013 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5014 if(IS_WDI_STATUS_FAILURE(status))
5015 {
5016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5017 "Failure in Remove BSS Key Req WDI API, free all the memory " );
5018 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5019 vos_mem_free(pWdaParams) ;
5020 removeBssKeyParams->status = eSIR_FAILURE ;
5021 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
5022 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5023 return CONVERT_WDI2VOS_STATUS(status) ;
5024}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5025/*
5026 * FUNCTION: WDA_SetBssKeyReqCallback
5027 * send SET BSS key RSP back to PE
5028 */
5029void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
5030{
5031 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5032 tWDA_CbContext *pWDA;
5033 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5035 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5036 if(NULL == pWdaParams)
5037 {
5038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5039 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5040 VOS_ASSERT(0) ;
5041 return ;
5042 }
5043 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5044 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5045 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5046 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5047 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5048 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5049 return ;
5050}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5051/*
5052 * FUNCTION: WDA_ProcessSetStaKeyReq
5053 * Request to WDI for programming the STA key( key for Unicast frames
5054 * Encryption)
5055 */
5056VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
5057 tSetStaKeyParams *setStaKeyParams )
5058{
5059 WDI_Status status = WDI_STATUS_SUCCESS ;
5060 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5061 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5062 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5063 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5064 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5066 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5067 if(NULL == wdiSetStaKeyParam)
5068 {
5069 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5070 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5071 VOS_ASSERT(0);
5072 return VOS_STATUS_E_NOMEM;
5073 }
5074 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5075 if(NULL == pWdaParams)
5076 {
5077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5078 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5079 VOS_ASSERT(0);
5080 vos_mem_free(wdiSetStaKeyParam);
5081 return VOS_STATUS_E_NOMEM;
5082 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5083 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5084 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5085 /* copy set STA key params to WDI structure */
5086 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5087 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5088 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5089 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5090 if(setStaKeyParams->encType != eSIR_ED_NONE)
5091 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5092 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5093 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
5094 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
5095 {
5096 WDA_GetWepKeysFromCfg( pWDA,
5097 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
5098 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
5099 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
5100 }
5101 else
5102 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5103 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5104 keyIndex++)
5105 {
5106 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5107 setStaKeyParams->key[keyIndex].keyId;
5108 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5109 setStaKeyParams->key[keyIndex].unicast;
5110 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5111 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5112 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5113 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5114 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5115 setStaKeyParams->key[keyIndex].paeRole;
5116 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5117 setStaKeyParams->key[keyIndex].keyLength;
5118 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5119 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5120 /* set default index to index which have key direction as WDI_TX_DEFAULT */
5121 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
5122 {
5123 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
5124 }
5125 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5126 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5127 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5128 }
5129 }
5130 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
5131 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5132 /* Store set key pointer, as this will be used for response */
5133 /* store Params pass it to WDI */
5134 pWdaParams->pWdaContext = pWDA;
5135 pWdaParams->wdaMsgParam = setStaKeyParams;
5136 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5137 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
5138 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5139 if(IS_WDI_STATUS_FAILURE(status))
5140 {
5141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5142 "Failure in set STA Key Req WDI API, free all the memory " );
5143 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5144 vos_mem_free(pWdaParams) ;
5145 setStaKeyParams->status = eSIR_FAILURE ;
5146 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
5147 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5148 return CONVERT_WDI2VOS_STATUS(status) ;
5149}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5150/*
5151 * FUNCTION: WDA_SetBcastStaKeyReqCallback
5152 * send SET Bcast STA key RSP back to PE
5153 */
5154void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
5155{
5156 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5157 tWDA_CbContext *pWDA;
5158 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5160 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5161 if(NULL == pWdaParams)
5162 {
5163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5164 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5165 VOS_ASSERT(0) ;
5166 return ;
5167 }
5168 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5169 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5170 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5171 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5172 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5173 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5174 return ;
5175}
5176
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5177/*
5178 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5179 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5180 * Encryption)
5181 */
5182VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5183 tSetStaKeyParams *setStaKeyParams )
5184{
5185 WDI_Status status = WDI_STATUS_SUCCESS ;
5186 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5187 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5188 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5189 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5190 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5191 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5192 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5193 if(NULL == wdiSetStaKeyParam)
5194 {
5195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5196 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5197 VOS_ASSERT(0);
5198 return VOS_STATUS_E_NOMEM;
5199 }
5200 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5201 if(NULL == pWdaParams)
5202 {
5203 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5204 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5205 VOS_ASSERT(0);
5206 vos_mem_free(wdiSetStaKeyParam);
5207 return VOS_STATUS_E_NOMEM;
5208 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5209 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5210 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5211 /* copy set STA key params to WDI structure */
5212 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5213 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5214 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5215 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5216 if(setStaKeyParams->encType != eSIR_ED_NONE)
5217 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5218 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5219 keyIndex++)
5220 {
5221 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5222 setStaKeyParams->key[keyIndex].keyId;
5223 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5224 setStaKeyParams->key[keyIndex].unicast;
5225 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5226 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5227 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5228 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5229 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5230 setStaKeyParams->key[keyIndex].paeRole;
5231 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5232 setStaKeyParams->key[keyIndex].keyLength;
5233 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5234 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5235 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5236 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5237 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5238 }
5239 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5240 /* Store set key pointer, as this will be used for response */
5241 /* store Params pass it to WDI */
5242 pWdaParams->pWdaContext = pWDA;
5243 pWdaParams->wdaMsgParam = setStaKeyParams;
5244 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5245 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5246 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5247 if(IS_WDI_STATUS_FAILURE(status))
5248 {
5249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5250 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5251 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5252 vos_mem_free(pWdaParams) ;
5253 setStaKeyParams->status = eSIR_FAILURE ;
5254 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5255 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5256 return CONVERT_WDI2VOS_STATUS(status) ;
5257}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5258/*
5259 * FUNCTION: WDA_RemoveStaKeyReqCallback
5260 * send SET BSS key RSP back to PE
5261 */
5262void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5263{
5264 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5265 tWDA_CbContext *pWDA;
5266 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5268 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5269 if(NULL == pWdaParams)
5270 {
5271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5272 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5273 VOS_ASSERT(0) ;
5274 return ;
5275 }
5276 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5277 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5278 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5279 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5280 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5281 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5282 return ;
5283}
5284
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5285/*
5286 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5287 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5288 */
5289VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5290 tRemoveStaKeyParams *removeStaKeyParams )
5291{
5292 WDI_Status status = WDI_STATUS_SUCCESS ;
5293 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
5294 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
5295 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
5296 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5298 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5299 if(NULL == wdiRemoveStaKeyParam)
5300 {
5301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5302 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5303 VOS_ASSERT(0);
5304 return VOS_STATUS_E_NOMEM;
5305 }
5306 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5307 if(NULL == pWdaParams)
5308 {
5309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5310 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5311 VOS_ASSERT(0);
5312 vos_mem_free(wdiRemoveStaKeyParam);
5313 return VOS_STATUS_E_NOMEM;
5314 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5315 /* copy remove STA key params to WDI structure*/
5316 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
5317 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
5318 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
5319 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
5320 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5321 /* Store remove key pointer, as this will be used for response */
5322 /* store Params pass it to WDI */
5323 pWdaParams->pWdaContext = pWDA;
5324 pWdaParams->wdaMsgParam = removeStaKeyParams;
5325 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5326 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
5327 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5328 if(IS_WDI_STATUS_FAILURE(status))
5329 {
5330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5331 "Failure in remove STA Key Req WDI API, free all the memory " );
5332 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5333 vos_mem_free(pWdaParams) ;
5334 removeStaKeyParams->status = eSIR_FAILURE ;
5335 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
5336 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5337 return CONVERT_WDI2VOS_STATUS(status) ;
5338}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5339/*
5340 * FUNCTION: WDA_IsHandleSetLinkStateReq
5341 * Update the WDA state and return the status to handle this message or not
5342 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5343WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
5344 tWDA_CbContext *pWDA,
5345 tLinkStateParams *linkStateParams)
5346{
5347 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5348 switch(linkStateParams->state)
5349 {
5350 case eSIR_LINK_PREASSOC_STATE:
5351 case eSIR_LINK_BTAMP_PREASSOC_STATE:
5352 /*
5353 * set the WDA state to PRE ASSOC
5354 * copy the BSSID into pWDA to use it in join request and return,
5355 * No need to handle these messages.
5356 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5357 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
5358 {
5359 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5360 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5361 }
5362 else
5363 {
5364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5365 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5366 VOS_ASSERT(0);
5367 }
5368
5369 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
5370 {
5371 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5372 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5373 }
5374 else
5375 {
5376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5377 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5378 VOS_ASSERT(0);
5379 }
5380
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5381 /* UMAC is issuing the setlink state with PREASSOC twice (before set
5382 *channel and after ) so reset the WDA state to ready when the second
5383 * time UMAC issue the link state with PREASSOC
5384 */
5385 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
5386 {
5387 /* RESET WDA state back to WDA_READY_STATE */
5388 pWDA->wdaState = WDA_READY_STATE;
5389 }
5390 else
5391 {
5392 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
5393 }
5394 //populate linkState info in WDACbCtxt
5395 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5396 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5397 default:
5398 if(pWDA->wdaState != WDA_READY_STATE)
5399 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5400 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
5401 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
5402 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
5403 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
5404 *the ASSERT in WDA_Stop during module unload.*/
5405 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
5406 {
5407 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5408 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5409 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5410 else
5411 {
5412 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5413 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5414 status = WDA_IGNORE_SET_LINK_STATE;
5415 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5416 }
5417 break;
5418 }
5419
5420 return status;
5421}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5422/*
5423 * FUNCTION: WDA_SetLinkStateCallback
5424 * call back function for set link state from WDI
5425 */
5426void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
5427{
5428 tWDA_CbContext *pWDA;
5429 tLinkStateParams *linkStateParams;
5430 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5432 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5433 if(NULL == pWdaParams)
5434 {
5435 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5436 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5437 VOS_ASSERT(0) ;
5438 return ;
5439 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5440 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5441 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5442 /*
5443 * In STA mode start the BA activity check timer after association
5444 * and in AP mode start BA activity check timer after BSS start */
5445 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
5446 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]5447 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
5448 ((status == WDI_STATUS_SUCCESS) &&
5449 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5450 {
5451 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5452 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5453 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5454 /*
5455 * No respone required for WDA_SET_LINK_STATE so free the request
5456 * param here
5457 */
5458 if( pWdaParams != NULL )
5459 {
5460 if( pWdaParams->wdaWdiApiMsgParam != NULL )
5461 {
5462 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5463 }
5464 vos_mem_free(pWdaParams);
5465 }
5466 return ;
5467}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5468/*
5469 * FUNCTION: WDA_ProcessSetLinkState
5470 * Request to WDI to set the link status.
5471 */
5472VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
5473 tLinkStateParams *linkStateParams)
5474{
5475 WDI_Status status = WDI_STATUS_SUCCESS ;
5476 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
5477 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
5478 sizeof(WDI_SetLinkReqParamsType)) ;
5479 tWDA_ReqParams *pWdaParams ;
5480 tpAniSirGlobal pMac;
5481 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
5482
5483 if(NULL == pMac)
5484 {
5485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5486 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5487 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5488 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5489 return VOS_STATUS_E_FAILURE;
5490 }
5491
5492 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5493 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5494 if(NULL == wdiSetLinkStateParam)
5495 {
5496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5497 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5498 VOS_ASSERT(0);
5499 return VOS_STATUS_E_NOMEM;
5500 }
5501 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5502 if(NULL == pWdaParams)
5503 {
5504 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5505 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5506 VOS_ASSERT(0);
5507 vos_mem_free(wdiSetLinkStateParam);
5508 return VOS_STATUS_E_NOMEM;
5509 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5510 if(WDA_IGNORE_SET_LINK_STATE ==
5511 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
5512 {
5513 status = WDI_STATUS_E_FAILURE;
5514 }
5515 else
5516 {
5517 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
5518 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5519 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
5520 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5521 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
5522 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5523 pWdaParams->pWdaContext = pWDA;
5524 /* Store remove key pointer, as this will be used for response */
5525 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5526 /* store Params pass it to WDI */
5527 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
5528 /* Stop Timer only other than GO role and concurrent session */
5529 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]5530 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5531 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
5532 {
5533 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5534 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5535 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
5536 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5537 if(IS_WDI_STATUS_FAILURE(status))
5538 {
5539 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5540 "Failure in set link state Req WDI API, free all the memory " );
5541 }
5542 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5543 if(IS_WDI_STATUS_FAILURE(status))
5544 {
5545 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5546 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5547 vos_mem_free(pWdaParams);
5548 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5549 return CONVERT_WDI2VOS_STATUS(status) ;
5550}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5551/*
5552 * FUNCTION: WDA_GetStatsReqParamsCallback
5553 * send the response to PE with Stats received from WDI
5554 */
5555void WDA_GetStatsReqParamsCallback(
5556 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
5557 void* pUserData)
5558{
5559 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5560 tAniGetPEStatsRsp *pGetPEStatsRspParams;
5561
5562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5563 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5564 pGetPEStatsRspParams =
5565 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
5566 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
5567
5568 if(NULL == pGetPEStatsRspParams)
5569 {
5570 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5571 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5572 VOS_ASSERT(0);
5573 return;
5574 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5575 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
5576 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
5577 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
5578 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5579
5580 //Fill the Session Id Properly in PE
5581 pGetPEStatsRspParams->sessionId = 0;
5582 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5583 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5584 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
5585 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5586 vos_mem_copy( pGetPEStatsRspParams + 1,
5587 wdiGetStatsRsp + 1,
5588 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5589 /* send response to UMAC*/
5590 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
5591
5592 return;
5593}
5594
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5595/*
5596 * FUNCTION: WDA_ProcessGetStatsReq
5597 * Request to WDI to get the statistics
5598 */
5599VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
5600 tAniGetPEStatsReq *pGetStatsParams)
5601{
5602 WDI_Status status = WDI_STATUS_SUCCESS ;
5603 WDI_GetStatsReqParamsType wdiGetStatsParam;
5604 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5606 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5607 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
5608 pGetStatsParams->staId;
5609 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
5610 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5611 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5612 status = WDI_GetStatsReq(&wdiGetStatsParam,
5613 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5614 if(IS_WDI_STATUS_FAILURE(status))
5615 {
5616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5617 "Failure in Get Stats Req WDI API, free all the memory " );
5618 pGetPEStatsRspParams =
5619 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
5620 if(NULL == pGetPEStatsRspParams)
5621 {
5622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5623 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5624 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5625 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5626 return VOS_STATUS_E_NOMEM;
5627 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5628 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
5629 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
5630 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
5631 pGetPEStatsRspParams->rc = eSIR_FAILURE;
5632 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
5633 (void *)pGetPEStatsRspParams, 0) ;
5634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5635 /* Free the request message */
5636 vos_mem_free(pGetStatsParams);
5637 return CONVERT_WDI2VOS_STATUS(status);
5638}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5639
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]5640#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5641/*
5642 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
5643 * send the response to PE with roam Rssi received from WDI
5644 */
5645void WDA_GetRoamRssiReqParamsCallback(
5646 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
5647 void* pUserData)
5648{
5649 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5650 tWDA_CbContext *pWDA = NULL;
5651 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5652 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
5653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5654 "<------ %s " ,__func__);
5655 if(NULL == pWdaParams)
5656 {
5657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5658 "%s: pWdaParams received NULL", __func__);
5659 VOS_ASSERT(0) ;
5660 return ;
5661 }
5662 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5663 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
5664
5665 if(NULL == pGetRoamRssiReqParams)
5666 {
5667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5668 "%s: pGetRoamRssiReqParams received NULL", __func__);
5669 VOS_ASSERT(0);
5670 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5671 vos_mem_free(pWdaParams);
5672 return ;
5673 }
5674 pGetRoamRssiRspParams =
5675 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5676
5677 if(NULL == pGetRoamRssiRspParams)
5678 {
5679 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5680 "%s: VOS MEM Alloc Failure", __func__);
5681 VOS_ASSERT(0);
5682 return;
5683 }
5684 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
5685 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5686 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5687 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
5688 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
5689
5690 /* Assign get roam rssi req (backup) in to the response */
5691 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
5692
5693 /* free WDI command buffer */
5694 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5695 vos_mem_free(pWdaParams) ;
5696
5697 /* send response to UMAC*/
5698 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
5699
5700 return;
5701}
5702
5703
5704
5705/*
5706 * FUNCTION: WDA_ProcessGetRoamRssiReq
5707 * Request to WDI to get the statistics
5708 */
5709VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
5710 tAniGetRssiReq *pGetRoamRssiParams)
5711{
5712 WDI_Status status = WDI_STATUS_SUCCESS ;
5713 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
5714 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5715 tWDA_ReqParams *pWdaParams = NULL;
5716
5717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5718 "------> %s " ,__func__);
5719 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
5720 pGetRoamRssiParams->staId;
5721 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
5722
5723 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5724 if(NULL == pWdaParams)
5725 {
5726 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5727 "%s: VOS MEM Alloc Failure", __func__);
5728 VOS_ASSERT(0);
5729 return VOS_STATUS_E_NOMEM;
5730 }
5731
5732 /* Store Init Req pointer, as this will be used for response */
5733 pWdaParams->pWdaContext = pWDA;
5734
5735 /* Take Get roam Rssi req backup as it stores the callback to be called after
5736 receiving the response */
5737 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
5738 pWdaParams->wdaWdiApiMsgParam = NULL;
5739
5740 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
5741 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
5742 if(IS_WDI_STATUS_FAILURE(status))
5743 {
5744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5745 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
5746 pGetRoamRssiRspParams =
5747 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5748 if(NULL == pGetRoamRssiRspParams)
5749 {
5750 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5751 "%s: VOS MEM Alloc Failure", __func__);
5752 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]5753 vos_mem_free(pGetRoamRssiParams);
5754 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5755 return VOS_STATUS_E_NOMEM;
5756 }
5757 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
5758 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
5759 pGetRoamRssiRspParams->rssi = 0;
5760 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
5761 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
5762 (void *)pGetRoamRssiRspParams, 0) ;
5763 }
5764 return CONVERT_WDI2VOS_STATUS(status);
5765}
5766#endif
5767
5768
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5769/*
5770 * FUNCTION: WDA_UpdateEDCAParamCallback
5771 * call back function for Update EDCA params from WDI
5772 */
5773void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
5774{
5775 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5776 tEdcaParams *pEdcaParams;
5777
5778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5779 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5780 if(NULL == pWdaParams)
5781 {
5782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5783 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5784 VOS_ASSERT(0) ;
5785 return ;
5786 }
5787 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5788 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5789 vos_mem_free(pWdaParams);
5790 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5791 return ;
5792}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5793/*
5794 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
5795 * Request to WDI to Update the EDCA params.
5796 */
5797VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
5798 tEdcaParams *pEdcaParams)
5799{
5800 WDI_Status status = WDI_STATUS_SUCCESS ;
5801 WDI_UpdateEDCAParamsType *wdiEdcaParam =
5802 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
5803 sizeof(WDI_UpdateEDCAParamsType)) ;
5804 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5806 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5807 if(NULL == wdiEdcaParam)
5808 {
5809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5810 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5811 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5812 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5813 return VOS_STATUS_E_NOMEM;
5814 }
5815 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5816 if(NULL == pWdaParams)
5817 {
5818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5819 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5820 VOS_ASSERT(0);
5821 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5822 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5823 return VOS_STATUS_E_NOMEM;
5824 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5825 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]5826 /*
5827 Since firmware is not using highperformance flag, we have removed
5828 this flag from wdiEDCAInfo structure to match sizeof the structure
5829 between host and firmware.In future if we are planning to use
5830 highperformance flag then Please define this flag in wdiEDCAInfo
5831 structure, update it here and send it to firmware. i.e.
5832 Following is the original line which we removed as part of the fix
5833 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
5834 pEdcaParams->highPerformance;
5835 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5836 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
5837 &pEdcaParams->acbe);
5838 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
5839 &pEdcaParams->acbk);
5840 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
5841 &pEdcaParams->acvi);
5842 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
5843 &pEdcaParams->acvo);
5844 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5845 pWdaParams->pWdaContext = pWDA;
5846 /* Store remove key pointer, as this will be used for response */
5847 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5848 /* store Params pass it to WDI */
5849 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5850 status = WDI_UpdateEDCAParams(wdiEdcaParam,
5851 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5852 if(IS_WDI_STATUS_FAILURE(status))
5853 {
5854 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5855 "Failure in Update EDCA Params WDI API, free all the memory " );
5856 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5857 vos_mem_free(pWdaParams);
5858 vos_mem_free(pEdcaParams);
5859 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5860 return CONVERT_WDI2VOS_STATUS(status) ;
5861}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5862/*
5863 * FUNCTION: WDA_AddBAReqCallback
5864 * send ADD BA RSP back to PE
5865 */
5866void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
5867 void* pUserData)
5868{
5869 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5870 tWDA_CbContext *pWDA;
5871 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5873 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5874 if(NULL == pWdaParams)
5875 {
5876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5877 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5878 VOS_ASSERT(0) ;
5879 return ;
5880 }
5881 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5882 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5883 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5884 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5885 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5886 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5887 return ;
5888}
5889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5890/*
5891 * FUNCTION: WDA_ProcessAddBAReq
5892 * Request to WDI to Update the ADDBA REQ params.
5893 */
5894VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
5895 tANI_U16 baSessionID, tANI_U8 staIdx, tAddBAParams *pAddBAReqParams)
5896{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5897 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5898 WDI_AddBAReqParamsType *wdiAddBAReqParam =
5899 (WDI_AddBAReqParamsType *)vos_mem_malloc(
5900 sizeof(WDI_AddBAReqParamsType)) ;
5901 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5903 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5904 if(NULL == wdiAddBAReqParam)
5905 {
5906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5907 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5908 VOS_ASSERT(0);
5909 return VOS_STATUS_E_NOMEM;
5910 }
5911 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5912 if(NULL == pWdaParams)
5913 {
5914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5915 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5916 VOS_ASSERT(0);
5917 vos_mem_free(wdiAddBAReqParam);
5918 return VOS_STATUS_E_NOMEM;
5919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5920 do
5921 {
5922 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5923 wdiAddBaInfo->ucSTAIdx = staIdx ;
5924 wdiAddBaInfo->ucBaSessionID = baSessionID ;
5925 wdiAddBaInfo->ucWinSize = WDA_BA_MAX_WINSIZE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5926 } while(0) ;
5927 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5928 pWdaParams->pWdaContext = pWDA;
5929 /* store Params pass it to WDI */
5930 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
5931 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5932 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
5933 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5934
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5935 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5936 {
5937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5938 "Failure in ADD BA REQ Params WDI API, free all the memory" );
5939 status = CONVERT_WDI2VOS_STATUS(wstatus);
5940 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5941 vos_mem_free(pWdaParams);
5942 pAddBAReqParams->status = eSIR_FAILURE;
5943 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5944 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5945 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5946}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5947/*
5948 * FUNCTION: WDA_AddBASessionReqCallback
5949 * send ADD BA SESSION RSP back to PE/(or TL)
5950 */
5951void WDA_AddBASessionReqCallback(
5952 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
5953{
5954 VOS_STATUS status = VOS_STATUS_SUCCESS ;
5955 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5956 tWDA_CbContext *pWDA;
5957 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5959 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5960 if(NULL == pWdaParams)
5961 {
5962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5963 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5964 VOS_ASSERT(0) ;
5965 return ;
5966 }
5967 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5968 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5969 if( NULL == pAddBAReqParams )
5970 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5972 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5973 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5974 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5975 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5976 return ;
5977 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5978 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5979 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5980 /*
5981 * if WDA in update TL state, update TL with BA session parama and send
5982 * another request to HAL(/WDI) (ADD_BA_REQ)
5983 */
5984
5985 if((VOS_STATUS_SUCCESS ==
5986 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
5987 (WDA_BA_UPDATE_TL_STATE == pWDA->wdaState))
5988 {
5989 /* Update TL with BA info received from HAL/WDI */
5990 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
5991 wdiAddBaSession->usBaSessionID,
5992 wdiAddBaSession->ucSTAIdx,
5993 wdiAddBaSession->ucBaTID,
5994 wdiAddBaSession->ucBaBufferSize,
5995 wdiAddBaSession->ucWinSize,
5996 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5997 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
5998 wdiAddBaSession->ucSTAIdx, pAddBAReqParams) ;
5999 }
6000 else
6001 {
6002 pAddBAReqParams->status =
6003 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
6004
6005 /* Setting Flag to indicate that Set BA is success */
6006 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
6007 {
6008 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
6009 tANI_U8 tid = wdiAddBaSession->ucBaTID;
6010 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
6011 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6012 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6013 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6014 /*Reset the WDA state to READY */
6015 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6016 return ;
6017}
6018
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6019/*
6020 * FUNCTION: WDA_ProcessAddBASessionReq
6021 * Request to WDI to Update the ADDBA REQ params.
6022 */
6023VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
6024 tAddBAParams *pAddBAReqParams)
6025{
6026 WDI_Status status = WDI_STATUS_SUCCESS ;
6027 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
6028 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
6029 sizeof(WDI_AddBASessionReqParamsType)) ;
6030 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6031 WLANTL_STAStateType tlSTAState = 0;
6032
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6033 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6034 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6035 if(NULL == wdiAddBASessionReqParam)
6036 {
6037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6038 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6039 VOS_ASSERT(0);
6040 return VOS_STATUS_E_NOMEM;
6041 }
6042 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6043 if(NULL == pWdaParams)
6044 {
6045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6046 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6047 VOS_ASSERT(0);
6048 vos_mem_free(wdiAddBASessionReqParam);
6049 return VOS_STATUS_E_NOMEM;
6050 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6051 /*
6052 * Populate ADD BA parameters and pass these paarmeters to WDI.
6053 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
6054 * the state to track if these is BA recipient case or BA initiator
6055 * case.
6056 */
6057 do
6058 {
6059 WDI_AddBASessionReqinfoType *wdiBAInfoType =
6060 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
6061 /* vos_mem_copy(wdiBAInfoType->macBSSID,
6062 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
6063 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
6064 vos_mem_copy(wdiBAInfoType->macPeerAddr,
6065 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6066 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6067 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
6068 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
6069 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
6070 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
6071 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6072 /* check the BA direction and update state accordingly */
6073 (eBA_RECIPIENT == wdiBAInfoType->ucBaDirection)
6074 ? (pWDA->wdaState = WDA_BA_UPDATE_TL_STATE)
6075 : (pWDA->wdaState = WDA_BA_UPDATE_LIM_STATE);
6076
6077 }while(0) ;
6078 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6079 pWdaParams->pWdaContext = pWDA;
6080 /* Store ADD BA pointer, as this will be used for response */
6081 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
6082 /* store Params pass it to WDI */
6083 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6084
6085 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
6086 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
6087 */
6088 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
6089 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
6090 {
6091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6092 "Peer staIdx %d hasn't established yet(%d). Send ADD BA failure to PE.", pAddBAReqParams->staIdx, tlSTAState );
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6093 status = WDI_STATUS_E_NOT_ALLOWED;
6094 pAddBAReqParams->status =
6095 CONVERT_WDI2SIR_STATUS(status) ;
6096 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6097 /*Reset the WDA state to READY */
6098 pWDA->wdaState = WDA_READY_STATE;
6099 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6100 vos_mem_free(pWdaParams);
6101
6102 return CONVERT_WDI2VOS_STATUS(status) ;
6103 }
6104
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6105 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
6106 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6107 if(IS_WDI_STATUS_FAILURE(status))
6108 {
6109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6110 "Failure in ADD BA Session REQ Params WDI API, free all the memory =%d", status);
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]6111 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6112 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]6113 pAddBAReqParams->status =
6114 CONVERT_WDI2SIR_STATUS(status) ;
6115 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6116 /*Reset the WDA state to READY */
6117 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6118 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6119 vos_mem_free(pWdaParams);
6120 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6121 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6122}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6123/*
6124 * FUNCTION: WDA_DelBANotifyTL
6125 * send DEL BA IND to TL
6126 */
6127void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
6128 tDelBAParams *pDelBAReqParams)
6129{
6130 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
6131 //tSirMsgQ msg;
6132 vos_msg_t vosMsg;
6133 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6134 if(NULL == pDelBAInd)
6135 {
6136 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6137 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6138 VOS_ASSERT(0) ;
6139 return;
6140 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6141 pDelBAInd->mesgType = WDA_DELETEBA_IND;
6142 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
6143 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
6144 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6145
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6146
6147 vosMsg.type = WDA_DELETEBA_IND;
6148 vosMsg.bodyptr = pDelBAInd;
6149 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
6150 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
6151 {
6152 vosStatus = VOS_STATUS_E_BADMSG;
6153 }
6154}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6155/*
6156 * FUNCTION: WDA_DelBAReqCallback
6157 * send DEL BA RSP back to PE
6158 */
6159void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
6160{
6161 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6162 tWDA_CbContext *pWDA;
6163 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6165 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6166 if(NULL == pWdaParams)
6167 {
6168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6169 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6170 VOS_ASSERT(0) ;
6171 return ;
6172 }
6173 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6174 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6175 /* Notify TL about DEL BA in case of recipinet */
6176 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6177 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6178 {
6179 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6181 /*
6182 * No respone required for WDA_DELBA_IND so just free the request
6183 * param here
6184 */
6185 vos_mem_free(pDelBAReqParams);
6186 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6187 vos_mem_free(pWdaParams);
6188 return ;
6189}
6190
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6191/*
6192 * FUNCTION: WDA_ProcessDelBAReq
6193 * Request to WDI to Update the DELBA REQ params.
6194 */
6195VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6196 tDelBAParams *pDelBAReqParams)
6197{
6198 WDI_Status status = WDI_STATUS_SUCCESS ;
6199 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6200 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6201 sizeof(WDI_DelBAReqParamsType)) ;
6202 tWDA_ReqParams *pWdaParams ;
6203 tANI_U16 staIdx = 0;
6204 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6206 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6207 if(NULL == wdiDelBAReqParam)
6208 {
6209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6210 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6211 VOS_ASSERT(0);
6212 return VOS_STATUS_E_NOMEM;
6213 }
6214 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6215 if(NULL == pWdaParams)
6216 {
6217 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6218 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6219 VOS_ASSERT(0);
6220 vos_mem_free(wdiDelBAReqParam);
6221 return VOS_STATUS_E_NOMEM;
6222 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6223 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6224 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6225 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6226 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6227 pWdaParams->pWdaContext = pWDA;
6228 /* Store DEL BA pointer, as this will be used for response */
6229 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6230 /* store Params pass it to WDI */
6231 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6232 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6233 * maintained in WDA, so that WDA can retry for another BA session
6234 */
6235 staIdx = pDelBAReqParams->staIdx;
6236 tid = pDelBAReqParams->baTID;
6237 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6238 status = WDI_DelBAReq(wdiDelBAReqParam,
6239 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6240 if(IS_WDI_STATUS_FAILURE(status))
6241 {
6242 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6243 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6244 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6245 vos_mem_free(pWdaParams->wdaMsgParam);
6246 vos_mem_free(pWdaParams);
6247 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6248 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6249}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6250
6251/*
6252 * FUNCTION: WDA_UpdateChReqCallback
6253 *
6254 */
6255void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6256{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6257 tWDA_ReqParams *pWdaParams;
6258 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6259 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6260 WDI_UpdateChannelReqinfoType *pChanInfoType;
6261 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6262
6263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6264 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6265 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6266 {
6267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6268 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6269 VOS_ASSERT(0);
6270 return;
6271 }
6272
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6273 pWdaParams = (tWDA_ReqParams *)pUserData;
6274 pwdiUpdateChReqParam =
6275 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
6276 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6277 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
6278 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6279 /*
6280 * currently there is no response message is expected between PE and
6281 * WDA, Failure return from WDI is a ASSERT condition
6282 */
6283 vos_mem_free(pChanInfoType);
6284 vos_mem_free(pChanList);
6285 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6286 vos_mem_free(pWdaParams);
6287
6288 return;
6289}
6290
6291/*
6292 * FUNCTION: WDA_ProcessUpdateChannelList
6293 * Request to WDI to Update the ChannelList params.
6294 */
6295VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
6296 tSirUpdateChanList *pChanList)
6297{
6298 WDI_Status status = WDI_STATUS_SUCCESS;
6299 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6300 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6301 WDI_UpdateChannelReqinfoType *pChanInfoType;
6302 tWDA_ReqParams *pWdaParams;
6303 wpt_uint8 i;
6304
6305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6306 "------> %s " ,__func__);
6307 if(NULL == pChanList)
6308 {
6309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6310 "%s: NULL pChanList", __func__);
6311 VOS_ASSERT(0);
6312 return VOS_STATUS_E_INVAL;
6313 }
6314
6315 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
6316 {
6317 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6318 "Update channel list capability Not Supported");
6319 vos_mem_free(pChanList);
6320 return VOS_STATUS_E_INVAL;
6321 }
6322
6323 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
6324 sizeof(WDI_UpdateChReqParamsType));
6325 if(NULL == pwdiUpdateChReqParam)
6326 {
6327 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6328 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
6329 __func__);
6330 VOS_ASSERT(0);
6331 vos_mem_free(pChanList);
6332 return VOS_STATUS_E_NOMEM;
6333 }
6334 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6335 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
6336 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
6337 pChanList->numChan);
6338 if(NULL == pChanInfoType)
6339 {
6340 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6341 "%s: VOS MEM Alloc Failure", __func__);
6342 VOS_ASSERT(0);
6343 vos_mem_free(pChanList);
6344 vos_mem_free(pwdiUpdateChReqParam);
6345 return VOS_STATUS_E_NOMEM;
6346 }
6347 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
6348 * pChanList->numChan);
6349 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
6350
6351 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6352 if(NULL == pWdaParams)
6353 {
6354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6355 "%s: VOS MEM Alloc Failure", __func__);
6356 VOS_ASSERT(0);
6357 vos_mem_free(pChanList);
6358 vos_mem_free(pChanInfoType);
6359 vos_mem_free(pwdiUpdateChReqParam);
6360 return VOS_STATUS_E_NOMEM;
6361 }
6362 pwdiUpdateChanReqType->numchan = pChanList->numChan;
6363
6364 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
6365 {
6366 pChanInfoType->mhz =
6367 vos_chan_to_freq(pChanList->chanParam[i].chanId);
6368
6369 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
6370 pChanInfoType->band_center_freq2 = 0;
6371
6372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6373 "chan[%d] = %u", i, pChanInfoType->mhz);
6374 if (pChanList->chanParam[i].dfsSet)
6375 {
6376 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
6377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6378 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
6379 pChanList->chanParam[i].dfsSet);
6380 }
6381
6382 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
6383 {
6384 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
6385 }
6386 else
6387 {
6388 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
6389 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
6390 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
6391 }
6392
6393 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6394 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6395
6396 pChanInfoType++;
6397 }
6398
6399 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
6400 pWdaParams->pWdaContext = pWDA;
6401 pWdaParams->wdaMsgParam = (void *)pChanList;
6402 /* store Params pass it to WDI */
6403 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
6404 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
6405 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
6406 if(IS_WDI_STATUS_FAILURE(status))
6407 {
6408 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6409 "Failure in Update Channel REQ Params WDI API, free all the memory");
6410 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
6411 vos_mem_free(pwdiUpdateChReqParam);
6412 vos_mem_free(pWdaParams->wdaMsgParam);
6413 vos_mem_free(pWdaParams);
6414 }
6415 return CONVERT_WDI2VOS_STATUS(status);
6416}
6417
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6418/*
6419 * FUNCTION: WDA_AddTSReqCallback
6420 * send ADD TS RSP back to PE
6421 */
6422void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
6423{
6424 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6425 tWDA_CbContext *pWDA;
6426 tAddTsParams *pAddTsReqParams;
6427
6428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6429 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6430 if(NULL == pWdaParams)
6431 {
6432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6433 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6434 VOS_ASSERT(0) ;
6435 return ;
6436 }
6437 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6438 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
6439 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6440 vos_mem_free(pWdaParams);
6441
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6442 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6443 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6444 return ;
6445}
6446
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6447/*
6448 * FUNCTION: WDA_ProcessAddTSReq
6449 * Request to WDI to Update the ADD TS REQ params.
6450 */
6451VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
6452 tAddTsParams *pAddTsReqParams)
6453{
6454 WDI_Status status = WDI_STATUS_SUCCESS ;
6455 WDI_AddTSReqParamsType *wdiAddTSReqParam =
6456 (WDI_AddTSReqParamsType *)vos_mem_malloc(
6457 sizeof(WDI_AddTSReqParamsType)) ;
6458 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6460 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6461 if(NULL == wdiAddTSReqParam)
6462 {
6463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6464 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6465 VOS_ASSERT(0);
6466 return VOS_STATUS_E_NOMEM;
6467 }
6468 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6469 if(NULL == pWdaParams)
6470 {
6471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6472 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6473 VOS_ASSERT(0);
6474 vos_mem_free(wdiAddTSReqParam);
6475 return VOS_STATUS_E_NOMEM;
6476 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6477 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
6478 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6479 //TS IE
6480 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
6481 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
6482 pAddTsReqParams->tspec.length;
6483
6484 //TS IE : TS INFO : TRAFFIC
6485 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
6486 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
6487 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
6488 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
6489 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
6490 pAddTsReqParams->tspec.tsinfo.traffic.psb;
6491 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
6492 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
6493 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
6494 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
6495 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
6496 pAddTsReqParams->tspec.tsinfo.traffic.direction;
6497 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
6498 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
6499 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
6500 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
6501
6502 //TS IE : TS INFO : SCHEDULE
6503 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
6504 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
6505 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
6506 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6507 //TS IE
6508 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
6509 pAddTsReqParams->tspec.nomMsduSz;
6510 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
6511 pAddTsReqParams->tspec.maxMsduSz;
6512 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
6513 pAddTsReqParams->tspec.minSvcInterval;
6514 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
6515 pAddTsReqParams->tspec.maxSvcInterval;
6516 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
6517 pAddTsReqParams->tspec.inactInterval;
6518 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
6519 pAddTsReqParams->tspec.suspendInterval;
6520 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
6521 pAddTsReqParams->tspec.svcStartTime;
6522 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
6523 pAddTsReqParams->tspec.minDataRate;
6524 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
6525 pAddTsReqParams->tspec.meanDataRate;
6526 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
6527 pAddTsReqParams->tspec.peakDataRate;
6528 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
6529 pAddTsReqParams->tspec.maxBurstSz;
6530 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
6531 pAddTsReqParams->tspec.delayBound;
6532 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
6533 pAddTsReqParams->tspec.minPhyRate;
6534 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
6535 pAddTsReqParams->tspec.surplusBw;
6536 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
6537 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6538 /* TODO: tAddTsParams doesn't have the following fields */
6539#if 0
6540 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
6541 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
6542 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
6543 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
6544#endif
6545 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
6546
6547 pWdaParams->pWdaContext = pWDA;
6548 /* Store ADD TS pointer, as this will be used for response */
6549 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6550 /* store Params pass it to WDI */
6551 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6552 status = WDI_AddTSReq(wdiAddTSReqParam,
6553 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6554 if(IS_WDI_STATUS_FAILURE(status))
6555 {
6556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6557 "Failure in ADD TS REQ Params WDI API, free all the memory " );
6558 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6559 vos_mem_free(pWdaParams);
6560 pAddTsReqParams->status = eSIR_FAILURE ;
6561 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
6562 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6563 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6564}
6565
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6566/*
6567 * FUNCTION: WDA_DelTSReqCallback
6568 * send DEL TS RSP back to PE
6569 */
6570void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
6571{
6572 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6573 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6574 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6575 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6576 vos_mem_free(pWdaParams->wdaMsgParam) ;
6577 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6578 /*
6579 * No respone required for WDA_DEL_TS_REQ so just free the request
6580 * param here
6581 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6582 return ;
6583}
6584
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6585/*
6586 * FUNCTION: WDA_ProcessDelTSReq
6587 * Request to WDI to Update the DELTS REQ params.
6588 */
6589VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
6590 tDelTsParams *pDelTSReqParams)
6591{
6592 WDI_Status status = WDI_STATUS_SUCCESS ;
6593 WDI_DelTSReqParamsType *wdiDelTSReqParam =
6594 (WDI_DelTSReqParamsType *)vos_mem_malloc(
6595 sizeof(WDI_DelTSReqParamsType)) ;
6596 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6598 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6599 if(NULL == wdiDelTSReqParam)
6600 {
6601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6602 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6603 VOS_ASSERT(0);
6604 return VOS_STATUS_E_NOMEM;
6605 }
6606 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6607 if(NULL == pWdaParams)
6608 {
6609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6610 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6611 VOS_ASSERT(0);
6612 vos_mem_free(wdiDelTSReqParam);
6613 return VOS_STATUS_E_NOMEM;
6614 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6615 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
6616 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
6617 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
6618 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
6619 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6620 pWdaParams->pWdaContext = pWDA;
6621 /* Store DEL TS pointer, as this will be used for response */
6622 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6623 /* store Params pass it to WDI */
6624 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6625 status = WDI_DelTSReq(wdiDelTSReqParam,
6626 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6627 if(IS_WDI_STATUS_FAILURE(status))
6628 {
6629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6630 "Failure in DEL TS REQ Params WDI API, free all the memory " );
6631 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6632 vos_mem_free(pWdaParams->wdaMsgParam);
6633 vos_mem_free(pWdaParams);
6634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6635 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6636}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6637/*
6638 * FUNCTION: WDA_UpdateBeaconParamsCallback
6639 * Free the memory. No need to send any response to PE in this case
6640 */
6641void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
6642{
6643 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6645 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6646 if(NULL == pWdaParams)
6647 {
6648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6649 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6650 VOS_ASSERT(0) ;
6651 return ;
6652 }
6653 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6654 vos_mem_free(pWdaParams->wdaMsgParam) ;
6655 vos_mem_free(pWdaParams);
6656 /*
6657 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
6658 * param here
6659 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6660 return ;
6661}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6662/*
6663 * FUNCTION: WDA_ProcessUpdateBeaconParams
6664 * Request to WDI to send the beacon parameters to HAL to update the Hardware
6665 */
6666VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
6667 tUpdateBeaconParams *pUpdateBeaconParams)
6668{
6669 WDI_Status status = WDI_STATUS_SUCCESS ;
6670 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
6671 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
6672 sizeof(WDI_UpdateBeaconParamsType)) ;
6673 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6674 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6675 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6676 if(NULL == wdiUpdateBeaconParams)
6677 {
6678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6679 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6680 VOS_ASSERT(0);
6681 return VOS_STATUS_E_NOMEM;
6682 }
6683 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6684 if(NULL == pWdaParams)
6685 {
6686 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6687 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6688 VOS_ASSERT(0);
6689 vos_mem_free(wdiUpdateBeaconParams);
6690 return VOS_STATUS_E_NOMEM;
6691 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6692 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
6693 pUpdateBeaconParams->bssIdx;
6694 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
6695 pUpdateBeaconParams->fShortPreamble;
6696 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
6697 pUpdateBeaconParams->fShortSlotTime;
6698 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
6699 pUpdateBeaconParams->beaconInterval;
6700 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
6701 pUpdateBeaconParams->llaCoexist;
6702 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
6703 pUpdateBeaconParams->llbCoexist;
6704 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
6705 pUpdateBeaconParams->llgCoexist;
6706 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
6707 pUpdateBeaconParams->ht20MhzCoexist;
6708 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
6709 pUpdateBeaconParams->llnNonGFCoexist;
6710 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
6711 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
6712 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
6713 pUpdateBeaconParams->fRIFSMode;
6714 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
6715 pUpdateBeaconParams->paramChangeBitmap;
6716 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
6717
6718 pWdaParams->pWdaContext = pWDA;
6719 /* Store UpdateBeacon Req pointer, as this will be used for response */
6720 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6721 /* store Params pass it to WDI */
6722 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6723 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
6724 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
6725 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6726 if(IS_WDI_STATUS_FAILURE(status))
6727 {
6728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6729 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
6730 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6731 vos_mem_free(pWdaParams->wdaMsgParam);
6732 vos_mem_free(pWdaParams);
6733 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6734 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6735}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6736#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6737/*
6738 * FUNCTION: WDA_TSMStatsReqCallback
6739 * send TSM Stats RSP back to PE
6740 */
6741void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
6742{
6743 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6744 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6745 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
6746 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6747
6748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6749 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6750 if(NULL == pWdaParams)
6751 {
6752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6753 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6754 VOS_ASSERT(0) ;
6755 return ;
6756 }
6757 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6758 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
6759
6760 if(NULL == pGetTsmStatsReqParams)
6761 {
6762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6763 "%s: pGetTsmStatsReqParams received NULL", __func__);
6764 VOS_ASSERT(0);
6765 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6766 vos_mem_free(pWdaParams);
6767 return;
6768 }
6769
6770 pTsmRspParams =
6771 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6772 if( NULL == pTsmRspParams )
6773 {
6774 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6775 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6776 VOS_ASSERT( 0 );
6777 return ;
6778 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6779 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
6780 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
6781 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
6782
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6783 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
6784 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
6785 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
6786 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
6787 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
6788 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
6789 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
6790 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
6791 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
6792 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6793
6794 /* Assign get tsm stats req req (backup) in to the response */
6795 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
6796
6797 /* free WDI command buffer */
6798 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6799 vos_mem_free(pWdaParams);
6800
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6801 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6802 return ;
6803}
6804
6805
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6806/*
6807 * FUNCTION: WDA_ProcessTsmStatsReq
6808 * Request to WDI to get the TSM Stats params.
6809 */
6810VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6811 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6812{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6813 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6814 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6815 tWDA_ReqParams *pWdaParams = NULL;
6816 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
6817
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6819 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6820 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
6821 sizeof(WDI_TSMStatsReqParamsType));
6822 if(NULL == wdiTSMReqParam)
6823 {
6824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6825 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6826 VOS_ASSERT(0);
6827 return VOS_STATUS_E_NOMEM;
6828 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6829 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6830 if(NULL == pWdaParams)
6831 {
6832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6833 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6834 VOS_ASSERT(0);
6835 vos_mem_free(wdiTSMReqParam);
6836 return VOS_STATUS_E_NOMEM;
6837 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6838 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
6839 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
6840 pTsmStats->bssId,
6841 sizeof(wpt_macAddr));
6842 wdiTSMReqParam->wdiReqStatusCB = NULL ;
6843
6844 pWdaParams->pWdaContext = pWDA;
6845 /* Store TSM Stats pointer, as this will be used for response */
6846 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6847 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6848 status = WDI_TSMStatsReq(wdiTSMReqParam,
6849 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6850 if(IS_WDI_STATUS_FAILURE(status))
6851 {
6852 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6853 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6854 vos_mem_free(pWdaParams);
6855
6856 pGetTsmStatsRspParams =
6857 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
6858 if(NULL == pGetTsmStatsRspParams)
6859 {
6860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6861 "%s: VOS MEM Alloc Failure", __func__);
6862 VOS_ASSERT(0);
6863 vos_mem_free(pTsmStats);
6864 return VOS_STATUS_E_NOMEM;
6865 }
6866 pGetTsmStatsRspParams->staId = pTsmStats->staId;
6867 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
6868 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
6869
6870 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6871 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6872 return CONVERT_WDI2VOS_STATUS(status) ;
6873}
6874#endif
6875/*
6876 * FUNCTION: WDA_SendBeaconParamsCallback
6877 * No need to send any response to PE in this case
6878 */
6879void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
6880{
6881
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6883 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6884 return ;
6885}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6886/*
6887 * FUNCTION: WDA_ProcessSendBeacon
6888 * Request to WDI to send the beacon template to HAL to update the TPE memory and
6889 * start beacon trasmission
6890 */
6891VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
6892 tSendbeaconParams *pSendbeaconParams)
6893{
6894 WDI_Status status = WDI_STATUS_SUCCESS ;
6895 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6897 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6898 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
6899 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
6900 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
6901 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6902 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
6903 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]6904 /* p2pIeOffset should be atleast greater than timIeOffset */
6905 if ((pSendbeaconParams->p2pIeOffset != 0) &&
6906 (pSendbeaconParams->p2pIeOffset <
6907 pSendbeaconParams->timIeOffset))
6908 {
6909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6910 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
6911 VOS_ASSERT( 0 );
6912 return WDI_STATUS_E_FAILURE;
6913 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6914 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
6915 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6916 /* Copy the beacon template to local buffer */
6917 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
6918 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
6919 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
6920
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6921 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
6922 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6923 if(IS_WDI_STATUS_FAILURE(status))
6924 {
6925 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6926 "Failure in SEND BEACON REQ Params WDI API" );
6927 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6928 vos_mem_free(pSendbeaconParams);
6929 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6930}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6931/*
6932 * FUNCTION: WDA_UpdateProbeRspParamsCallback
6933 * No need to send any response to PE in this case
6934 */
6935void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
6936{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6937 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6938 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6939 return ;
6940}
6941
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6942/*
6943 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
6944 * Request to WDI to send the probe response template to HAL to update the TPE memory and
6945 * send probe response
6946 */
6947VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
6948 tSendProbeRespParams *pSendProbeRspParams)
6949{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6950 WDI_Status status = WDI_STATUS_SUCCESS;
6951 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
6952 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6954 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6955
6956 if (!wdiSendProbeRspParam)
6957 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
6958
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6959 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6960 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6961 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6962 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6963 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6964 /* Copy the Probe Response template to local buffer */
6965 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6966 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6967 pSendProbeRspParams->pProbeRespTemplate,
6968 pSendProbeRspParams->probeRespTemplateLen);
6969 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6970 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6971 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
6972 WDI_PROBE_REQ_BITMAP_IE_LEN);
6973
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6974 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6975
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6976 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6977 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6978 if(IS_WDI_STATUS_FAILURE(status))
6979 {
6980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6981 "Failure in SEND Probe RSP Params WDI API" );
6982 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6983 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6984 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6985 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6986}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6987#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6988/*
6989 * FUNCTION: WDA_SetMaxTxPowerCallBack
6990 * send the response to PE with power value received from WDI
6991 */
6992void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
6993 void* pUserData)
6994{
6995 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6996 tWDA_CbContext *pWDA = NULL;
6997 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
6998
6999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7000 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7001 if(NULL == pWdaParams)
7002 {
7003 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7004 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7005 VOS_ASSERT(0) ;
7006 return ;
7007 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7008 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7009 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7010 if( NULL == pMaxTxPowerParams )
7011 {
7012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7013 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7014 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]7015 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7016 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7017 return ;
7018 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7019
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7020
7021 /*need to free memory for the pointers used in the
7022 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7023 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7024 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7025 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7026
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7027
7028 /* send response to UMAC*/
7029 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
7030
7031 return;
7032}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7033/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7034 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7035 * Request to WDI to send set Max Tx Power Request
7036 */
7037 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
7038 tMaxTxPowerParams *MaxTxPowerParams)
7039{
7040 WDI_Status status = WDI_STATUS_SUCCESS;
7041 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
7042 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7043
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7045 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7046
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7047 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
7048 sizeof(WDI_SetMaxTxPowerParamsType));
7049 if(NULL == wdiSetMaxTxPowerParams)
7050 {
7051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7052 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7053 VOS_ASSERT(0);
7054 return VOS_STATUS_E_NOMEM;
7055 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7056 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7057 if(NULL == pWdaParams)
7058 {
7059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7060 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7061 vos_mem_free(wdiSetMaxTxPowerParams);
7062 VOS_ASSERT(0);
7063 return VOS_STATUS_E_NOMEM;
7064 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7065 /* Copy.Max.Tx.Power Params to WDI structure */
7066 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
7067 MaxTxPowerParams->bssId,
7068 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7069 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
7070 MaxTxPowerParams->selfStaMacAddr,
7071 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7072 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
7073 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7074 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7075 pWdaParams->pWdaContext = pWDA;
7076 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7077 /* store Params pass it to WDI */
7078 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7079 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
7080 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7081 if(IS_WDI_STATUS_FAILURE(status))
7082 {
7083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7084 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
7085 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7086 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7087 /* send response to UMAC*/
7088 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7089 }
7090 return CONVERT_WDI2VOS_STATUS(status);
7091
7092}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7093#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7094
7095/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]7096 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
7097 * send the response to PE with power value received from WDI
7098 */
7099void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
7100 *pwdiSetMaxTxPowerPerBandRsp,
7101 void* pUserData)
7102{
7103 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7104 tWDA_CbContext *pWDA = NULL;
7105 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
7106
7107 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7108 "<------ %s ", __func__);
7109 if (NULL == pWdaParams)
7110 {
7111 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7112 "%s: pWdaParams received NULL", __func__);
7113 VOS_ASSERT(0);
7114 return ;
7115 }
7116 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7117 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
7118 if ( NULL == pMxTxPwrPerBandParams )
7119 {
7120 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7121 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
7122 VOS_ASSERT(0);
7123 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7124 vos_mem_free(pWdaParams);
7125 return;
7126 }
7127
7128 /*need to free memory for the pointers used in the
7129 WDA Process.Set Max Tx Power Req function*/
7130 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7131 vos_mem_free(pWdaParams);
7132 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
7133
7134 /* send response to UMAC*/
7135 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7136 pMxTxPwrPerBandParams, 0);
7137
7138 return;
7139}
7140
7141/*
7142 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
7143 * Request to WDI to send set Max Tx Power Per band Request
7144 */
7145 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
7146 tMaxTxPowerPerBandParams
7147 *MaxTxPowerPerBandParams)
7148{
7149 WDI_Status status = WDI_STATUS_SUCCESS;
7150 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
7151 tWDA_ReqParams *pWdaParams = NULL;
7152
7153 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7154 "------> %s ", __func__);
7155
7156 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
7157 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
7158
7159 if (NULL == wdiSetMxTxPwrPerBandParams)
7160 {
7161 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7162 "%s: VOS MEM Alloc Failure", __func__);
7163 VOS_ASSERT(0);
7164 return VOS_STATUS_E_NOMEM;
7165 }
7166 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7167 if (NULL == pWdaParams)
7168 {
7169 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7170 "%s: VOS MEM Alloc Failure", __func__);
7171 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7172 VOS_ASSERT(0);
7173 return VOS_STATUS_E_NOMEM;
7174 }
7175 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7176 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7177 MaxTxPowerPerBandParams->bandInfo;
7178 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7179 MaxTxPowerPerBandParams->power;
7180 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7181 pWdaParams->pWdaContext = pWDA;
7182 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7183 /* store Params pass it to WDI */
7184 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7185 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7186 WDA_SetMaxTxPowerPerBandCallBack,
7187 pWdaParams);
7188 if (IS_WDI_STATUS_FAILURE(status))
7189 {
7190 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7191 "Failure in SET MAX TX Power REQ Params WDI API,"
7192 " free all the memory");
7193 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7194 vos_mem_free(pWdaParams);
7195 /* send response to UMAC*/
7196 WDA_SendMsg(pWDA,
7197 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7198 MaxTxPowerPerBandParams, 0);
7199 }
7200 return CONVERT_WDI2VOS_STATUS(status);
7201}
7202
7203/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7204 * FUNCTION: WDA_SetTxPowerCallBack
7205 * send the response to PE with power value received from WDI
7206 */
7207void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7208 void* pUserData)
7209{
7210 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7211 tWDA_CbContext *pWDA = NULL;
7212 tSirSetTxPowerReq *pTxPowerParams = NULL;
7213
7214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7215 "<------ %s ", __func__);
7216 if(NULL == pWdaParams)
7217 {
7218 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7219 "%s: pWdaParams received NULL", __func__);
7220 VOS_ASSERT(0) ;
7221 return ;
7222 }
7223 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7224 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
7225 if(NULL == pTxPowerParams)
7226 {
7227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7228 "%s: pTxPowerParams received NULL " ,__func__);
7229 VOS_ASSERT(0);
7230 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7231 vos_mem_free(pWdaParams);
7232 return ;
7233 }
7234
7235 /*need to free memory for the pointers used in the
7236 WDA Process.Set Max Tx Power Req function*/
7237 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7238 vos_mem_free(pWdaParams);
7239
7240 /* send response to UMAC*/
7241 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
7242 return;
7243}
7244
7245/*
7246 * FUNCTION: WDA_ProcessSetTxPowerReq
7247 * Request to WDI to send set Tx Power Request
7248 */
7249 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
7250 tSirSetTxPowerReq *txPowerParams)
7251{
7252 WDI_Status status = WDI_STATUS_SUCCESS;
7253 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
7254 tWDA_ReqParams *pWdaParams = NULL;
7255
7256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7257 "------> %s ", __func__);
7258
7259 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
7260 sizeof(WDI_SetTxPowerParamsType));
7261 if(NULL == wdiSetTxPowerParams)
7262 {
7263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7264 "%s: VOS MEM Alloc Failure", __func__);
7265 VOS_ASSERT(0);
7266 return VOS_STATUS_E_NOMEM;
7267 }
7268 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7269 if(NULL == pWdaParams)
7270 {
7271 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7272 "%s: VOS MEM Alloc Failure", __func__);
7273 vos_mem_free(wdiSetTxPowerParams);
7274 VOS_ASSERT(0);
7275 return VOS_STATUS_E_NOMEM;
7276 }
7277 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
7278 txPowerParams->bssIdx;
7279 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
7280 txPowerParams->mwPower;
7281 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
7282 pWdaParams->pWdaContext = pWDA;
7283 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
7284 /* store Params pass it to WDI */
7285 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
7286 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
7287 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
7288 if(IS_WDI_STATUS_FAILURE(status))
7289 {
7290 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7291 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
7292 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7293 vos_mem_free(pWdaParams);
7294 /* send response to UMAC*/
7295 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
7296 }
7297 return CONVERT_WDI2VOS_STATUS(status);
7298}
7299
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7300/*
7301 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7302 * Free the memory. No need to send any response to PE in this case
7303 */
7304void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
7305{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7306 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7307
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7308 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7309 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7310
7311 if(NULL == pWdaParams)
7312 {
7313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7314 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7315 VOS_ASSERT(0) ;
7316 return ;
7317 }
7318
7319 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7320 vos_mem_free(pWdaParams->wdaMsgParam) ;
7321 vos_mem_free(pWdaParams);
7322
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7323 /*
7324 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
7325 * so just free the request param here
7326 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7327 return ;
7328}
7329
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7330/*
7331 * FUNCTION: WDA_ProcessSetP2PGONOAReq
7332 * Request to WDI to set the P2P Group Owner Notice of Absence Req
7333 */
7334VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
7335 tP2pPsParams *pP2pPsConfigParams)
7336{
7337 WDI_Status status = WDI_STATUS_SUCCESS ;
7338 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
7339 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
7340 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7341 tWDA_ReqParams *pWdaParams = NULL;
7342
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7344 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7345 if(NULL == wdiSetP2PGONOAReqParam)
7346 {
7347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7348 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7349 VOS_ASSERT(0);
7350 return VOS_STATUS_E_NOMEM;
7351 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7352
7353 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7354 if(NULL == pWdaParams)
7355 {
7356 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7357 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7358 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7359 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7360 VOS_ASSERT(0);
7361 return VOS_STATUS_E_NOMEM;
7362 }
7363
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7364 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
7365 pP2pPsConfigParams->opp_ps;
7366 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
7367 pP2pPsConfigParams->ctWindow;
7368 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
7369 pP2pPsConfigParams->count;
7370 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
7371 pP2pPsConfigParams->duration;
7372 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
7373 pP2pPsConfigParams->interval;
7374 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
7375 pP2pPsConfigParams->single_noa_duration;
7376 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
7377 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7378
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7379 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
7380 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7381 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
7382
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7383 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7384 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
7385 pWdaParams->pWdaContext = pWDA;
7386
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7387 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7388 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
7389
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7390 if(IS_WDI_STATUS_FAILURE(status))
7391 {
7392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7393 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7394 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7395 vos_mem_free(pWdaParams->wdaMsgParam);
7396 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7397 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7398 return CONVERT_WDI2VOS_STATUS(status);
7399
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7400}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7401
7402#ifdef FEATURE_WLAN_TDLS
7403/*
7404 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7405 * Free the memory. No need to send any response to PE in this case
7406 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7407void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
7408 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7409{
7410 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7411 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7412 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7413
7414
7415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7416 "<------ %s " ,__func__);
7417 if(NULL == pWdaParams)
7418 {
7419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7420 "%s: pWdaParams received NULL", __func__);
7421 VOS_ASSERT(0) ;
7422 return ;
7423 }
7424 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7425
7426 if(NULL == pWdaParams)
7427 {
7428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7429 "%s: pWdaParams received NULL", __func__);
7430 VOS_ASSERT(0) ;
7431 return ;
7432 }
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7433 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
7434 if( NULL == pTdlsLinkEstablishParams )
7435 {
7436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7437 "%s: pTdlsLinkEstablishParams "
7438 "received NULL " ,__func__);
7439 VOS_ASSERT(0);
7440 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7441 vos_mem_free(pWdaParams);
7442 return ;
7443 }
7444 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
7445 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7446 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7447 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7448 /* send response to UMAC*/
7449 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
7450
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7451 return ;
7452}
7453
7454VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
7455 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
7456{
7457 WDI_Status status = WDI_STATUS_SUCCESS ;
7458 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
7459 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
7460 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
7461 tWDA_ReqParams *pWdaParams = NULL;
7462 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7463 "------> %s " ,__func__);
7464 if(NULL == wdiSetTDLSLinkEstablishReqParam)
7465 {
7466 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7467 "%s: VOS MEM Alloc Failure", __func__);
7468 VOS_ASSERT(0);
7469 return VOS_STATUS_E_NOMEM;
7470 }
7471 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7472 if(NULL == pWdaParams)
7473 {
7474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7475 "%s: VOS MEM Alloc Failure", __func__);
7476 vos_mem_free(pTdlsLinkEstablishParams);
7477 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
7478 VOS_ASSERT(0);
7479 return VOS_STATUS_E_NOMEM;
7480 }
7481 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7482 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7483 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7484 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7485 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7486 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7487 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7488 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7489 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7490 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]7491 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
7492 pTdlsLinkEstablishParams->isOffChannelSupported;
7493
7494 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
7495 pTdlsLinkEstablishParams->validChannels,
7496 pTdlsLinkEstablishParams->validChannelsLen);
7497
7498 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
7499 pTdlsLinkEstablishParams->validChannelsLen;
7500
7501 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
7502 pTdlsLinkEstablishParams->validOperClasses,
7503 pTdlsLinkEstablishParams->validOperClassesLen);
7504 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
7505 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7506
7507 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
7508 /* Store msg pointer from PE, as this will be used for response */
7509 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
7510 /* store Params pass it to WDI */
7511 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
7512 pWdaParams->pWdaContext = pWDA;
7513
7514 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
7515 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
7516 WDA_SetTDLSLinkEstablishReqParamsCallback,
7517 pWdaParams);
7518 if(IS_WDI_STATUS_FAILURE(status))
7519 {
7520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7521 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
7522 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7523 vos_mem_free(pWdaParams->wdaMsgParam);
7524 vos_mem_free(pWdaParams);
7525 }
7526 return CONVERT_WDI2VOS_STATUS(status);
7527}
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame^]7528
7529// tdlsoffchan
7530void WDA_SetTDLSChanSwitchReqParamsCallback(WDI_SetTdlsChanSwitchReqResp *wdiSetTdlsChanSwitchReqRsp,
7531 void* pUserData)
7532{
7533 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7534 tWDA_CbContext *pWDA = NULL;
7535 tTdlsChanSwitchParams *pTdlsChanSwitchParams;
7536
7537
7538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7539 "<------ %s " ,__func__);
7540 if(NULL == pWdaParams)
7541 {
7542 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7543 "%s: pWdaParams received NULL", __func__);
7544 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7545 VOS_ASSERT(0) ;
7546 return ;
7547 }
7548 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7549
7550 pTdlsChanSwitchParams = (tTdlsChanSwitchParams *)pWdaParams->wdaMsgParam ;
7551 if( NULL == pTdlsChanSwitchParams || pWDA == NULL )
7552 {
7553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7554 "%s: pTdlsChanSwitchParams "
7555 "received NULL " ,__func__);
7556 VOS_ASSERT(0);
7557 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7558 vos_mem_free(pWdaParams);
7559 return ;
7560 }
7561 pTdlsChanSwitchParams->status = CONVERT_WDI2SIR_STATUS(
7562 wdiSetTdlsChanSwitchReqRsp->wdiStatus);
7563 vos_mem_free(pTdlsChanSwitchParams) ;
7564 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7565 vos_mem_free(pWdaParams);
7566 /* send response to UMAC
7567 WDA_SendMsg(pWDA, WDA_SET_TDLS_CHAN_SWITCH_REQ_RSP, pTdlsChanSwitchParams, 0) ;*/
7568
7569 return ;
7570}
7571VOS_STATUS WDA_ProcessSetTdlsChanSwitchReq(tWDA_CbContext *pWDA,
7572 tTdlsChanSwitchParams *pTdlsChanSwitchParams)
7573{
7574 WDI_Status status = WDI_STATUS_SUCCESS ;
7575 WDI_SetTDLSChanSwitchReqParamsType *wdiSetTDLSChanSwitchReqParam =
7576 (WDI_SetTDLSChanSwitchReqParamsType *)vos_mem_malloc(
7577 sizeof(WDI_SetTDLSChanSwitchReqParamsType));
7578 tWDA_ReqParams *pWdaParams = NULL;
7579
7580 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7581 "Enter: %s ",__func__);
7582 if(NULL == wdiSetTDLSChanSwitchReqParam)
7583 {
7584 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7585 "%s: VOS MEM Alloc Failure", __func__);
7586 VOS_ASSERT(0);
7587 return VOS_STATUS_E_NOMEM;
7588 }
7589
7590 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7591 if(NULL == pWdaParams)
7592 {
7593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7594 "%s: VOS MEM Alloc Failure", __func__);
7595 vos_mem_free(pTdlsChanSwitchParams);
7596 vos_mem_free(wdiSetTDLSChanSwitchReqParam);
7597 VOS_ASSERT(0);
7598 return VOS_STATUS_E_NOMEM;
7599 }
7600 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.staIdx =
7601 pTdlsChanSwitchParams->staIdx;
7602 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.isOffchannelInitiator =
7603 pTdlsChanSwitchParams->tdlsSwMode;
7604 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetOperClass =
7605 pTdlsChanSwitchParams->operClass;
7606 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetChannel =
7607 pTdlsChanSwitchParams->tdlsOffCh;
7608 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.secondaryChannelOffset =
7609 pTdlsChanSwitchParams->tdlsOffChBwOffset;
7610
7611
7612 /* Store msg pointer from PE, as this will be used for response */
7613 pWdaParams->wdaMsgParam = (void *)pTdlsChanSwitchParams ;
7614 /* store Params pass it to WDI */
7615 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSChanSwitchReqParam ;
7616 pWdaParams->pWdaContext = pWDA;
7617 status = WDI_SetTDLSChanSwitchReq(wdiSetTDLSChanSwitchReqParam,
7618 (WDI_SetTDLSChanSwitchReqParamsRspCb)
7619 WDA_SetTDLSChanSwitchReqParamsCallback,
7620 pWdaParams);
7621 if(IS_WDI_STATUS_FAILURE(status))
7622 {
7623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7624 "Failure in TDLS Channel Switch Req WDI API, free all the memory" );
7625 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7626 vos_mem_free(pWdaParams->wdaMsgParam);
7627 vos_mem_free(pWdaParams);
7628 }
7629 return CONVERT_WDI2VOS_STATUS(status);
7630}
7631#endif /*FEATURE_WLAN_TDLS*/
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7632
7633
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7634#ifdef WLAN_FEATURE_VOWIFI_11R
7635/*
7636 * FUNCTION: WDA_AggrAddTSReqCallback
7637 * send ADD AGGREGATED TS RSP back to PE
7638 */
7639void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
7640{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7641 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7642 tWDA_CbContext *pWDA;
7643 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7644 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7646 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7647 if(NULL == pWdaParams)
7648 {
7649 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7650 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7651 VOS_ASSERT(0) ;
7652 return ;
7653 }
7654
7655 pWDA = pWdaParams->pWdaContext;
7656 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7657
7658 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7659 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7660 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7662 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7663
7664 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7665 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7666 return ;
7667}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7668/*
7669 * FUNCTION: WDA_ProcessAddTSReq
7670 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
7671 */
7672VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
7673 tAggrAddTsParams *pAggrAddTsReqParams)
7674{
7675 WDI_Status status = WDI_STATUS_SUCCESS ;
7676 int i;
7677 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7678 tWDA_ReqParams *pWdaParams = NULL;
7679
7680
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7682 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7683 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
7684 sizeof(WDI_AggrAddTSReqParamsType)) ;
7685 if(NULL == wdiAggrAddTSReqParam)
7686 {
7687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7688 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7689 VOS_ASSERT(0);
7690 return VOS_STATUS_E_NOMEM;
7691 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7692
7693
7694 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7695 if(NULL == pWdaParams)
7696 {
7697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7698 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7699 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7700 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7701 VOS_ASSERT(0);
7702 return VOS_STATUS_E_NOMEM;
7703 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7704 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
7705 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
7706 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7707 for( i = 0; i < WDI_MAX_NO_AC; i++ )
7708 {
7709 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
7710 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
7711 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7712 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
7713 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
7714 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
7715 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
7716 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
7717 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
7718 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
7719 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
7720 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
7721 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
7722 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
7723 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
7724 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
7725 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
7726 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
7727 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7728 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
7729 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7730 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
7731 pAggrAddTsReqParams->tspec[i].nomMsduSz;
7732 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
7733 pAggrAddTsReqParams->tspec[i].maxMsduSz;
7734 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
7735 pAggrAddTsReqParams->tspec[i].minSvcInterval;
7736 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
7737 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
7738 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
7739 pAggrAddTsReqParams->tspec[i].inactInterval;
7740 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
7741 pAggrAddTsReqParams->tspec[i].suspendInterval;
7742 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
7743 pAggrAddTsReqParams->tspec[i].svcStartTime;
7744 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
7745 pAggrAddTsReqParams->tspec[i].minDataRate;
7746 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
7747 pAggrAddTsReqParams->tspec[i].meanDataRate;
7748 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
7749 pAggrAddTsReqParams->tspec[i].peakDataRate;
7750 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
7751 pAggrAddTsReqParams->tspec[i].maxBurstSz;
7752 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
7753 pAggrAddTsReqParams->tspec[i].delayBound;
7754 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
7755 pAggrAddTsReqParams->tspec[i].minPhyRate;
7756 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
7757 pAggrAddTsReqParams->tspec[i].surplusBw;
7758 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
7759 pAggrAddTsReqParams->tspec[i].mediumTime;
7760 }
7761
7762 /* TODO: tAggrAddTsParams doesn't have the following fields */
7763#if 0
7764 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7765 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
7766 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7767 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7768#endif
7769 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
7770
7771 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7772 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7773 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7774 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
7775
7776 pWdaParams->pWdaContext = pWDA;
7777
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7778 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7779 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
7780
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7781 if(IS_WDI_STATUS_FAILURE(status))
7782 {
7783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7784 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7785 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7786 vos_mem_free(pWdaParams);
7787
7788 /* send the failure response back to PE*/
7789 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7790 {
7791 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
7792 }
7793
7794 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
7795 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7796 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7797 return CONVERT_WDI2VOS_STATUS(status) ;
7798}
7799#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7800/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7801 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7802 * send Enter IMPS RSP back to PE
7803 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7804void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7805{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7806 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7807 tWDA_CbContext *pWDA;
7808
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7810 "<------ %s status=%d" ,__func__,status);
7811 if(NULL == pWdaParams)
7812 {
7813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7814 "%s: pWdaParams received NULL", __func__);
7815 VOS_ASSERT(0);
7816 return;
7817 }
7818
7819 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7820
7821 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7822 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7823 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7824 return ;
7825}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7826
7827
7828/*
7829 * FUNCTION: WDA_EnterImpsReqCallback
7830 * Free memory and send Enter IMPS RSP back to PE.
7831 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
7832 */
7833void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7834{
7835 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7836 tWDA_CbContext *pWDA;
7837
7838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7839 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7840
7841 if(NULL == pWdaParams)
7842 {
7843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7844 "%s: pWdaParams received NULL", __func__);
7845 VOS_ASSERT(0);
7846 return;
7847 }
7848
7849 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7850
7851 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7852 {
7853 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7854 vos_mem_free(pWdaParams);
7855 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7856 CONVERT_WDI2SIR_STATUS(wdiStatus));
7857 }
7858
7859 return;
7860}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7861/*
7862 * FUNCTION: WDA_ProcessEnterImpsReq
7863 * Request to WDI to Enter IMPS power state.
7864 */
7865VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
7866{
7867 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7868 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
7869 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7871 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7872
7873
7874 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
7875 if (NULL == wdiEnterImpsReqParams)
7876 {
7877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7878 "%s: VOS MEM Alloc Failure", __func__);
7879 VOS_ASSERT(0);
7880 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7881 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7882 return VOS_STATUS_E_NOMEM;
7883 }
7884
7885 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7886 if (NULL == pWdaParams)
7887 {
7888 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7889 "%s: VOS MEM Alloc Failure", __func__);
7890 VOS_ASSERT(0);
7891 vos_mem_free(wdiEnterImpsReqParams);
7892 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
7893 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7894 return VOS_STATUS_E_NOMEM;
7895 }
7896
7897 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
7898 wdiEnterImpsReqParams->pUserData = pWdaParams;
7899
7900 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
7901 pWdaParams->wdaMsgParam = NULL;
7902 pWdaParams->pWdaContext = pWDA;
7903
7904 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
7905 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
7906 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7907 if(IS_WDI_STATUS_FAILURE(status))
7908 {
7909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7910 "Failure in Enter IMPS REQ WDI API, free all the memory " );
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7911 vos_mem_free(wdiEnterImpsReqParams);
7912 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7913 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7914 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7915 return CONVERT_WDI2VOS_STATUS(status) ;
7916}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7917/*
7918 * FUNCTION: WDA_ExitImpsReqCallback
7919 * send Exit IMPS RSP back to PE
7920 */
7921void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
7922{
7923 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7924 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7925 "<------ %s " ,__func__);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7926 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7927 return ;
7928}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7929/*
7930 * FUNCTION: WDA_ProcessExitImpsReq
7931 * Request to WDI to Exit IMPS power state.
7932 */
7933VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
7934{
7935 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7937 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7938 status = WDI_ExitImpsReq((WDI_ExitImpsRspCb)WDA_ExitImpsReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7939 if(IS_WDI_STATUS_FAILURE(status))
7940 {
7941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7942 "Failure in Exit IMPS REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7943 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7944 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7945 return CONVERT_WDI2VOS_STATUS(status) ;
7946}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7947/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7948 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7949 * send Enter BMPS RSP back to PE
7950 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7951void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7952{
7953 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7954 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7955 tEnterBmpsParams *pEnterBmpsRspParams;
7956
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7958 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7959 if(NULL == pWdaParams)
7960 {
7961 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7962 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7963 VOS_ASSERT(0) ;
7964 return ;
7965 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7966
7967 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7968 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
7969
7970 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7971 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7972
7973 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7974 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7975 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
7976
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7977 return ;
7978}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7979/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7980 * FUNCTION: WDA_EnterBmpsReqCallback
7981 * Free memory and send Enter BMPS RSP back to PE.
7982 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
7983 */
7984void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7985{
7986 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7987 tWDA_CbContext *pWDA;
7988 tEnterBmpsParams *pEnterBmpsRspParams;
7989
7990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7991 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7992
7993 if(NULL == pWdaParams)
7994 {
7995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7996 "%s: pWdaParams received NULL", __func__);
7997 VOS_ASSERT(0);
7998 return;
7999 }
8000
8001 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8002 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8003 pEnterBmpsRspParams->status = wdiStatus;
8004
8005 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8006 {
8007 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8008 vos_mem_free(pWdaParams);
8009 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
8010 }
8011
8012 return;
8013}
8014/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8015 * FUNCTION: WDA_ProcessEnterBmpsReq
8016 * Request to WDI to Enter BMPS power state.
8017 */
8018VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
8019 tEnterBmpsParams *pEnterBmpsReqParams)
8020{
8021 WDI_Status status = WDI_STATUS_SUCCESS;
8022 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
8023 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8024 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8025 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8026 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
8027 {
8028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8029 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8030 VOS_ASSERT(0);
8031 return VOS_STATUS_E_FAILURE;
8032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8033 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
8034 if (NULL == wdiEnterBmpsReqParams)
8035 {
8036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8037 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8038 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8039 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8040 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8041 return VOS_STATUS_E_NOMEM;
8042 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8043 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8044 if (NULL == pWdaParams)
8045 {
8046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8047 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8048 VOS_ASSERT(0);
8049 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8050 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8051 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8052 return VOS_STATUS_E_NOMEM;
8053 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8054 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
8055 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
8056 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
8057 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]8058 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8059 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
8060 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
8061 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8062 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
8063 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8064
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8065 /* Store param pointer as passed in by caller */
8066 /* store Params pass it to WDI */
8067 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8068 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8069 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8070 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8071 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8072 if (IS_WDI_STATUS_FAILURE(status))
8073 {
8074 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8075 "Failure in Enter BMPS REQ WDI API, free all the memory" );
8076 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8077 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8078 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8079 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8080 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8081 return CONVERT_WDI2VOS_STATUS(status);
8082}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8083
8084
8085static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
8086 WDI_Status wdiStatus,
8087 tExitBmpsParams *pExitBmpsReqParams)
8088{
8089 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
8090
8091 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
8092}
8093
8094
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8095/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8096 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8097 * send Exit BMPS RSP back to PE
8098 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8099void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8100{
8101 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8102 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8103 tExitBmpsParams *pExitBmpsRspParams;
8104
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8105 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8106 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8107 if(NULL == pWdaParams)
8108 {
8109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8110 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8111 VOS_ASSERT(0) ;
8112 return ;
8113 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8114
8115 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8116 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8117
8118 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8119 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8120
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8121 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8122 vos_mem_free(pWdaParams) ;
8123
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8124 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8125 return ;
8126}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8127/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8128 * FUNCTION: WDA_ExitBmpsReqCallback
8129 * Free memory and send Exit BMPS RSP back to PE.
8130 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
8131 */
8132void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8133{
8134 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8135 tWDA_CbContext *pWDA;
8136 tExitBmpsParams *pExitBmpsRspParams;
8137
8138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8139 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8140
8141 if(NULL == pWdaParams)
8142 {
8143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8144 "%s: pWdaParams received NULL", __func__);
8145 VOS_ASSERT(0);
8146 return;
8147 }
8148
8149 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8150 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8151 pExitBmpsRspParams->status = wdiStatus;
8152
8153 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8154 {
8155 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8156 vos_mem_free(pWdaParams);
8157 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
8158 }
8159
8160 return;
8161}
8162/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8163 * FUNCTION: WDA_ProcessExitBmpsReq
8164 * Request to WDI to Exit BMPS power state.
8165 */
8166VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
8167 tExitBmpsParams *pExitBmpsReqParams)
8168{
8169 WDI_Status status = WDI_STATUS_SUCCESS ;
8170 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
8171 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
8172 sizeof(WDI_ExitBmpsReqParamsType)) ;
8173 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8175 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8176 if(NULL == wdiExitBmpsReqParams)
8177 {
8178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8179 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8180 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8181 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8182 return VOS_STATUS_E_NOMEM;
8183 }
8184 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8185 if(NULL == pWdaParams)
8186 {
8187 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8188 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8189 VOS_ASSERT(0);
8190 vos_mem_free(wdiExitBmpsReqParams);
8191 return VOS_STATUS_E_NOMEM;
8192 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8193 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8194
8195 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
8196
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8197 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
8198 wdiExitBmpsReqParams->pUserData = pWdaParams;
8199
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8200 /* Store param pointer as passed in by caller */
8201 /* store Params pass it to WDI */
8202 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
8203 pWdaParams->pWdaContext = pWDA;
8204 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8205 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8206 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8207 if(IS_WDI_STATUS_FAILURE(status))
8208 {
8209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8210 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8211 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8212 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8213 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8214 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8215 return CONVERT_WDI2VOS_STATUS(status) ;
8216}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8217/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8218 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8219 * send Enter UAPSD RSP back to PE
8220 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8221void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8222{
8223 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8224 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8225 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8226 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8227 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8228 if(NULL == pWdaParams)
8229 {
8230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8231 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8232 VOS_ASSERT(0) ;
8233 return ;
8234 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8235
8236 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8237 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8238
8239 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8240 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8241
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8242 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8243 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8244 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8245 return ;
8246}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8247/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8248 * FUNCTION: WDA_EnterUapsdReqCallback
8249 * Free memory and send Enter UAPSD RSP back to PE.
8250 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
8251 */
8252void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8253{
8254 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8255 tWDA_CbContext *pWDA;
8256 tUapsdParams *pEnterUapsdRsqParams;
8257
8258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8259 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8260
8261 if(NULL == pWdaParams)
8262 {
8263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8264 "%s: pWdaParams received NULL", __func__);
8265 VOS_ASSERT(0);
8266 return;
8267 }
8268
8269 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8270 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8271 pEnterUapsdRsqParams->status = wdiStatus;
8272
8273 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8274 {
8275 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8276 vos_mem_free(pWdaParams);
8277 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
8278 }
8279
8280 return;
8281}
8282/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8283 * FUNCTION: WDA_ProcessEnterUapsdReq
8284 * Request to WDI to Enter UAPSD power state.
8285 */
8286VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
8287 tUapsdParams *pEnterUapsdReqParams)
8288{
8289 WDI_Status status = WDI_STATUS_SUCCESS ;
8290 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
8291 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
8292 sizeof(WDI_EnterUapsdReqParamsType)) ;
8293 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8294 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8295 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8296 if(NULL == wdiEnterUapsdReqParams)
8297 {
8298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8299 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8300 VOS_ASSERT(0);
8301 return VOS_STATUS_E_NOMEM;
8302 }
8303 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8304 if(NULL == pWdaParams)
8305 {
8306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8307 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8308 VOS_ASSERT(0);
8309 vos_mem_free(wdiEnterUapsdReqParams);
8310 return VOS_STATUS_E_NOMEM;
8311 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8312 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
8313 pEnterUapsdReqParams->beDeliveryEnabled;
8314 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
8315 pEnterUapsdReqParams->beTriggerEnabled;
8316 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
8317 pEnterUapsdReqParams->bkDeliveryEnabled;
8318 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
8319 pEnterUapsdReqParams->bkTriggerEnabled;
8320 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
8321 pEnterUapsdReqParams->viDeliveryEnabled;
8322 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
8323 pEnterUapsdReqParams->viTriggerEnabled;
8324 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
8325 pEnterUapsdReqParams->voDeliveryEnabled;
8326 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
8327 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8328 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8329
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8330 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
8331 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8332
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8333 /* Store param pointer as passed in by caller */
8334 /* store Params pass it to WDI */
8335 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
8336 pWdaParams->pWdaContext = pWDA;
8337 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8338 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8339 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8340 if(IS_WDI_STATUS_FAILURE(status))
8341 {
8342 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8343 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
8344 vos_mem_free(pWdaParams->wdaMsgParam) ;
8345 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8346 vos_mem_free(pWdaParams) ;
8347 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8348 return CONVERT_WDI2VOS_STATUS(status) ;
8349}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8350/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8351 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8352 * send Exit UAPSD RSP back to PE
8353 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8354void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8355{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8356
8357 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8358 tWDA_CbContext *pWDA;
8359 tExitUapsdParams *pExitUapsdRspParams;
8360
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8361 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8362 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8363 if(NULL == pWdaParams)
8364 {
8365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8366 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8367 VOS_ASSERT(0);
8368 return;
8369 }
8370
8371 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8372 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8373
8374 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8375 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8376
8377 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8378 vos_mem_free(pWdaParams) ;
8379
8380 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8381 return ;
8382}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8383/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8384 * FUNCTION: WDA_ExitUapsdReqCallback
8385 * Free memory and send Exit UAPSD RSP back to PE.
8386 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
8387 */
8388void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8389{
8390 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8391 tWDA_CbContext *pWDA;
8392 tExitUapsdParams *pExitUapsdRspParams;
8393
8394 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8395 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8396
8397 if(NULL == pWdaParams)
8398 {
8399 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8400 "%s: pWdaParams received NULL", __func__);
8401 VOS_ASSERT(0);
8402 return;
8403 }
8404
8405 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8406 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8407 pExitUapsdRspParams->status = wdiStatus;
8408
8409 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8410 {
8411 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8412 vos_mem_free(pWdaParams);
8413 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
8414 }
8415
8416 return;
8417}
8418/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8419 * FUNCTION: WDA_ProcessExitUapsdReq
8420 * Request to WDI to Exit UAPSD power state.
8421 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8422VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
8423 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8424{
8425 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8426 tWDA_ReqParams *pWdaParams ;
8427 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
8428 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
8429 sizeof(WDI_ExitUapsdReqParamsType)) ;
8430
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8432 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8433
8434 if(NULL == wdiExitUapsdReqParams)
8435 {
8436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8437 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8438 VOS_ASSERT(0);
8439 return VOS_STATUS_E_NOMEM;
8440 }
8441 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8442 if(NULL == pWdaParams)
8443 {
8444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8445 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8446 VOS_ASSERT(0);
8447 vos_mem_free(wdiExitUapsdReqParams);
8448 return VOS_STATUS_E_NOMEM;
8449 }
8450
8451 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8452 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
8453 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8454
8455 /* Store param pointer as passed in by caller */
8456 /* store Params pass it to WDI */
8457 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
8458 pWdaParams->pWdaContext = pWDA;
8459 pWdaParams->wdaMsgParam = pExitUapsdParams;
8460
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8461 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8462 if(IS_WDI_STATUS_FAILURE(status))
8463 {
8464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8465 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8466 vos_mem_free(pWdaParams->wdaMsgParam) ;
8467 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8468 vos_mem_free(pWdaParams) ;
8469
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8470 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8471 return CONVERT_WDI2VOS_STATUS(status) ;
8472}
8473
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8474/*
8475 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
8476 *
8477 */
8478void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
8479{
8480 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8482 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8483 if(NULL == pWdaParams)
8484 {
8485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8486 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8487 VOS_ASSERT(0) ;
8488 return ;
8489 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8490 if( pWdaParams != NULL )
8491 {
8492 if( pWdaParams->wdaWdiApiMsgParam != NULL )
8493 {
8494 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8495 }
8496 if( pWdaParams->wdaMsgParam != NULL )
8497 {
8498 vos_mem_free(pWdaParams->wdaMsgParam) ;
8499 }
8500 vos_mem_free(pWdaParams) ;
8501 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8502 return ;
8503}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8504/*
8505 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
8506 * Request to WDI to set the power save params at start.
8507 */
8508VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
8509 tSirPowerSaveCfg *pPowerSaveCfg)
8510{
8511 WDI_Status status = WDI_STATUS_SUCCESS ;
8512 tHalCfg *tlvStruct = NULL ;
8513 tANI_U8 *tlvStructStart = NULL ;
8514 v_PVOID_t *configParam;
8515 tANI_U32 configParamSize;
8516 tANI_U32 *configDataValue;
8517 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
8518 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8520 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8521 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
8522 {
8523 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8524 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8525 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8526 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8527 return VOS_STATUS_E_FAILURE;
8528 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8529 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
8530 if (NULL == wdiPowerSaveCfg)
8531 {
8532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8533 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8534 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8535 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8536 return VOS_STATUS_E_NOMEM;
8537 }
8538 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8539 if(NULL == pWdaParams)
8540 {
8541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8542 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8543 VOS_ASSERT(0);
8544 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8545 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8546 return VOS_STATUS_E_NOMEM;
8547 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8548 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
8549 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8550 if(NULL == configParam)
8551 {
8552 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8553 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8554 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8555 vos_mem_free(pWdaParams);
8556 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8557 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8558 return VOS_STATUS_E_NOMEM;
8559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8560 vos_mem_set(configParam, configParamSize, 0);
8561 wdiPowerSaveCfg->pConfigBuffer = configParam;
8562 tlvStruct = (tHalCfg *)configParam;
8563 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8564 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
8565 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
8566 tlvStruct->length = sizeof(tANI_U32);
8567 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8568 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8569 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8570 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8571 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
8572 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
8573 tlvStruct->length = sizeof(tANI_U32);
8574 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8575 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8576 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8577 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8578 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
8579 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
8580 tlvStruct->length = sizeof(tANI_U32);
8581 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8582 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8583 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8584 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8585 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
8586 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
8587 tlvStruct->length = sizeof(tANI_U32);
8588 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8589 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8590 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8591 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8592 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
8593 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
8594 tlvStruct->length = sizeof(tANI_U32);
8595 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8596 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8597 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8598 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8599 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
8600 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
8601 tlvStruct->length = sizeof(tANI_U32);
8602 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8603 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8604 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8605 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8606 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
8607 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
8608 tlvStruct->length = sizeof(tANI_U32);
8609 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8610 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8611 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8612 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8613 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
8614 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
8615 tlvStruct->length = sizeof(tANI_U32);
8616 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8617 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
8618 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8619 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8620 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
8621 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
8622 tlvStruct->length = sizeof(tANI_U32);
8623 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8624 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
8625 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8626 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8627 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
8628 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
8629 tlvStruct->length = sizeof(tANI_U32);
8630 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8631 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8632 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8633 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8634 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
8635 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
8636 tlvStruct->length = sizeof(tANI_U32);
8637 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8638 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8639 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8640 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8641 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8642 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8643 /* store Params pass it to WDI */
8644 pWdaParams->wdaMsgParam = configParam;
8645 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
8646 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8647 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
8648 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8649 if(IS_WDI_STATUS_FAILURE(status))
8650 {
8651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8652 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
8653 vos_mem_free(pWdaParams->wdaMsgParam);
8654 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8655 vos_mem_free(pWdaParams);
8656 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8657 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8658 return CONVERT_WDI2VOS_STATUS(status);
8659}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8660/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8661 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8662 *
8663 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8664void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8665{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8666 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8667
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8669 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8670
8671 if(NULL == pWdaParams)
8672 {
8673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8674 "%s: pWdaParams received NULL", __func__);
8675 VOS_ASSERT(0);
8676 return ;
8677 }
8678
8679 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8680 vos_mem_free(pWdaParams);
8681
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8682 return ;
8683}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8684/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8685 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
8686 * Free memory.
8687 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
8688 */
8689void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8690{
8691 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8692
8693 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8694 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8695
8696 if(NULL == pWdaParams)
8697 {
8698 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8699 "%s: pWdaParams received NULL", __func__);
8700 VOS_ASSERT(0);
8701 return;
8702 }
8703
8704 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8705 {
8706 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8707 vos_mem_free(pWdaParams);
8708 }
8709
8710 return;
8711}
8712/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8713 * FUNCTION: WDA_SetUapsdAcParamsReq
8714 * Request to WDI to set the UAPSD params for an ac (sta mode).
8715 */
8716VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
8717 tUapsdInfo *pUapsdInfo)
8718{
8719 WDI_Status status = WDI_STATUS_SUCCESS;
8720 tWDA_CbContext *pWDA = NULL ;
8721 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
8722 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
8723 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
8724 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8725 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8726 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8727 if(NULL == wdiUapsdParams)
8728 {
8729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8730 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8731 VOS_ASSERT(0);
8732 return VOS_STATUS_E_NOMEM;
8733 }
8734 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8735 if(NULL == pWdaParams)
8736 {
8737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8738 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8739 VOS_ASSERT(0);
8740 vos_mem_free(wdiUapsdParams);
8741 return VOS_STATUS_E_NOMEM;
8742 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8743 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
8744 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
8745 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
8746 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
8747 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
8748 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8749 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
8750 wdiUapsdParams->pUserData = pWdaParams;
8751
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8752 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8753 pWdaParams->pWdaContext = pWDA;
8754 /* Store param pointer as passed in by caller */
8755 pWdaParams->wdaMsgParam = pUapsdInfo;
8756 /* store Params pass it to WDI */
8757 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8758 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8759 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8760 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8761 if(IS_WDI_STATUS_FAILURE(status))
8762 {
8763 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8764 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
8765 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8766 vos_mem_free(pWdaParams);
8767 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8768 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
8769 return VOS_STATUS_SUCCESS;
8770 else
8771 return VOS_STATUS_E_FAILURE;
8772
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8773}
8774/*
8775 * FUNCTION: WDA_ClearUapsdAcParamsReq
8776 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
8777 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
8778 * and again enter the UPASD with the modified params. Hence the disable
8779 * function was kept empty.
8780 *
8781 */
8782VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
8783{
8784 /* do nothing */
8785 return VOS_STATUS_SUCCESS;
8786}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8787/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8788 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8789 *
8790 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8791void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8792{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8793 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8794
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8796 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8797
8798 if(NULL == pWdaParams)
8799 {
8800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8801 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8802 VOS_ASSERT(0) ;
8803 return ;
8804 }
8805
8806 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8807 vos_mem_free(pWdaParams->wdaMsgParam);
8808 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8809
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8810 //print a msg, nothing else to do
8811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8812 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8813 return ;
8814}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8815/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8816 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
8817 * Free memory.
8818 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
8819 */
8820void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8821{
8822 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8823
8824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8825 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8826
8827 if(NULL == pWdaParams)
8828 {
8829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8830 "%s: pWdaParams received NULL", __func__);
8831 VOS_ASSERT(0);
8832 return;
8833 }
8834
8835 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8836 {
8837 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8838 vos_mem_free(pWdaParams->wdaMsgParam);
8839 vos_mem_free(pWdaParams);
8840 }
8841
8842 return;
8843}
8844/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8845 * FUNCTION: WDA_UpdateUapsdParamsReq
8846 * Request to WDI to update UAPSD params (in softAP mode) for a station.
8847 */
8848VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
8849 tUpdateUapsdParams* pUpdateUapsdInfo)
8850{
8851 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8852 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8853 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
8854 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
8855 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8856 tWDA_ReqParams *pWdaParams = NULL;
8857
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8859 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8860 if(NULL == wdiUpdateUapsdParams)
8861 {
8862 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8863 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8864 VOS_ASSERT(0);
8865 return VOS_STATUS_E_NOMEM;
8866 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8867 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
8868 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
8869 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8870 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
8871 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8872
8873 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8874 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8875 {
8876 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8877 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8878 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8879 vos_mem_free(pUpdateUapsdInfo);
8880 vos_mem_free(wdiUpdateUapsdParams);
8881 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8882 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8883 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8884 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8885 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8886 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
8887 pWdaParams->pWdaContext = pWDA;
8888
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8889 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8890 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8891 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8892
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8893 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8894 {
8895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8896 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8897 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
8898 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8899 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8900 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8901 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8902 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8903}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8904/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8905 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8906 *
8907 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8908void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8909{
8910 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8912 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8913 if(WDI_STATUS_SUCCESS != wdiStatus)
8914 {
8915 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8916 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8917 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8918 if(NULL == pWdaParams)
8919 {
8920 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8921 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8922 VOS_ASSERT(0) ;
8923 return ;
8924 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8925 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8926 vos_mem_free(pWdaParams->wdaMsgParam);
8927 vos_mem_free(pWdaParams);
8928 return ;
8929}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8930/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8931 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
8932 * Free memory.
8933 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
8934 */
8935void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8936{
8937 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8938
8939 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8940 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8941
8942 if(NULL == pWdaParams)
8943 {
8944 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8945 "%s: pWdaParams received NULL", __func__);
8946 VOS_ASSERT(0);
8947 return;
8948 }
8949
8950 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8951 {
8952 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8953 vos_mem_free(pWdaParams->wdaMsgParam);
8954 vos_mem_free(pWdaParams);
8955 }
8956
8957 return;
8958}
8959/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8960 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
8961 *
8962 */
8963VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
8964 tSirWlanSetRxpFilters *pWlanSuspendParam)
8965{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8966 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8967 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8968 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8969 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8970 /* Sanity Check
8971 * This is very unlikely and add assert to collect more info next time */
8972 if(NULL == pWlanSuspendParam)
8973 {
8974 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8975 "%s: pWlanSuspendParam received NULL", __func__);
8976 VOS_ASSERT(0) ;
8977 return VOS_STATUS_E_FAULT;
8978 }
8979 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
8980 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8981 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8982 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8983 if(NULL == wdiRxpFilterParams)
8984 {
8985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8986 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8987 VOS_ASSERT(0);
8988 vos_mem_free(pWlanSuspendParam);
8989 return VOS_STATUS_E_NOMEM;
8990 }
8991 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8992 if(NULL == pWdaParams)
8993 {
8994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8995 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8996 VOS_ASSERT(0);
8997 vos_mem_free(wdiRxpFilterParams);
8998 vos_mem_free(pWlanSuspendParam);
8999 return VOS_STATUS_E_NOMEM;
9000 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9001 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
9002 pWlanSuspendParam->setMcstBcstFilter;
9003 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
9004 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9005
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9006 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
9007 wdiRxpFilterParams->pUserData = pWdaParams;
9008
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9009 pWdaParams->pWdaContext = pWDA;
9010 pWdaParams->wdaMsgParam = pWlanSuspendParam;
9011 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9012 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9013 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9014 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9015 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9016 {
9017 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9018 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9019 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9020 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9021 vos_mem_free(pWdaParams->wdaMsgParam);
9022 vos_mem_free(pWdaParams);
9023 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9024 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9025}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9026/*
9027 * FUNCTION: WDA_WdiIndicationCallback
9028 *
9029 */
9030void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
9031 void* pUserData)
9032{
9033 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9034 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9035}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9036/*
9037 * FUNCTION: WDA_ProcessWlanSuspendInd
9038 *
9039 */
9040VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
9041 tSirWlanSuspendParam *pWlanSuspendParam)
9042{
9043 WDI_Status wdiStatus;
9044 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9046 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9047 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
9048 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9049 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
9050 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9051 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]9052 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
9053 if(WDI_STATUS_PENDING == wdiStatus)
9054 {
9055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9056 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9057 }
9058 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9059 {
9060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9061 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9062 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9063 vos_mem_free(pWlanSuspendParam);
9064 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9065}
9066
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]9067#ifdef WLAN_FEATURE_11W
9068/*
9069 * FUNCTION: WDA_ProcessExcludeUnecryptInd
9070 *
9071 */
9072VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
9073 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
9074{
9075 WDI_Status wdiStatus;
9076 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
9077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9078 "------> %s ", __func__);
9079
9080 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
9081 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
9082 sizeof(tSirMacAddr));
9083
9084 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
9085 wdiExclUnencryptParams.pUserData = pWDA;
9086
9087 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
9088 if(WDI_STATUS_PENDING == wdiStatus)
9089 {
9090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9091 "Pending received for %s:%d ", __func__, __LINE__ );
9092 }
9093 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9094 {
9095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9096 "Failure in %s:%d ", __func__, __LINE__ );
9097 }
9098 vos_mem_free(pExclUnencryptParam);
9099 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9100}
9101#endif
9102
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9103/*
9104 * FUNCTION: WDA_ProcessWlanResumeCallback
9105 *
9106 */
9107void WDA_ProcessWlanResumeCallback(
9108 WDI_SuspendResumeRspParamsType *resumeRspParams,
9109 void* pUserData)
9110{
9111 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9113 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9114 if(NULL == pWdaParams)
9115 {
9116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9117 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9118 VOS_ASSERT(0) ;
9119 return ;
9120 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9121 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
9122 {
9123 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]9124 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9125 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9126 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9127 vos_mem_free(pWdaParams->wdaMsgParam);
9128 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9129 return ;
9130}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9131/*
9132 * FUNCTION: WDA_ProcessWlanResumeReq
9133 *
9134 */
9135VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
9136 tSirWlanResumeParam *pWlanResumeParam)
9137{
9138 WDI_Status wdiStatus;
9139 WDI_ResumeParamsType *wdiResumeParams =
9140 (WDI_ResumeParamsType *)vos_mem_malloc(
9141 sizeof(WDI_ResumeParamsType) ) ;
9142 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9144 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9145 if(NULL == wdiResumeParams)
9146 {
9147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9148 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9149 VOS_ASSERT(0);
9150 return VOS_STATUS_E_NOMEM;
9151 }
9152 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9153 if(NULL == pWdaParams)
9154 {
9155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9156 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9157 VOS_ASSERT(0);
9158 vos_mem_free(wdiResumeParams);
9159 return VOS_STATUS_E_NOMEM;
9160 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9161 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
9162 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9163 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]9164 wdiResumeParams->wdiReqStatusCB = NULL;
9165 pWdaParams->wdaMsgParam = pWlanResumeParam;
9166 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
9167 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9168 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
9169 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
9170 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9171 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9172 {
9173 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9174 "Failure in Host Resume REQ WDI API, free all the memory " );
9175 VOS_ASSERT(0);
9176 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9177 vos_mem_free(pWdaParams->wdaMsgParam);
9178 vos_mem_free(pWdaParams);
9179 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9180 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9181}
9182
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9183/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9184 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9185 *
9186 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9187void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9188{
9189 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9191 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9192 if(NULL == pWdaParams)
9193 {
9194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9195 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9196 VOS_ASSERT(0) ;
9197 return ;
9198 }
9199
9200 vos_mem_free(pWdaParams->wdaMsgParam) ;
9201 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9202 vos_mem_free(pWdaParams) ;
9203 /*
9204 * No respone required for SetBeaconFilter req so just free the request
9205 * param here
9206 */
9207
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9208 return ;
9209}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9210/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9211 * FUNCTION: WDA_SetBeaconFilterReqCallback
9212 * Free memory.
9213 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
9214 */
9215void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9216{
9217 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9218
9219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9220 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9221
9222 if(NULL == pWdaParams)
9223 {
9224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9225 "%s: pWdaParams received NULL", __func__);
9226 VOS_ASSERT(0);
9227 return;
9228 }
9229
9230 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9231 {
9232 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9233 vos_mem_free(pWdaParams->wdaMsgParam);
9234 vos_mem_free(pWdaParams);
9235 }
9236
9237 return;
9238}
9239/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9240 * FUNCTION: WDA_SetBeaconFilterReq
9241 * Request to WDI to send the beacon filtering related information.
9242 */
9243VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
9244 tBeaconFilterMsg* pBeaconFilterInfo)
9245{
9246 WDI_Status status = WDI_STATUS_SUCCESS;
9247 tANI_U8 *dstPtr, *srcPtr;
9248 tANI_U8 filterLength;
9249 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
9250 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
9251 sizeof(WDI_BeaconFilterReqParamsType) ) ;
9252 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9254 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9255 if(NULL == wdiBeaconFilterInfo)
9256 {
9257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9258 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9259 VOS_ASSERT(0);
9260 return VOS_STATUS_E_NOMEM;
9261 }
9262 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9263 if(NULL == pWdaParams)
9264 {
9265 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9266 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9267 VOS_ASSERT(0);
9268 vos_mem_free(wdiBeaconFilterInfo);
9269 return VOS_STATUS_E_NOMEM;
9270 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9271 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
9272 pBeaconFilterInfo->beaconInterval;
9273 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
9274 pBeaconFilterInfo->capabilityInfo;
9275 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
9276 pBeaconFilterInfo->capabilityMask;
9277 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]9278
9279 //Fill the BssIdx
9280 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
9281
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9282 //Fill structure with info contained in the beaconFilterTable
9283 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
9284 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
9285 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
9286 if(WDI_BEACON_FILTER_LEN < filterLength)
9287 {
9288 filterLength = WDI_BEACON_FILTER_LEN;
9289 }
9290 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9291 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
9292 wdiBeaconFilterInfo->pUserData = pWdaParams;
9293
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9294 /* Store param pointer as passed in by caller */
9295 /* store Params pass it to WDI */
9296 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
9297 pWdaParams->pWdaContext = pWDA;
9298 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
9299
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9300 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9301 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9302 if(IS_WDI_STATUS_FAILURE(status))
9303 {
9304 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9305 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
9306 vos_mem_free(pWdaParams->wdaMsgParam) ;
9307 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9308 vos_mem_free(pWdaParams) ;
9309 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9310 return CONVERT_WDI2VOS_STATUS(status) ;
9311}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9312/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9313 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9314 *
9315 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9316void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9317{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9318 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9319
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9321 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9322
9323 if(NULL == pWdaParams)
9324 {
9325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9326 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9327 VOS_ASSERT(0) ;
9328 return ;
9329 }
9330
9331 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9332 vos_mem_free(pWdaParams->wdaMsgParam);
9333 vos_mem_free(pWdaParams);
9334
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9335 //print a msg, nothing else to do
9336 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9337 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9338 return ;
9339}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9340/*
9341 * FUNCTION: WDA_RemBeaconFilterReqCallback
9342 * Free memory.
9343 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
9344 */
9345void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9346{
9347 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9348
9349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9350 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9351
9352 if(NULL == pWdaParams)
9353 {
9354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9355 "%s: pWdaParams received NULL", __func__);
9356 VOS_ASSERT(0);
9357 return;
9358 }
9359
9360 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9361 {
9362 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9363 vos_mem_free(pWdaParams->wdaMsgParam);
9364 vos_mem_free(pWdaParams);
9365 }
9366
9367 return;
9368}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9369 // TODO: PE does not have this feature for now implemented,
9370 // but the support for removing beacon filter exists between
9371 // HAL and FW. This function can be called whenever PE defines
9372 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9373/*
9374 * FUNCTION: WDA_RemBeaconFilterReq
9375 * Request to WDI to send the removal of beacon filtering related information.
9376 */
9377VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
9378 tRemBeaconFilterMsg* pBeaconFilterInfo)
9379{
9380 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9381 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9382 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
9383 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
9384 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9385 tWDA_ReqParams *pWdaParams ;
9386
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9387 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9388 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9389 if(NULL == wdiBeaconFilterInfo)
9390 {
9391 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9392 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9393 VOS_ASSERT(0);
9394 return VOS_STATUS_E_NOMEM;
9395 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9396 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9397 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9398 {
9399 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9400 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9401 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9402 vos_mem_free(wdiBeaconFilterInfo);
9403 vos_mem_free(pBeaconFilterInfo);
9404 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9405 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9406
9407 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
9408 pBeaconFilterInfo->ucIeCount;
9409 //Fill structure with info contained in the ucRemIeId
9410 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
9411 pBeaconFilterInfo->ucRemIeId,
9412 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
9413 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
9414 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9415
9416 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9417 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9418 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9419 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
9420
9421 pWdaParams->pWdaContext = pWDA;
9422
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9423 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9424 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9425 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9426 {
9427 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9428 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9429 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9430 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9431 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9432 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9433 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9434 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9435}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9436/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9437 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9438 *
9439 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9440void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9441{
9442 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9444 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9445 if(NULL == pWdaParams)
9446 {
9447 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9448 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9449 VOS_ASSERT(0) ;
9450 return ;
9451 }
9452
9453 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9454 vos_mem_free(pWdaParams) ;
9455
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9456 return ;
9457}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9458/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9459 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
9460 * Free memory.
9461 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
9462 */
9463void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
9464{
9465 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9466
9467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9468 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9469
9470 if(NULL == pWdaParams)
9471 {
9472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9473 "%s: pWdaParams received NULL", __func__);
9474 VOS_ASSERT(0);
9475 return;
9476 }
9477
9478 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9479 {
9480 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9481 vos_mem_free(pWdaParams);
9482 }
9483
9484 return;
9485}
9486/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9487 * FUNCTION: WDA_SetRSSIThresholdsReq
9488 * Request to WDI to set the RSSI thresholds (sta mode).
9489 */
9490VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
9491{
9492 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9493 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9494 tWDA_CbContext *pWDA = NULL ;
9495 v_PVOID_t pVosContext = NULL;
9496 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
9497 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
9498 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
9499 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9500 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9501 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9502 if(NULL == wdiRSSIThresholdsInfo)
9503 {
9504 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9505 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9506 VOS_ASSERT(0);
9507 return VOS_STATUS_E_NOMEM;
9508 }
9509 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9510 if(NULL == pWdaParams)
9511 {
9512 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9513 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9514 VOS_ASSERT(0);
9515 vos_mem_free(wdiRSSIThresholdsInfo);
9516 return VOS_STATUS_E_NOMEM;
9517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9518 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9519 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
9520 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
9521 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9522 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
9523 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
9524 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9525 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
9526 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
9527 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9528 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
9529 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9530 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
9531 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
9532
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9533 /* Store param pointer as passed in by caller */
9534 /* store Params pass it to WDI */
9535 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
9536 pWdaParams->pWdaContext = pWDA;
9537 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9538 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9539 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9540 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9541 {
9542 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9543 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9544 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9545 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9546 vos_mem_free(pWdaParams) ;
9547 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9548 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9549
9550}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9551/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9552 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9553 *
9554 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9555void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9556{
9557 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9558
9559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9560 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9561 if(NULL == pWdaParams)
9562 {
9563 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9564 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9565 VOS_ASSERT(0) ;
9566 return ;
9567 }
9568
9569 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9570 vos_mem_free(pWdaParams->wdaMsgParam);
9571 vos_mem_free(pWdaParams) ;
9572
9573 //print a msg, nothing else to do
9574 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9575 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9576 return ;
9577}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9578/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9579 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9580 * Free memory.
9581 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9582 */
9583void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
9584{
9585 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9586
9587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9588 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9589
9590 if(NULL == pWdaParams)
9591 {
9592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9593 "%s: Invalid pWdaParams pointer", __func__);
9594 VOS_ASSERT(0);
9595 return;
9596 }
9597
9598 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9599 {
9600 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9601 vos_mem_free(pWdaParams->wdaMsgParam);
9602 vos_mem_free(pWdaParams);
9603 }
9604
9605 return;
9606}
9607/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9608 * FUNCTION: WDA_ProcessHostOffloadReq
9609 * Request to WDI to set the filter to minimize unnecessary host wakeup due
9610 * to broadcast traffic (sta mode).
9611 */
9612VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
9613 tSirHostOffloadReq *pHostOffloadParams)
9614{
9615 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9616 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9617 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
9618 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
9619 sizeof(WDI_HostOffloadReqParamsType)) ;
9620 tWDA_ReqParams *pWdaParams ;
9621
9622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9623 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9624
9625 if(NULL == wdiHostOffloadInfo)
9626 {
9627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9628 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9629 VOS_ASSERT(0);
9630 return VOS_STATUS_E_NOMEM;
9631 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9632 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9633 if(NULL == pWdaParams)
9634 {
9635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9636 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9637 VOS_ASSERT(0);
9638 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9639 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9640 return VOS_STATUS_E_NOMEM;
9641 }
9642
9643 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
9644 pHostOffloadParams->offloadType;
9645 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
9646 pHostOffloadParams->enableOrDisable;
9647
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9648 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
9649 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
9650
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9651 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
9652 {
9653 case SIR_IPV4_ARP_REPLY_OFFLOAD:
9654 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
9655 pHostOffloadParams->params.hostIpv4Addr,
9656 4);
9657 break;
9658 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
9659 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9660 pHostOffloadParams->params.hostIpv6Addr,
9661 16);
9662 break;
9663 case SIR_IPV6_NS_OFFLOAD:
9664 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9665 pHostOffloadParams->params.hostIpv6Addr,
9666 16);
9667
9668#ifdef WLAN_NS_OFFLOAD
9669 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
9670 {
9671 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
9672 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
9673 16);
9674 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
9675 }
9676 else
9677 {
9678 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
9679 }
9680
9681 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
9682 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
9683 16);
9684 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
9685 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
9686 6);
9687
9688 //Only two are supported so let's go through them without a loop
9689 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
9690 {
9691 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
9692 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
9693 16);
9694 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
9695 }
9696 else
9697 {
9698 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
9699 }
9700
9701 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
9702 {
9703 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
9704 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
9705 16);
9706 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
9707 }
9708 else
9709 {
9710 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
9711 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]9712 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
9713 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9714 break;
9715#endif //WLAN_NS_OFFLOAD
9716 default:
9717 {
9718 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9719 "No Handling for Offload Type %x in WDA "
9720 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
9721 //WDA_VOS_ASSERT(0) ;
9722 }
9723 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9724 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
9725 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9726
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9727 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9728 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9729 /* store Params pass it to WDI */
9730 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
9731 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9732
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9733
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9734 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9735 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9736
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9737 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9738 {
9739 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9740 "Failure in host offload REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9741 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9742 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9743 vos_mem_free(pWdaParams->wdaMsgParam);
9744 vos_mem_free(pWdaParams) ;
9745 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9746 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9747
9748}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9749/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9750 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9751 *
9752 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9753void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9754{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9755 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9756
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9758 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9759
9760 if(NULL == pWdaParams)
9761 {
9762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9763 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9764 VOS_ASSERT(0) ;
9765 return ;
9766 }
9767
9768 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9769 vos_mem_free(pWdaParams->wdaMsgParam);
9770 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9771
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9772 //print a msg, nothing else to do
9773 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9774 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9775 return ;
9776}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9777/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9778 * FUNCTION: WDA_KeepAliveReqCallback
9779 * Free memory.
9780 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
9781 */
9782void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
9783{
9784 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9785
9786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9787 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9788
9789 if(NULL == pWdaParams)
9790 {
9791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9792 "%s: pWdaParams received NULL", __func__);
9793 VOS_ASSERT(0);
9794 return;
9795 }
9796
9797 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9798 {
9799 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9800 vos_mem_free(pWdaParams->wdaMsgParam);
9801 vos_mem_free(pWdaParams);
9802 }
9803
9804 return;
9805}
9806/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9807 * FUNCTION: WDA_ProcessKeepAliveReq
9808 * Request to WDI to send Keep Alive packets to minimize unnecessary host
9809 * wakeup due to broadcast traffic (sta mode).
9810 */
9811VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
9812 tSirKeepAliveReq *pKeepAliveParams)
9813{
9814 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9815 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9816 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
9817 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
9818 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9819 tWDA_ReqParams *pWdaParams;
9820
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9822 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9823 if(NULL == wdiKeepAliveInfo)
9824 {
9825 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9826 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9827 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9828 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9829 return VOS_STATUS_E_NOMEM;
9830 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9831
9832 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9833 if(NULL == pWdaParams)
9834 {
9835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9836 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9837 VOS_ASSERT(0);
9838 vos_mem_free(wdiKeepAliveInfo);
9839 vos_mem_free(pKeepAliveParams);
9840 return VOS_STATUS_E_NOMEM;
9841 }
9842
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9843 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
9844 pKeepAliveParams->packetType;
9845 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
9846 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9847
9848 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
9849 pKeepAliveParams->bssId,
9850 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9851
9852 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
9853 {
9854 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9855 pKeepAliveParams->hostIpv4Addr,
9856 SIR_IPV4_ADDR_LEN);
9857 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9858 pKeepAliveParams->destIpv4Addr,
9859 SIR_IPV4_ADDR_LEN);
9860 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9861 pKeepAliveParams->destMacAddr,
9862 SIR_MAC_ADDR_LEN);
9863 }
9864 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
9865 {
9866 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9867 SIR_IPV4_ADDR_LEN,
9868 0);
9869 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9870 SIR_IPV4_ADDR_LEN,
9871 0);
9872 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9873 SIR_MAC_ADDR_LEN,
9874 0);
9875 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9876 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
9877 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9878
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9879 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9880 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9881 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9882 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
9883 pWdaParams->pWdaContext = pWDA;
9884
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
9886 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
9887 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
9888 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
9889 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
9890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
9891 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
9892 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
9893 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
9894 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
9895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9896 "WDA DMAC : %d:%d:%d:%d:%d:%d",
9897 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
9898 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
9899 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
9900 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
9901 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
9902 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
9903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9904 "TimePeriod %d PacketType %d",
9905 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
9906 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9907 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9908 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9909
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9910 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9911 {
9912 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9913 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9914 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9915 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9916 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9917 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9918 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9919 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9920
9921}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9922/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9923 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9924 *
9925 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9926void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9927 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
9928 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9929{
9930 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9931 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9932 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9933 if(NULL == pWdaParams)
9934 {
9935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9936 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9937 VOS_ASSERT(0) ;
9938 return ;
9939 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9940 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9941 vos_mem_free(pWdaParams->wdaMsgParam);
9942 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9943 return ;
9944}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9945/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9946 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
9947 * Free memory.
9948 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
9949 */
9950void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
9951{
9952 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9953
9954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9955 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9956
9957 if(NULL == pWdaParams)
9958 {
9959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9960 "%s: pWdaParams received NULL", __func__);
9961 VOS_ASSERT(0);
9962 return;
9963 }
9964
9965 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9966 {
9967 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9968 vos_mem_free(pWdaParams->wdaMsgParam);
9969 vos_mem_free(pWdaParams);
9970 }
9971
9972 return;
9973}
9974
9975/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9976 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
9977 * Request to WDI to add WOWL Bcast pattern
9978 */
9979VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
9980 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
9981{
9982 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9983 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9984 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
9985 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
9986 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
9987 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9989 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9990 if(NULL == wdiWowlAddBcPtrnInfo)
9991 {
9992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9993 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9994 VOS_ASSERT(0);
9995 return VOS_STATUS_E_NOMEM;
9996 }
9997 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9998 if(NULL == pWdaParams)
9999 {
10000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10001 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10002 VOS_ASSERT(0);
10003 vos_mem_free(wdiWowlAddBcPtrnInfo);
10004 return VOS_STATUS_E_NOMEM;
10005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10006 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
10007 pWowlAddBcPtrnParams->ucPatternId;
10008 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
10009 pWowlAddBcPtrnParams->ucPatternByteOffset;
10010 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
10011 pWowlAddBcPtrnParams->ucPatternMaskSize;
10012 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
10013 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10014 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
10015 {
10016 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10017 pWowlAddBcPtrnParams->ucPattern,
10018 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
10019 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10020 pWowlAddBcPtrnParams->ucPatternMask,
10021 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
10022 }
10023 else
10024 {
10025 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10026 pWowlAddBcPtrnParams->ucPattern,
10027 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10028 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10029 pWowlAddBcPtrnParams->ucPatternMask,
10030 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10031
10032 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
10033 pWowlAddBcPtrnParams->ucPatternExt,
10034 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10035 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
10036 pWowlAddBcPtrnParams->ucPatternMaskExt,
10037 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10038 }
10039
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10040 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
10041 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
10042
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10043 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
10044 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10045 /* Store param pointer as passed in by caller */
10046 /* store Params pass it to WDI */
10047 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
10048 pWdaParams->pWdaContext = pWDA;
10049 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10050 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10051 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10052 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10053 {
10054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10055 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10056 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10057 vos_mem_free(pWdaParams->wdaMsgParam) ;
10058 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10059 vos_mem_free(pWdaParams) ;
10060 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10061 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10062
10063}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10064/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10065 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10066 *
10067 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10068void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10069 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
10070 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10071{
10072 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10073 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10074 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10075 if(NULL == pWdaParams)
10076 {
10077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10078 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10079 VOS_ASSERT(0) ;
10080 return ;
10081 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10082 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10083 vos_mem_free(pWdaParams->wdaMsgParam);
10084 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10085 return ;
10086}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10087/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10088 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
10089 * Free memory.
10090 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
10091 */
10092void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
10093{
10094 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10095
10096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10097 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10098
10099 if(NULL == pWdaParams)
10100 {
10101 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10102 "%s: pWdaParams received NULL", __func__);
10103 VOS_ASSERT(0);
10104 return;
10105 }
10106
10107 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10108 {
10109 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10110 vos_mem_free(pWdaParams->wdaMsgParam);
10111 vos_mem_free(pWdaParams);
10112 }
10113
10114 return;
10115}
10116/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10117 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
10118 * Request to WDI to delete WOWL Bcast pattern
10119 */
10120VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
10121 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
10122{
10123 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10124 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10125 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
10126 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
10127 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
10128 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10129 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10130 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10131 if(NULL == wdiWowlDelBcPtrnInfo)
10132 {
10133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10134 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10135 VOS_ASSERT(0);
10136 return VOS_STATUS_E_NOMEM;
10137 }
10138 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10139 if(NULL == pWdaParams)
10140 {
10141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10142 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10143 VOS_ASSERT(0);
10144 vos_mem_free(wdiWowlDelBcPtrnInfo);
10145 return VOS_STATUS_E_NOMEM;
10146 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10147 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
10148 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10149
10150 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
10151 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
10152
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10153 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
10154 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10155 /* Store param pointer as passed in by caller */
10156 /* store Params pass it to WDI */
10157 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
10158 pWdaParams->pWdaContext = pWDA;
10159 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10160 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10161 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10162 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10163 {
10164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10165 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10166 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10167 vos_mem_free(pWdaParams->wdaMsgParam) ;
10168 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10169 vos_mem_free(pWdaParams) ;
10170 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10171 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10172
10173}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10174/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10175 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10176 *
10177 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10178void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10179{
10180 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10181 tWDA_CbContext *pWDA;
10182 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10184 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10185 if(NULL == pWdaParams)
10186 {
10187 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10188 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10189 VOS_ASSERT(0) ;
10190 return ;
10191 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10192 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10193 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
10194
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10195 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
10196
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10197 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10198 vos_mem_free(pWdaParams) ;
10199
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10200 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10201 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10202 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10203 return ;
10204}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10205/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10206 * FUNCTION: WDA_WowlEnterReqCallback
10207 * Free memory and send WOWL Enter RSP back to PE.
10208 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
10209 */
10210void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
10211{
10212 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10213 tWDA_CbContext *pWDA;
10214 tSirHalWowlEnterParams *pWowlEnterParams;
10215
10216 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10217 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10218
10219 if(NULL == pWdaParams)
10220 {
10221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10222 "%s: pWdaParams received NULL", __func__);
10223 VOS_ASSERT(0);
10224 return;
10225 }
10226
10227 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10228 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
10229 pWowlEnterParams->status = wdiStatus;
10230
10231 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10232 {
10233 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10234 vos_mem_free(pWdaParams);
10235 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
10236 }
10237
10238 return;
10239}
10240/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10241 * FUNCTION: WDA_ProcessWowlEnterReq
10242 * Request to WDI to enter WOWL
10243 */
10244VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
10245 tSirHalWowlEnterParams *pWowlEnterParams)
10246{
10247 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10248 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10249 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
10250 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
10251 sizeof(WDI_WowlEnterReqParamsType)) ;
10252 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10254 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10255 if(NULL == wdiWowlEnterInfo)
10256 {
10257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10258 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10259 VOS_ASSERT(0);
10260 return VOS_STATUS_E_NOMEM;
10261 }
10262 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10263 if(NULL == pWdaParams)
10264 {
10265 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10266 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10267 VOS_ASSERT(0);
10268 vos_mem_free(wdiWowlEnterInfo);
10269 return VOS_STATUS_E_NOMEM;
10270 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]10271
10272 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
10273
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10274 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
10275 pWowlEnterParams->magicPtrn,
10276 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10277 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
10278 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10279 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
10280 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10281 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
10282 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10283 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
10284 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10285 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
10286 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10287 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
10288 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10289 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
10290 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10291 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
10292 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10293#ifdef WLAN_WAKEUP_EVENTS
10294 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
10295 pWowlEnterParams->ucWoWEAPIDRequestEnable;
10296
10297 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
10298 pWowlEnterParams->ucWoWEAPOL4WayEnable;
10299
10300 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
10301 pWowlEnterParams->ucWowNetScanOffloadMatch;
10302
10303 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
10304 pWowlEnterParams->ucWowGTKRekeyError;
10305
10306 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
10307 pWowlEnterParams->ucWoWBSSConnLoss;
10308#endif // WLAN_WAKEUP_EVENTS
10309
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10310 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
10311 pWowlEnterParams->bssIdx;
10312
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10313 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
10314 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10315 /* Store param pointer as passed in by caller */
10316 /* store Params pass it to WDI */
10317 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
10318 pWdaParams->pWdaContext = pWDA;
10319 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10320 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10321 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10322 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10323 {
10324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10325 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10326 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10327 vos_mem_free(pWdaParams->wdaMsgParam) ;
10328 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10329 vos_mem_free(pWdaParams) ;
10330 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10331 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10332
10333}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10334/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10335 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10336 *
10337 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10338void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10339{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10340 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10341 tWDA_CbContext *pWDA;
10342 tSirHalWowlExitParams *pWowlExitParams;
10343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10344 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10345 if(NULL == pWdaParams)
10346 {
10347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10348 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10349 VOS_ASSERT(0) ;
10350 return ;
10351 }
10352 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10353 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
10354
10355 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10356 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10357
10358 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10359 vos_mem_free(pWdaParams) ;
10360
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10361 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10362 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10363 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10364 return ;
10365}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10366/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10367 * FUNCTION: WDA_WowlExitReqCallback
10368 * Free memory and send WOWL Exit RSP back to PE.
10369 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
10370 */
10371void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
10372{
10373 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10374 tWDA_CbContext *pWDA;
10375 tSirHalWowlExitParams *pWowlExitParams;
10376
10377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10378 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10379
10380 if(NULL == pWdaParams)
10381 {
10382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10383 "%s: pWdaParams received NULL", __func__);
10384 VOS_ASSERT(0);
10385 return;
10386 }
10387
10388 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10389 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
10390 pWowlExitParams->status = wdiStatus;
10391
10392 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10393 {
10394 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10395 vos_mem_free(pWdaParams);
10396 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
10397 }
10398
10399 return;
10400}
10401/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10402 * FUNCTION: WDA_ProcessWowlExitReq
10403 * Request to WDI to add WOWL Bcast pattern
10404 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10405VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
10406 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10407{
10408 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10409 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10410 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
10411 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
10412 sizeof(WDI_WowlExitReqParamsType)) ;
10413 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10414 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10415 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10416 if(NULL == wdiWowlExitInfo)
10417 {
10418 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10419 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10420 VOS_ASSERT(0);
10421 return VOS_STATUS_E_NOMEM;
10422 }
10423 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10424 if(NULL == pWdaParams)
10425 {
10426 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10427 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10428 VOS_ASSERT(0);
10429 vos_mem_free(wdiWowlExitInfo);
10430 return VOS_STATUS_E_NOMEM;
10431 }
10432
10433 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
10434 pWowlExitParams->bssIdx;
10435
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10436 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
10437 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10438
10439 /* Store param pointer as passed in by caller */
10440 /* store Params pass it to WDI */
10441 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
10442 pWdaParams->pWdaContext = pWDA;
10443 pWdaParams->wdaMsgParam = pWowlExitParams;
10444
10445 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10446 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10447
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10448 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10449 {
10450 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10451 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10452 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10453 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10454 vos_mem_free(pWdaParams->wdaMsgParam);
10455 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10456 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10457 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10458}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10459/*
10460 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
10461 * Request to WDI to determine whether a given station is capable of
10462 * using HW-based frame translation
10463 */
10464v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
10465 tANI_U8 staIdx)
10466{
10467 return WDI_IsHwFrameTxTranslationCapable(staIdx);
10468}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10469
10470/*
10471 * FUNCTION: WDA_IsSelfSTA
10472 * Request to WDI to determine whether a given STAID is self station
10473 * index.
10474 */
10475v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
10476{
10477
10478 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10479
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]10480 if (NULL != pWDA)
10481 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
10482 else
10483 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10484}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10485/*
10486 * FUNCTION: WDA_NvDownloadReqCallback
10487 * send NV Download RSP back to PE
10488 */
10489void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
10490 void* pUserData)
10491{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10492
10493 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
10494 tWDA_CbContext *pWDA;
10495
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10497 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10498
10499 if(NULL == pWdaParams)
10500 {
10501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10502 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10503 VOS_ASSERT(0) ;
10504 return ;
10505 }
10506
10507 pWDA = pWdaParams->pWdaContext;
10508
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10509 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10510 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10511 vos_mem_free(pWdaParams);
10512
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10513 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10514 return ;
10515}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10516/*
10517 * FUNCTION: WDA_ProcessNvDownloadReq
10518 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
10519 */
10520VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
10521{
10522 /* Initialize the local Variables*/
10523 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10524 v_VOID_t *pNvBuffer=NULL;
10525 v_SIZE_t bufferSize = 0;
10526 WDI_Status status = WDI_STATUS_E_FAILURE;
10527 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10528 tWDA_ReqParams *pWdaParams ;
10529
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10530 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10531 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10532 if(NULL == pWDA)
10533 {
10534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10535 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10536 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10537 return VOS_STATUS_E_FAILURE;
10538 }
10539
10540 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]10541 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
10542
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10543 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
10544 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10545 if(NULL == wdiNvDownloadReqParam)
10546 {
10547 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10548 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10549 VOS_ASSERT(0);
10550 return VOS_STATUS_E_NOMEM;
10551 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10552 /* Copy Params to wdiNvDownloadReqParam*/
10553 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
10554 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10555
10556 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10557 if(NULL == pWdaParams)
10558 {
10559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10560 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10561 VOS_ASSERT(0);
10562 vos_mem_free(wdiNvDownloadReqParam);
10563 return VOS_STATUS_E_NOMEM;
10564 }
10565
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10566 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10567 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
10568 pWdaParams->wdaMsgParam = NULL;
10569 pWdaParams->pWdaContext = pWDA;
10570
10571
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10572 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10573
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10574 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10575 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
10576
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10577 if(IS_WDI_STATUS_FAILURE(status))
10578 {
10579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10580 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10581 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10582 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10583 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10584 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10585}
10586/*
10587 * FUNCTION: WDA_FlushAcReqCallback
10588 * send Flush AC RSP back to TL
10589 */
10590void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
10591{
10592 vos_msg_t wdaMsg = {0} ;
10593 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10594 tFlushACReq *pFlushACReqParams;
10595 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10597 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10598 if(NULL == pWdaParams)
10599 {
10600 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10601 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10602 VOS_ASSERT(0) ;
10603 return ;
10604 }
10605
10606 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
10607 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
10608 if(NULL == pFlushACRspParams)
10609 {
10610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10611 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10612 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]10613 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10614 return ;
10615 }
10616 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
10617 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
10618 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
10619 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
10620 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10621 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10622 vos_mem_free(pWdaParams->wdaMsgParam) ;
10623 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10624 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10625 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
10626 wdaMsg.bodyptr = (void *)pFlushACRspParams;
10627 // POST message to TL
10628 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
10629
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10630 return ;
10631}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10632/*
10633 * FUNCTION: WDA_ProcessFlushAcReq
10634 * Request to WDI to Update the DELBA REQ params.
10635 */
10636VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
10637 tFlushACReq *pFlushAcReqParams)
10638{
10639 WDI_Status status = WDI_STATUS_SUCCESS ;
10640 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
10641 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
10642 sizeof(WDI_FlushAcReqParamsType)) ;
10643 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10644 if(NULL == wdiFlushAcReqParam)
10645 {
10646 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10647 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10648 VOS_ASSERT(0);
10649 return VOS_STATUS_E_NOMEM;
10650 }
10651 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10652 if(NULL == pWdaParams)
10653 {
10654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10655 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10656 VOS_ASSERT(0);
10657 vos_mem_free(wdiFlushAcReqParam);
10658 return VOS_STATUS_E_NOMEM;
10659 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10661 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10662 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
10663 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
10664 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
10665 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10666 /* Store Flush AC pointer, as this will be used for response */
10667 /* store Params pass it to WDI */
10668 pWdaParams->pWdaContext = pWDA;
10669 pWdaParams->wdaMsgParam = pFlushAcReqParams;
10670 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10671 status = WDI_FlushAcReq(wdiFlushAcReqParam,
10672 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10673 if(IS_WDI_STATUS_FAILURE(status))
10674 {
10675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10676 "Failure in Flush AC REQ Params WDI API, free all the memory " );
10677 vos_mem_free(pWdaParams->wdaMsgParam) ;
10678 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10679 vos_mem_free(pWdaParams) ;
10680 //TODO: respond to TL with failure
10681 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10682 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10683}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10684/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10685 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10686 *
10687 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10688void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10689{
10690 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10691 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10692 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10693
10694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10695 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10696 if(NULL == pWdaParams)
10697 {
10698 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10699 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10700 VOS_ASSERT(0) ;
10701 return ;
10702 }
10703 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10704 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10705 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10706 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10707 {
10708 pWDA->wdaAmpSessionOn = VOS_FALSE;
10709 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10710 vos_mem_free(pWdaParams->wdaMsgParam) ;
10711 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10712 vos_mem_free(pWdaParams) ;
10713 /*
10714 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
10715 * param here
10716 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10717 return ;
10718}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10719/*
10720 * FUNCTION: WDA_BtAmpEventReqCallback
10721 * Free memory.
10722 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
10723 */
10724void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
10725{
10726 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10727 tWDA_CbContext *pWDA;
10728 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10729
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10731 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10732
10733 if(NULL == pWdaParams)
10734 {
10735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10736 "%s: pWdaParams received NULL", __func__);
10737 VOS_ASSERT(0);
10738 return;
10739 }
10740
10741 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10742 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10743
10744 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10745 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10746 {
10747 pWDA->wdaAmpSessionOn = VOS_FALSE;
10748 }
10749
10750 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10751 {
10752 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10753 vos_mem_free(pWdaParams->wdaMsgParam);
10754 vos_mem_free(pWdaParams);
10755 }
10756
10757 return;
10758}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10759/*
10760 * FUNCTION: WDA_ProcessBtAmpEventReq
10761 * Request to WDI to Update with BT AMP events.
10762 */
10763VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
10764 tSmeBtAmpEvent *pBtAmpEventParams)
10765{
10766 WDI_Status status = WDI_STATUS_SUCCESS ;
10767 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
10768 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
10769 sizeof(WDI_BtAmpEventParamsType)) ;
10770 tWDA_ReqParams *pWdaParams ;
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 == wdiBtAmpEventParam)
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10777 VOS_ASSERT(0);
10778 return VOS_STATUS_E_NOMEM;
10779 }
10780 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10781 if(NULL == pWdaParams)
10782 {
10783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10784 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10785 VOS_ASSERT(0);
10786 vos_mem_free(wdiBtAmpEventParam);
10787 return VOS_STATUS_E_NOMEM;
10788 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10789 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
10790 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10791 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
10792 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10793 /* Store BT AMP event pointer, as this will be used for response */
10794 /* store Params pass it to WDI */
10795 pWdaParams->pWdaContext = pWDA;
10796 pWdaParams->wdaMsgParam = pBtAmpEventParams;
10797 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10798 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10799 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10800 if(IS_WDI_STATUS_FAILURE(status))
10801 {
10802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10803 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
10804 vos_mem_free(pWdaParams->wdaMsgParam) ;
10805 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10806 vos_mem_free(pWdaParams) ;
10807 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10808 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10809 {
10810 pWDA->wdaAmpSessionOn = VOS_TRUE;
10811 }
10812 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10813}
10814
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10815/*
10816 * FUNCTION: WDA_FTMCommandReqCallback
10817 * Handle FTM CMD response came from HAL
10818 * Route responce to HDD FTM
10819 */
10820void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
10821 void *usrData)
10822{
10823 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10824 if((NULL == pWDA) || (NULL == ftmCmdRspData))
10825 {
10826 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]10827 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10828 return;
10829 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10830 /* Release Current FTM Command Request */
10831 vos_mem_free(pWDA->wdaFTMCmdReq);
10832 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10833 /* Post FTM Responce to HDD FTM */
10834 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10835 return;
10836}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10837/*
10838 * FUNCTION: WDA_ProcessFTMCommand
10839 * Send FTM command to WDI
10840 */
10841VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
10842 tPttMsgbuffer *pPTTFtmCmd)
10843{
10844 WDI_Status status = WDI_STATUS_SUCCESS;
10845 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10846 ftmCMDReq = (WDI_FTMCommandReqType *)
10847 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
10848 if(NULL == ftmCMDReq)
10849 {
10850 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10851 "WDA FTM Command buffer alloc fail");
10852 return VOS_STATUS_E_NOMEM;
10853 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10854 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
10855 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10856 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10857 /* Send command to WDI */
10858 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10859 return status;
10860}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10861#ifdef FEATURE_OEM_DATA_SUPPORT
10862/*
10863 * FUNCTION: WDA_StartOemDataReqCallback
10864 *
10865 */
10866void WDA_StartOemDataReqCallback(
10867 WDI_oemDataRspParamsType *wdiOemDataRspParams,
10868 void* pUserData)
10869{
10870 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10871 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10872 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10873 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10874
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10876 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10877
10878 if(NULL == pWdaParams)
10879 {
10880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10881 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10882 VOS_ASSERT(0) ;
10883 return ;
10884 }
10885 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10886
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10887 if(NULL == pWDA)
10888 {
10889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10890 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10891 VOS_ASSERT(0);
10892 return ;
10893 }
10894
10895 /*
10896 * Allocate memory for response params sent to PE
10897 */
10898 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
10899
10900 // Check if memory is allocated for OemdataMeasRsp Params.
10901 if(NULL == pOemDataRspParams)
10902 {
10903 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10904 "OEM DATA WDA callback alloc fail");
10905 VOS_ASSERT(0) ;
10906 return;
10907 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10908
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10909 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10910 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10911 vos_mem_free(pWdaParams->wdaMsgParam);
10912 vos_mem_free(pWdaParams) ;
10913
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10914 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]10915 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10916 * Also, here success always means that we have atleast one BSSID.
10917 */
10918 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
10919
10920 //enable Tx
10921 status = WDA_ResumeDataTx(pWDA);
10922 if(status != VOS_STATUS_SUCCESS)
10923 {
10924 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
10925 }
10926 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
10927 return ;
10928}
10929/*
10930 * FUNCTION: WDA_ProcessStartOemDataReq
10931 * Send Start Oem Data Req to WDI
10932 */
10933VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
10934 tStartOemDataReq *pOemDataReqParams)
10935{
10936 WDI_Status status = WDI_STATUS_SUCCESS;
10937 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10938 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10939
10940 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
10941
10942 if(NULL == wdiOemDataReqParams)
10943 {
10944 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10945 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10946 VOS_ASSERT(0);
10947 return VOS_STATUS_E_NOMEM;
10948 }
10949
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10950 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
10951 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
10952 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
10953 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10954
10955 wdiOemDataReqParams->wdiReqStatusCB = NULL;
10956
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10957 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10958 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10959 {
10960 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10961 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10962 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10963 vos_mem_free(pOemDataReqParams);
10964 VOS_ASSERT(0);
10965 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10966 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10967
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]10968 pWdaParams->pWdaContext = (void*)pWDA;
10969 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
10970 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10971
10972 status = WDI_StartOemDataReq(wdiOemDataReqParams,
10973 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10974
10975 if(IS_WDI_STATUS_FAILURE(status))
10976 {
10977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10978 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10979 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10980 vos_mem_free(pWdaParams->wdaMsgParam);
10981 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10982 }
10983 return CONVERT_WDI2VOS_STATUS(status) ;
10984}
10985#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10986/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10987 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10988 *
10989 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10990void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10991{
10992 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10994 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10995 if(NULL == pWdaParams)
10996 {
10997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10998 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10999 VOS_ASSERT(0) ;
11000 return ;
11001 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11002
11003 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11004 vos_mem_free(pWdaParams->wdaMsgParam);
11005 vos_mem_free(pWdaParams);
11006
11007 return ;
11008}
11009/*
11010 * FUNCTION: WDA_SetTxPerTrackingReqCallback
11011 * Free memory.
11012 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
11013 */
11014void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
11015{
11016 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11017
11018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11019 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11020
11021 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11022 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11024 "%s: pWdaParams received NULL", __func__);
11025 VOS_ASSERT(0);
11026 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11027 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11028
11029 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11030 {
11031 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11032 vos_mem_free(pWdaParams->wdaMsgParam);
11033 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11034 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11035
11036 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11037}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11038#ifdef WLAN_FEATURE_GTK_OFFLOAD
11039/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11040 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11041 *
11042 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11043void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11044 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11045{
11046 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11047
11048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11049 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11050 if(NULL == pWdaParams)
11051 {
11052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11053 "%s: pWdaParams received NULL", __func__);
11054 VOS_ASSERT(0);
11055 return;
11056 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11057
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11058 vos_mem_free(pWdaParams->wdaMsgParam) ;
11059 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11060 vos_mem_free(pWdaParams) ;
11061
11062 //print a msg, nothing else to do
11063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11064 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11065
11066 return ;
11067}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11068/*
11069 * FUNCTION: WDA_GTKOffloadReqCallback
11070 * Free memory.
11071 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
11072 */
11073void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
11074{
11075 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11076
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11078 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11079
11080 if(NULL == pWdaParams)
11081 {
11082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11083 "%s: pWdaParams received NULL", __func__);
11084 VOS_ASSERT(0);
11085 return;
11086 }
11087
11088 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11089 {
11090 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11091 vos_mem_free(pWdaParams->wdaMsgParam);
11092 vos_mem_free(pWdaParams);
11093 }
11094
11095 return;
11096}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11097/*
11098 * FUNCTION: WDA_ProcessGTKOffloadReq
11099 * Request to WDI to set the filter to minimize unnecessary host wakeup due
11100 * to broadcast traffic (sta mode).
11101 */
11102VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
11103 tpSirGtkOffloadParams pGtkOffloadParams)
11104{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11105 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11106 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
11107 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
11108 sizeof(WDI_GtkOffloadReqMsg)) ;
11109 tWDA_ReqParams *pWdaParams ;
11110
11111 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11112 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11113
11114 if(NULL == wdiGtkOffloadReqMsg)
11115 {
11116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11117 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11118 VOS_ASSERT(0);
11119 return VOS_STATUS_E_NOMEM;
11120 }
11121
11122 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11123 if(NULL == pWdaParams)
11124 {
11125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11126 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11127 VOS_ASSERT(0);
11128 vos_mem_free(wdiGtkOffloadReqMsg);
11129 return VOS_STATUS_E_NOMEM;
11130 }
11131
11132 //
11133 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
11134 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11135
11136 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11137 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11138
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11139 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
11140 // Copy KCK
11141 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
11142 // Copy KEK
11143 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
11144 // Copy KeyReplayCounter
11145 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
11146 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
11147
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11148 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
11149 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11150
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11151
11152 /* Store Params pass it to WDI */
11153 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
11154 pWdaParams->pWdaContext = pWDA;
11155 /* Store param pointer as passed in by caller */
11156 pWdaParams->wdaMsgParam = pGtkOffloadParams;
11157
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11158 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11159
11160 if(IS_WDI_STATUS_FAILURE(status))
11161 {
11162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11163 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
11164 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11165 vos_mem_free(pWdaParams->wdaMsgParam);
11166 vos_mem_free(pWdaParams);
11167 }
11168
11169 return CONVERT_WDI2VOS_STATUS(status) ;
11170}
11171
11172/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11173 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11174 *
11175 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11176void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11177 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11178{
11179 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11180 tWDA_CbContext *pWDA;
11181 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11182 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11183 vos_msg_t vosMsg;
11184
11185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11186 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11187
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11188 if(NULL == pWdaParams)
11189 {
11190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11191 "%s: pWdaParams received NULL", __func__);
11192 VOS_ASSERT(0);
11193 return;
11194 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11195
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11196 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
11197 if(NULL == pGtkOffloadGetInfoRsp)
11198 {
11199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11200 "%s: vos_mem_malloc failed ", __func__);
11201 VOS_ASSERT(0);
11202 return;
11203 }
11204
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11205 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
11206 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
11207
11208 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
11209 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
11210
11211 /* Message Header */
11212 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]11213 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11214
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11215 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
11216 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
11217 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
11218 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
11219 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11220
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11221 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
11222 pwdiGtkOffloadGetInfoRsparams->bssId,
11223 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11224 /* VOS message wrapper */
11225 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11226 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
11227 vosMsg.bodyval = 0;
11228
11229 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
11230 {
11231 /* free the mem and return */
11232 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
11233 }
11234
11235 vos_mem_free(pWdaParams->wdaMsgParam) ;
11236 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11237 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11238
11239 return;
11240}
11241/*
11242 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
11243 * Free memory and send RSP back to SME.
11244 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
11245 */
11246void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
11247{
11248 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11249 vos_msg_t vosMsg;
11250
11251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11252 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11253
11254 if(NULL == pWdaParams)
11255 {
11256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11257 "%s: pWdaParams received NULL", __func__);
11258 VOS_ASSERT(0);
11259 return;
11260 }
11261
11262 /* VOS message wrapper */
11263 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11264 vosMsg.bodyptr = NULL;
11265 vosMsg.bodyval = 0;
11266
11267 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11268 {
11269 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11270 vos_mem_free(pWdaParams->wdaMsgParam);
11271 vos_mem_free(pWdaParams);
11272 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
11273 }
11274
11275 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11276}
11277#endif
11278
11279/*
11280 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
11281 * Request to WDI to set Tx Per Tracking configurations
11282 */
11283VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
11284{
11285 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11286 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11287 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
11288 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
11289 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
11290 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11292 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11293 if(NULL == pwdiSetTxPerTrackingReqParams)
11294 {
11295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11296 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11297 vos_mem_free(pTxPerTrackingParams);
11298 VOS_ASSERT(0);
11299 return VOS_STATUS_E_NOMEM;
11300 }
11301 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11302 if(NULL == pWdaParams)
11303 {
11304 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11305 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11306 vos_mem_free(pwdiSetTxPerTrackingReqParams);
11307 vos_mem_free(pTxPerTrackingParams);
11308 VOS_ASSERT(0);
11309 return VOS_STATUS_E_NOMEM;
11310 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11311 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
11312 pTxPerTrackingParams->ucTxPerTrackingEnable;
11313 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
11314 pTxPerTrackingParams->ucTxPerTrackingPeriod;
11315 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
11316 pTxPerTrackingParams->ucTxPerTrackingRatio;
11317 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
11318 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11319 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
11320 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11321 /* Store param pointer as passed in by caller */
11322 /* store Params pass it to WDI
11323 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
11324 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
11325 pWdaParams->pWdaContext = pWDA;
11326 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11327 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11328 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11329 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11330 {
11331 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11332 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11333 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11334 vos_mem_free(pWdaParams->wdaMsgParam) ;
11335 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11336 vos_mem_free(pWdaParams) ;
11337 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11338 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11339
11340}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11341/*
11342 * FUNCTION: WDA_HALDumpCmdCallback
11343 * Send the VOS complete .
11344 */
11345void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
11346 void* pUserData)
11347{
11348 tANI_U8 *buffer = NULL;
11349 tWDA_CbContext *pWDA = NULL;
11350 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11351 if(NULL == pWdaParams)
11352 {
11353 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11354 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11355 VOS_ASSERT(0) ;
11356 return ;
11357 }
11358
11359 pWDA = pWdaParams->pWdaContext;
11360 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11361 if(wdiRspParams->usBufferLen > 0)
11362 {
11363 /*Copy the Resp data to UMAC supplied buffer*/
11364 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
11365 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11366 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11367 vos_mem_free(pWdaParams);
11368
11369 /* Indicate VOSS about the start complete */
11370 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11371 return ;
11372}
11373
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11374/*
11375 * FUNCTION: WDA_ProcessHALDumpCmdReq
11376 * Send Dump command to WDI
11377 */
11378VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
11379 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
11380 tANI_U32 arg4, tANI_U8 *pBuffer)
11381{
11382 WDI_Status status = WDI_STATUS_SUCCESS;
11383 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
11384 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
11385 tWDA_ReqParams *pWdaParams ;
11386 pVosContextType pVosContext = NULL;
11387 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11388 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
11389 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]11390 if(pVosContext)
11391 {
11392 if (pVosContext->isLogpInProgress)
11393 {
11394 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
11395 "%s:LOGP in Progress. Ignore!!!", __func__);
11396 return VOS_STATUS_E_BUSY;
11397 }
11398 }
11399 else
11400 {
11401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11402 "%s: VOS Context Null", __func__);
11403 return VOS_STATUS_E_RESOURCES;
11404 }
11405
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11406 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11407 if(NULL == pWdaParams)
11408 {
11409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11410 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11411 return VOS_STATUS_E_NOMEM;
11412 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11413 /* Allocate memory WDI request structure*/
11414 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
11415 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
11416 if(NULL == wdiHALDumpCmdReqParam)
11417 {
11418 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11419 "WDA HAL DUMP Command buffer alloc fail");
11420 vos_mem_free(pWdaParams);
11421 return WDI_STATUS_E_FAILURE;
11422 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11423 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11424 /* Extract the arguments */
11425 wdiHalDumpCmdInfo->command = cmd;
11426 wdiHalDumpCmdInfo->argument1 = arg1;
11427 wdiHalDumpCmdInfo->argument2 = arg2;
11428 wdiHalDumpCmdInfo->argument3 = arg3;
11429 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11430 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11431 pWdaParams->pWdaContext = pVosContext->pWDAContext;
11432
11433 /* Response message will be passed through the buffer */
11434 pWdaParams->wdaMsgParam = (void *)pBuffer;
11435
11436 /* store Params pass it to WDI */
11437 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11438 /* Send command to WDI */
11439 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback, pWdaParams);
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]11440 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent), WDA_DUMPCMD_WAIT_TIMEOUT );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11441 if ( vStatus != VOS_STATUS_SUCCESS )
11442 {
11443 if ( vStatus == VOS_STATUS_E_TIMEOUT )
11444 {
11445 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11446 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11447 }
11448 else
11449 {
11450 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11451 "%s: WDA_HALDUMP reporting other error",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11452 }
11453 VOS_ASSERT(0);
11454 }
11455 return status;
11456}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11457#ifdef WLAN_FEATURE_GTK_OFFLOAD
11458/*
11459 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
11460 * Request to WDI to get GTK Offload Information
11461 */
11462VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
11463 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
11464{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11465 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11466 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
11467 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
11468 tWDA_ReqParams *pWdaParams ;
11469
11470 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
11471 {
11472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11473 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11474 VOS_ASSERT(0);
11475 return VOS_STATUS_E_NOMEM;
11476 }
11477
11478 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11479 if(NULL == pWdaParams)
11480 {
11481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11482 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11483 VOS_ASSERT(0);
11484 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
11485 return VOS_STATUS_E_NOMEM;
11486 }
11487
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11488 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
11489 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11490
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11491 /* Store Params pass it to WDI */
11492 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
11493 pWdaParams->pWdaContext = pWDA;
11494 /* Store param pointer as passed in by caller */
11495 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
11496
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11497 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11498 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11499
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11500 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11501
11502 if(IS_WDI_STATUS_FAILURE(status))
11503 {
11504 /* failure returned by WDI API */
11505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11506 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
11507 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11508 vos_mem_free(pWdaParams) ;
11509 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
11510 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
11511 }
11512
11513 return CONVERT_WDI2VOS_STATUS(status) ;
11514}
11515#endif // WLAN_FEATURE_GTK_OFFLOAD
11516
11517/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11518 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
11519 *
11520 */
11521VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11522 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
11523{
11524 WDI_Status wdiStatus;
11525 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
11526
11527 addPeriodicTxPtrnParams =
11528 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
11529
11530 if (NULL == addPeriodicTxPtrnParams)
11531 {
11532 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11533 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
11534 __func__);
11535
11536 return VOS_STATUS_E_NOMEM;
11537 }
11538
11539 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
11540 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
11541
11542 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11543 addPeriodicTxPtrnParams->pUserData = pWDA;
11544
11545 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
11546
11547 if (WDI_STATUS_PENDING == wdiStatus)
11548 {
11549 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11550 "Pending received for %s:%d", __func__, __LINE__ );
11551 }
11552 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11553 {
11554 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11555 "Failure in %s:%d", __func__, __LINE__ );
11556 }
11557
11558 vos_mem_free(addPeriodicTxPtrnParams);
11559
11560 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11561}
11562
11563/*
11564 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
11565 *
11566 */
11567VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11568 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
11569{
11570 WDI_Status wdiStatus;
11571 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
11572
11573 delPeriodicTxPtrnParams =
11574 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
11575
11576 if (NULL == delPeriodicTxPtrnParams)
11577 {
11578 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11579 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
11580 __func__);
11581
11582 return VOS_STATUS_E_NOMEM;
11583 }
11584
11585 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
11586 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
11587
11588 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11589 delPeriodicTxPtrnParams->pUserData = pWDA;
11590
11591 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
11592
11593 if (WDI_STATUS_PENDING == wdiStatus)
11594 {
11595 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11596 "Pending received for %s:%d", __func__, __LINE__ );
11597 }
11598 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11599 {
11600 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11601 "Failure in %s:%d", __func__, __LINE__ );
11602 }
11603
11604 vos_mem_free(delPeriodicTxPtrnParams);
11605
11606 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11607}
11608
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11609#ifdef FEATURE_WLAN_BATCH_SCAN
11610/*
11611 * FUNCTION: WDA_ProcessStopBatchScanInd
11612 *
11613 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
11614 *
11615 * PARAM:
11616 * pWDA: pointer to WDA context
11617 * pReq: pointer to stop batch scan request
11618 */
11619VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
11620 tSirStopBatchScanInd *pReq)
11621{
11622 WDI_Status wdiStatus;
11623 WDI_StopBatchScanIndType wdiReq;
11624
11625 wdiReq.param = pReq->param;
11626
11627 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
11628
11629 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11630 {
11631 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11632 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
11633 }
11634
11635 vos_mem_free(pReq);
11636
11637 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11638}
11639/*==========================================================================
11640 FUNCTION WDA_ProcessTriggerBatchScanResultInd
11641
11642 DESCRIPTION
11643 API to pull batch scan result from FW
11644
11645 PARAMETERS
11646 pWDA: Pointer to WDA context
11647 pGetBatchScanReq: Pointer to get batch scan result indication
11648
11649 RETURN VALUE
11650 NONE
11651
11652===========================================================================*/
11653VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
11654 tSirTriggerBatchScanResultInd *pReq)
11655{
11656 WDI_Status wdiStatus;
11657 WDI_TriggerBatchScanResultIndType wdiReq;
11658
11659 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11660 "------> %s " ,__func__);
11661
11662 wdiReq.param = pReq->param;
11663
11664 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
11665
11666 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11667 {
11668 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11669 "Trigger batch scan result ind failed %s:%d",
11670 __func__, wdiStatus);
11671 }
11672
11673 vos_mem_free(pReq);
11674
11675 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11676}
11677
11678/*==========================================================================
11679 FUNCTION WDA_SetBatchScanRespCallback
11680
11681 DESCRIPTION
11682 API to process set batch scan response from FW
11683
11684 PARAMETERS
11685 pRsp: Pointer to set batch scan response
11686 pUserData: Pointer to user data
11687
11688 RETURN VALUE
11689 NONE
11690
11691===========================================================================*/
11692void WDA_SetBatchScanRespCallback
11693(
11694 WDI_SetBatchScanRspType *pRsp,
11695 void* pUserData
11696)
11697{
11698 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
11699 tpAniSirGlobal pMac;
11700 void *pCallbackContext;
11701 tWDA_CbContext *pWDA = NULL ;
11702 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11703
11704
11705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11706 "<------ %s " ,__func__);
11707 if (NULL == pWdaParams)
11708 {
11709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11710 "%s: pWdaParams received NULL", __func__);
11711 VOS_ASSERT(0) ;
11712 return ;
11713 }
11714
11715 /*extract WDA context*/
11716 pWDA = pWdaParams->pWdaContext;
11717 if (NULL == pWDA)
11718 {
11719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11720 "%s:pWDA is NULL can't invole HDD callback",
11721 __func__);
11722 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11723 vos_mem_free(pWdaParams->wdaMsgParam);
11724 vos_mem_free(pWdaParams);
11725 VOS_ASSERT(0);
11726 return;
11727 }
11728
11729 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11730 vos_mem_free(pWdaParams->wdaMsgParam);
11731 vos_mem_free(pWdaParams);
11732
11733 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11734 if (NULL == pMac)
11735 {
11736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11737 "%s:pMac is NULL", __func__);
11738 VOS_ASSERT(0);
11739 return;
11740 }
11741
11742 pHddSetBatchScanRsp =
11743 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
11744 if (NULL == pHddSetBatchScanRsp)
11745 {
11746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11747 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
11748 VOS_ASSERT(0);
11749 return;
11750 }
11751
11752 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
11753
11754 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
11755 /*call hdd callback with set batch scan response data*/
11756 if(pMac->pmc.setBatchScanReqCallback)
11757 {
11758 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
11759 }
11760 else
11761 {
11762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11763 "%s:HDD callback is null", __func__);
11764 VOS_ASSERT(0);
11765 }
11766
11767 vos_mem_free(pHddSetBatchScanRsp);
11768 return ;
11769}
11770
11771/*==========================================================================
11772 FUNCTION WDA_ProcessSetBatchScanReq
11773
11774 DESCRIPTION
11775 API to send set batch scan request to WDI
11776
11777 PARAMETERS
11778 pWDA: Pointer to WDA context
11779 pSetBatchScanReq: Pointer to set batch scan req
11780
11781 RETURN VALUE
11782 NONE
11783
11784===========================================================================*/
11785VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
11786 tSirSetBatchScanReq *pSetBatchScanReq)
11787{
11788 WDI_Status status;
11789 tWDA_ReqParams *pWdaParams ;
11790 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
11791
11792 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11793 "------> %s " ,__func__);
11794
11795 pWdiSetBatchScanReq =
11796 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
11797 if (NULL == pWdiSetBatchScanReq)
11798 {
11799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11800 "%s: VOS MEM Alloc Failure", __func__);
11801 vos_mem_free(pSetBatchScanReq);
11802 VOS_ASSERT(0);
11803 return VOS_STATUS_E_NOMEM;
11804 }
11805
11806 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
11807 if (NULL == pWdaParams)
11808 {
11809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11810 "%s: VOS MEM Alloc Failure", __func__);
11811 VOS_ASSERT(0);
11812 vos_mem_free(pSetBatchScanReq);
11813 vos_mem_free(pWdiSetBatchScanReq);
11814 return VOS_STATUS_E_NOMEM;
11815 }
11816
11817 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
11818 pWdiSetBatchScanReq->numberOfScansToBatch =
11819 pSetBatchScanReq->numberOfScansToBatch;
11820 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
11821 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
11822 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
11823
11824 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
11825 pWdaParams->pWdaContext = pWDA;
11826 pWdaParams->wdaMsgParam = pSetBatchScanReq;
11827
11828 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
11829 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
11830 if (IS_WDI_STATUS_FAILURE(status))
11831 {
11832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11833 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
11834 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11835 vos_mem_free(pWdaParams->wdaMsgParam);
11836 vos_mem_free(pWdaParams);
11837 }
11838 return CONVERT_WDI2VOS_STATUS(status);
11839}
11840
11841#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11842/*
11843 * FUNCTION: WDA_ProcessHT40OBSSScanInd
11844 *
11845 * DESCRIPTION: This function sends start/update OBSS scan
11846 * inidcation message to WDI
11847 *
11848 * PARAM:
11849 * pWDA: pointer to WDA context
11850 * pReq: pointer to start OBSS scan request
11851 */
11852VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
11853 tSirHT40OBSSScanInd *pReq)
11854{
11855 WDI_Status status;
11856 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
11857 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11858
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11860 "------> %s " ,__func__);
11861 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11862 wdiOBSSScanParams.pUserData = pWDA;
11863
11864 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
11865 pWdiOBSSScanInd->cmdType = pReq->cmdType;
11866 pWdiOBSSScanInd->scanType = pReq->scanType;
11867 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
11868 pReq->OBSSScanActiveDwellTime;
11869 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
11870 pReq->OBSSScanPassiveDwellTime;
11871 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
11872 pReq->BSSChannelWidthTriggerScanInterval;
11873 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
11874 pReq->BSSWidthChannelTransitionDelayFactor;
11875 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
11876 pReq->OBSSScanActiveTotalPerChannel;
11877 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
11878 pReq->OBSSScanPassiveTotalPerChannel;
11879 pWdiOBSSScanInd->OBSSScanActivityThreshold =
11880 pReq->OBSSScanActivityThreshold;
11881 pWdiOBSSScanInd->channelCount = pReq->channelCount;
11882 vos_mem_copy(pWdiOBSSScanInd->channels,
11883 pReq->channels,
11884 pReq->channelCount);
11885 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
11886 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
11887 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
11888 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
11889 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
11890
11891 vos_mem_copy(pWdiOBSSScanInd->ieField,
11892 pReq->ieField,
11893 pReq->ieFieldLen);
11894
11895 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
11896 if (WDI_STATUS_PENDING == status)
11897 {
11898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11899 "Pending received for %s:%d ",__func__,__LINE__ );
11900 }
11901 else if (WDI_STATUS_SUCCESS_SYNC != status)
11902 {
11903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11904 "Failure in %s:%d ",__func__,__LINE__ );
11905 }
11906 return CONVERT_WDI2VOS_STATUS(status) ;
11907}
11908/*
11909 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
11910 *
11911 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
11912 *
11913 * PARAM:
11914 * pWDA: pointer to WDA context
11915 * pReq: pointer to stop batch scan request
11916 */
11917VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
11918 tANI_U8 *bssIdx)
11919{
11920 WDI_Status status;
11921
11922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11923 "------> %s " ,__func__);
11924
11925 status = WDI_HT40OBSSStopScanInd(*bssIdx);
11926 if (WDI_STATUS_PENDING == status)
11927 {
11928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11929 "Pending received for %s:%d ",__func__,__LINE__ );
11930 }
11931 else if (WDI_STATUS_SUCCESS_SYNC != status)
11932 {
11933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11934 "Failure in %s:%d ",__func__,__LINE__ );
11935 }
11936 return CONVERT_WDI2VOS_STATUS(status) ;
11937}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11938/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]11939 * FUNCTION: WDA_ProcessRateUpdateInd
11940 *
11941 */
11942VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
11943 tSirRateUpdateInd *pRateUpdateParams)
11944{
11945 WDI_Status wdiStatus;
11946 WDI_RateUpdateIndParams rateUpdateParams;
11947
11948 vos_mem_copy(rateUpdateParams.bssid,
11949 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
11950
11951 rateUpdateParams.ucastDataRateTxFlag =
11952 pRateUpdateParams->ucastDataRateTxFlag;
11953 rateUpdateParams.reliableMcastDataRateTxFlag =
11954 pRateUpdateParams->reliableMcastDataRateTxFlag;
11955 rateUpdateParams.mcastDataRate24GHzTxFlag =
11956 pRateUpdateParams->mcastDataRate24GHzTxFlag;
11957 rateUpdateParams.mcastDataRate5GHzTxFlag =
11958 pRateUpdateParams->mcastDataRate5GHzTxFlag;
11959
11960 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
11961 rateUpdateParams.reliableMcastDataRate =
11962 pRateUpdateParams->reliableMcastDataRate;
11963 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
11964 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
11965
11966 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11967 rateUpdateParams.pUserData = pWDA;
11968
11969 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
11970
11971 if (WDI_STATUS_PENDING == wdiStatus)
11972 {
11973 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11974 "Pending received for %s:%d", __func__, __LINE__ );
11975 }
11976 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11977 {
11978 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11979 "Failure in %s:%d", __func__, __LINE__ );
11980 }
11981
11982 vos_mem_free(pRateUpdateParams);
11983
11984 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11985}
11986
11987/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11988 * -------------------------------------------------------------------------
11989 * DATA interface with WDI for Mgmt Frames
11990 * -------------------------------------------------------------------------
11991 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11992/*
11993 * FUNCTION: WDA_TxComplete
11994 * Callback function for the WDA_TxPacket
11995 */
11996VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
11997 VOS_STATUS status )
11998{
11999
12000 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
12001 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12002 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12003
12004 if(NULL == wdaContext)
12005 {
12006 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12007 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12008 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12009 VOS_ASSERT(0);
12010 return VOS_STATUS_E_FAILURE;
12011 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12012
12013 /*Check if frame was timed out or not*/
12014 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
12015 (v_PVOID_t)&uUserData);
12016
12017 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
12018 {
12019 /*Discard frame - no further processing is needed*/
12020 vos_pkt_return_packet(pData);
12021 return VOS_STATUS_SUCCESS;
12022 }
12023
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12024 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
12025 if( NULL!=wdaContext->pTxCbFunc)
12026 {
12027 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12028 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]12029 {
12030 wdaContext->pTxCbFunc(pMac, pData);
12031 }
12032 else
12033 {
12034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12035 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12036 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12037 //Return from here since we reaching here because the packet already timeout
12038 return status;
12039 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12040 }
12041
12042 /*
12043 * Trigger the event to bring the HAL TL Tx complete function to come
12044 * out of wait
12045 * Let the coe above to complete the packet first. When this event is set,
12046 * the thread waiting for the event may run and set Vospacket_freed causing the original
12047 * packet not being freed.
12048 */
12049 status = vos_event_set(&wdaContext->txFrameEvent);
12050 if(!VOS_IS_STATUS_SUCCESS(status))
12051 {
12052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12053 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12054 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12055 return status;
12056}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12057/*
12058 * FUNCTION: WDA_TxPacket
12059 * Forward TX management frame to WDI
12060 */
12061VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
12062 void *pFrmBuf,
12063 tANI_U16 frmLen,
12064 eFrameType frmType,
12065 eFrameTxDir txDir,
12066 tANI_U8 tid,
12067 pWDATxRxCompFunc pCompFunc,
12068 void *pData,
12069 pWDAAckFnTxComp pAckTxComp,
Kanchanapally, Vidyullathaf9426e52013-12-24 17:28:54 +0530[diff] [blame]12070 tANI_U32 txFlag)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12071{
12072 VOS_STATUS status = VOS_STATUS_SUCCESS ;
12073 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
12074 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
12075 tANI_U8 eventIdx = 0;
12076 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
12077 tpAniSirGlobal pMac;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12078 if((NULL == pWDA)||(NULL == pFrmBuf))
12079 {
12080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12081 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12082 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12083 VOS_ASSERT(0);
12084 return VOS_STATUS_E_FAILURE;
12085 }
12086
12087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12088 "Tx Mgmt Frame Subtype: %d alloc(%p)", pFc->subType, pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12089 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
12090 if(NULL == pMac)
12091 {
12092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12093 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12094 VOS_ASSERT(0);
12095 return VOS_STATUS_E_FAILURE;
12096 }
12097
12098
12099
12100 /* store the call back function in WDA context */
12101 pWDA->pTxCbFunc = pCompFunc;
12102 /* store the call back for the function of ackTxComplete */
12103 if( pAckTxComp )
12104 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12105 if( NULL != pWDA->pAckTxCbFunc )
12106 {
12107 /* Already TxComp is active no need to active again */
12108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12109 "There is already one request pending for tx complete");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12110 pWDA->pAckTxCbFunc( pMac, 0);
12111 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12112
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12113 if( VOS_STATUS_SUCCESS !=
12114 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12115 {
12116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12117 "Tx Complete timeout Timer Stop Failed ");
12118 }
12119 else
12120 {
12121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]12122 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12123 }
12124 }
12125
12126 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
12127 pWDA->pAckTxCbFunc = pAckTxComp;
12128 if( VOS_STATUS_SUCCESS !=
12129 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
12130 {
12131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12132 "Tx Complete Timer Start Failed ");
12133 pWDA->pAckTxCbFunc = NULL;
12134 return eHAL_STATUS_FAILURE;
12135 }
12136 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12137 /* Reset the event to be not signalled */
12138 status = vos_event_reset(&pWDA->txFrameEvent);
12139 if(!VOS_IS_STATUS_SUCCESS(status))
12140 {
12141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12142 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12143 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
12144 if( pAckTxComp )
12145 {
12146 pWDA->pAckTxCbFunc = NULL;
12147 if( VOS_STATUS_SUCCESS !=
12148 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12149 {
12150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12151 "Tx Complete timeout Timer Stop Failed ");
12152 }
12153 }
12154 return VOS_STATUS_E_FAILURE;
12155 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12156
12157 /* If Peer Sta mask is set don't overwrite to self sta */
12158 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12159 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12160 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12161 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12162 else
12163 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12164 /* Get system role, use the self station if in unknown role or STA role */
12165 systemRole = wdaGetGlobalSystemRole(pMac);
12166 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
12167 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12168#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12169 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12170#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12171 ))
12172 {
12173 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
12174 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]12175 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12176
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12177 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
12178 disassoc frame reaches the HW, HAL has already deleted the peer station */
12179 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12180 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]12181 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12182 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12183 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12184 /*Send Probe request frames on self sta idx*/
12185 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12186 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12187 /* Since we donot want probe responses to be retried, send probe responses
12188 through the NO_ACK queues */
12189 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
12190 {
12191 //probe response is sent out using self station and no retries options.
12192 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
12193 }
12194 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
12195 {
12196 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
12197 }
12198 }
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12199 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]12200
12201 /*Set frame tag to 0
12202 We will use the WDA user data in order to tag a frame as expired*/
12203 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12204 (v_PVOID_t)0);
12205
12206
12207 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
12208 frmLen, ucTypeSubType, tid,
12209 WDA_TxComplete, NULL, txFlag)) != VOS_STATUS_SUCCESS)
12210 {
12211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12212 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12213 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12214 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]12215 if( pAckTxComp )
12216 {
12217 pWDA->pAckTxCbFunc = NULL;
12218 if( VOS_STATUS_SUCCESS !=
12219 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12220 {
12221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12222 "Tx Complete timeout Timer Stop Failed ");
12223 }
12224 }
12225 return VOS_STATUS_E_FAILURE;
12226 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12227 /*
12228 * Wait for the event to be set by the TL, to get the response of TX
12229 * complete, this event should be set by the Callback function called by TL
12230 */
12231 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
12232 &eventIdx);
12233 if(!VOS_IS_STATUS_SUCCESS(status))
12234 {
12235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12236 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12237 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12238 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
12239 after the packet gets completed(packet freed once)*/
12240
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12241 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]12242 WDA_TransportChannelDebug(pMac, 1, WPAL_DEBUG_TX_DESC_RESYNC);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12243
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12244 /*Tag Frame as timed out for later deletion*/
12245 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12246 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
12247
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12248 /* check whether the packet was freed already,so need not free again when
12249 * TL calls the WDA_Txcomplete routine
12250 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12251 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
12252 /*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]12253 {
12254 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12255 } */
12256
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12257 if( pAckTxComp )
12258 {
12259 pWDA->pAckTxCbFunc = NULL;
12260 if( VOS_STATUS_SUCCESS !=
12261 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12262 {
12263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12264 "Tx Complete timeout Timer Stop Failed ");
12265 }
12266 }
12267 status = VOS_STATUS_E_FAILURE;
12268 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]12269#ifdef WLAN_DUMP_MGMTFRAMES
12270 if (VOS_IS_STATUS_SUCCESS(status))
12271 {
12272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12273 "%s() TX packet : SubType %d", __func__,pFc->subType);
12274 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12275 pData, frmLen);
12276 }
12277#endif
12278
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]12279 if (VOS_IS_STATUS_SUCCESS(status))
12280 {
12281 if (pMac->fEnableDebugLog & 0x1)
12282 {
12283 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
12284 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
12285 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
12286 {
12287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
12288 pFc->type, pFc->subType);
12289 }
12290 }
12291 }
12292
12293
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12294 return status;
12295}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12296/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12297 * FUNCTION: WDA_ProcessDHCPStartInd
12298 * Forward DHCP Start to WDI
12299 */
12300static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
12301 tAniDHCPInd *dhcpStartInd)
12302{
12303 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12304 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12305
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12306 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
12307 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12308 sizeof(tSirMacAddr));
12309
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12310 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12311
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12312 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12313 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12315 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12316 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12317 else if (WDI_STATUS_SUCCESS_SYNC != status)
12318 {
12319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12320 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
12321 }
12322
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12323 vos_mem_free(dhcpStartInd);
12324 return CONVERT_WDI2VOS_STATUS(status) ;
12325}
12326
12327 /*
12328 * FUNCTION: WDA_ProcessDHCPStopInd
12329 * Forward DHCP Stop to WDI
12330 */
12331 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
12332 tAniDHCPInd *dhcpStopInd)
12333 {
12334 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12335 WDI_DHCPInd wdiDHCPInd;
12336
12337 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
12338 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
12339
12340 status = WDI_dhcpStopInd(&wdiDHCPInd);
12341
12342 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12343 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12345 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12346 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12347 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12348 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12350 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12351 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12352
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12353 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12354
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12355 return CONVERT_WDI2VOS_STATUS(status) ;
12356 }
12357
12358/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12359 * FUNCTION: WDA_McProcessMsg
12360 * Trigger DAL-AL to start CFG download
12361 */
12362VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
12363{
12364 VOS_STATUS status = VOS_STATUS_SUCCESS;
12365 tWDA_CbContext *pWDA = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12366 if(NULL == pMsg)
12367 {
12368 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12369 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12370 VOS_ASSERT(0);
12371 return VOS_STATUS_E_FAILURE;
12372 }
12373
12374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12375 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12376
12377 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
12378 if(NULL == pWDA )
12379 {
12380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12381 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12382 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12383 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12384 return VOS_STATUS_E_FAILURE;
12385 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12386 /* Process all the WDA messages.. */
12387 switch( pMsg->type )
12388 {
12389 case WNI_CFG_DNLD_REQ:
12390 {
12391 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12392 /* call WDA complete event if config download success */
12393 if( VOS_IS_STATUS_SUCCESS(status) )
12394 {
12395 vos_WDAComplete_cback(pVosContext);
12396 }
12397 else
12398 {
12399 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12400 "WDA Config Download failure" );
12401 }
12402 break ;
12403 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12404 /*
12405 * Init SCAN request from PE, convert it into DAL format
12406 * and send it to DAL
12407 */
12408 case WDA_INIT_SCAN_REQ:
12409 {
12410 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
12411 break ;
12412 }
12413 /* start SCAN request from PE */
12414 case WDA_START_SCAN_REQ:
12415 {
12416 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
12417 break ;
12418 }
12419 /* end SCAN request from PE */
12420 case WDA_END_SCAN_REQ:
12421 {
12422 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
12423 break ;
12424 }
12425 /* end SCAN request from PE */
12426 case WDA_FINISH_SCAN_REQ:
12427 {
12428 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
12429 break ;
12430 }
12431 /* join request from PE */
12432 case WDA_CHNL_SWITCH_REQ:
12433 {
12434 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
12435 {
12436 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
12437 }
12438 else
12439 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]12440 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
12441 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
12442 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
12443 {
12444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12445 "call ProcessChannelSwitchReq_V1" );
12446 WDA_ProcessChannelSwitchReq_V1(pWDA,
12447 (tSwitchChannelParams*)pMsg->bodyptr) ;
12448 }
12449 else
12450 {
12451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12452 "call ProcessChannelSwitchReq" );
12453 WDA_ProcessChannelSwitchReq(pWDA,
12454 (tSwitchChannelParams*)pMsg->bodyptr) ;
12455 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12456 }
12457 break ;
12458 }
12459 /* ADD BSS request from PE */
12460 case WDA_ADD_BSS_REQ:
12461 {
12462 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
12463 break ;
12464 }
12465 case WDA_ADD_STA_REQ:
12466 {
12467 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
12468 break ;
12469 }
12470 case WDA_DELETE_BSS_REQ:
12471 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12472 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
12473 break ;
12474 }
12475 case WDA_DELETE_STA_REQ:
12476 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12477 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
12478 break ;
12479 }
12480 case WDA_CONFIG_PARAM_UPDATE_REQ:
12481 {
12482 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
12483 break ;
12484 }
12485 case WDA_SET_BSSKEY_REQ:
12486 {
12487 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
12488 break ;
12489 }
12490 case WDA_SET_STAKEY_REQ:
12491 {
12492 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12493 break ;
12494 }
12495 case WDA_SET_STA_BCASTKEY_REQ:
12496 {
12497 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12498 break ;
12499 }
12500 case WDA_REMOVE_BSSKEY_REQ:
12501 {
12502 WDA_ProcessRemoveBssKeyReq(pWDA,
12503 (tRemoveBssKeyParams *)pMsg->bodyptr);
12504 break ;
12505 }
12506 case WDA_REMOVE_STAKEY_REQ:
12507 {
12508 WDA_ProcessRemoveStaKeyReq(pWDA,
12509 (tRemoveStaKeyParams *)pMsg->bodyptr);
12510 break ;
12511 }
12512 case WDA_REMOVE_STA_BCASTKEY_REQ:
12513 {
12514 /* TODO: currently UMAC is not sending this request, Add the code for
12515 handling this request when UMAC supports */
12516 break;
12517 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12518#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12519 case WDA_TSM_STATS_REQ:
12520 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]12521 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12522 break;
12523 }
12524#endif
12525 case WDA_UPDATE_EDCA_PROFILE_IND:
12526 {
12527 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
12528 break;
12529 }
12530 case WDA_ADD_TS_REQ:
12531 {
12532 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
12533 break;
12534 }
12535 case WDA_DEL_TS_REQ:
12536 {
12537 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
12538 break;
12539 }
12540 case WDA_ADDBA_REQ:
12541 {
12542 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
12543 break;
12544 }
12545 case WDA_DELBA_IND:
12546 {
12547 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
12548 break;
12549 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]12550 case WDA_UPDATE_CHAN_LIST_REQ:
12551 {
12552 WDA_ProcessUpdateChannelList(pWDA,
12553 (tSirUpdateChanList *)pMsg->bodyptr);
12554 break;
12555 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12556 case WDA_SET_LINK_STATE:
12557 {
12558 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
12559 break;
12560 }
12561 case WDA_GET_STATISTICS_REQ:
12562 {
12563 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
12564 break;
12565 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12566#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]12567 case WDA_GET_ROAM_RSSI_REQ:
12568 {
12569 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
12570 break;
12571 }
12572#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12573 case WDA_PWR_SAVE_CFG:
12574 {
12575 if(pWDA->wdaState == WDA_READY_STATE)
12576 {
12577 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
12578 }
12579 else
12580 {
12581 if(NULL != pMsg->bodyptr)
12582 {
12583 vos_mem_free(pMsg->bodyptr);
12584 }
12585 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12586 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
12587 }
12588 break;
12589 }
12590 case WDA_ENTER_IMPS_REQ:
12591 {
12592 if(pWDA->wdaState == WDA_READY_STATE)
12593 {
12594 WDA_ProcessEnterImpsReq(pWDA);
12595 }
12596 else
12597 {
12598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12599 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12600 }
12601 break;
12602 }
12603 case WDA_EXIT_IMPS_REQ:
12604 {
12605 if(pWDA->wdaState == WDA_READY_STATE)
12606 {
12607 WDA_ProcessExitImpsReq(pWDA);
12608 }
12609 else
12610 {
12611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12612 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12613 }
12614 break;
12615 }
12616 case WDA_ENTER_BMPS_REQ:
12617 {
12618 if(pWDA->wdaState == WDA_READY_STATE)
12619 {
12620 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
12621 }
12622 else
12623 {
12624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12625 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12626 }
12627 break;
12628 }
12629 case WDA_EXIT_BMPS_REQ:
12630 {
12631 if(pWDA->wdaState == WDA_READY_STATE)
12632 {
12633 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
12634 }
12635 else
12636 {
12637 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12638 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12639 }
12640 break;
12641 }
12642 case WDA_ENTER_UAPSD_REQ:
12643 {
12644 if(pWDA->wdaState == WDA_READY_STATE)
12645 {
12646 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
12647 }
12648 else
12649 {
12650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12651 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12652 }
12653 break;
12654 }
12655 case WDA_EXIT_UAPSD_REQ:
12656 {
12657 if(pWDA->wdaState == WDA_READY_STATE)
12658 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12659 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12660 }
12661 else
12662 {
12663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12664 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12665 }
12666 break;
12667 }
12668 case WDA_UPDATE_UAPSD_IND:
12669 {
12670 if(pWDA->wdaState == WDA_READY_STATE)
12671 {
12672 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
12673 }
12674 else
12675 {
12676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12677 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
12678 }
12679 break;
12680 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12681 case WDA_REGISTER_PE_CALLBACK :
12682 {
12683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12684 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
12685 /*TODO: store the PE callback */
12686 /* Do Nothing? MSG Body should be freed at here */
12687 if(NULL != pMsg->bodyptr)
12688 {
12689 vos_mem_free(pMsg->bodyptr);
12690 }
12691 break;
12692 }
12693 case WDA_SYS_READY_IND :
12694 {
12695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12696 "Handling msg type WDA_SYS_READY_IND " );
12697 pWDA->wdaState = WDA_READY_STATE;
12698 if(NULL != pMsg->bodyptr)
12699 {
12700 vos_mem_free(pMsg->bodyptr);
12701 }
12702 break;
12703 }
12704 case WDA_BEACON_FILTER_IND :
12705 {
12706 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
12707 break;
12708 }
12709 case WDA_BTC_SET_CFG:
12710 {
12711 /*TODO: handle this while dealing with BTC */
12712 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12713 "Handling msg type WDA_BTC_SET_CFG " );
12714 /* Do Nothing? MSG Body should be freed at here */
12715 if(NULL != pMsg->bodyptr)
12716 {
12717 vos_mem_free(pMsg->bodyptr);
12718 }
12719 break;
12720 }
12721 case WDA_SIGNAL_BT_EVENT:
12722 {
12723 /*TODO: handle this while dealing with BTC */
12724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12725 "Handling msg type WDA_SIGNAL_BT_EVENT " );
12726 /* Do Nothing? MSG Body should be freed at here */
12727 if(NULL != pMsg->bodyptr)
12728 {
12729 vos_mem_free(pMsg->bodyptr);
12730 }
12731 break;
12732 }
12733 case WDA_CFG_RXP_FILTER_REQ:
12734 {
12735 WDA_ProcessConfigureRxpFilterReq(pWDA,
12736 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
12737 break;
12738 }
12739 case WDA_SET_HOST_OFFLOAD:
12740 {
12741 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12742 break;
12743 }
12744 case WDA_SET_KEEP_ALIVE:
12745 {
12746 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
12747 break;
12748 }
12749#ifdef WLAN_NS_OFFLOAD
12750 case WDA_SET_NS_OFFLOAD:
12751 {
12752 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12753 break;
12754 }
12755#endif //WLAN_NS_OFFLOAD
12756 case WDA_ADD_STA_SELF_REQ:
12757 {
12758 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
12759 break;
12760 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12761 case WDA_DEL_STA_SELF_REQ:
12762 {
12763 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
12764 break;
12765 }
12766 case WDA_WOWL_ADD_BCAST_PTRN:
12767 {
12768 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
12769 break;
12770 }
12771 case WDA_WOWL_DEL_BCAST_PTRN:
12772 {
12773 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
12774 break;
12775 }
12776 case WDA_WOWL_ENTER_REQ:
12777 {
12778 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
12779 break;
12780 }
12781 case WDA_WOWL_EXIT_REQ:
12782 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12783 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12784 break;
12785 }
12786 case WDA_TL_FLUSH_AC_REQ:
12787 {
12788 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
12789 break;
12790 }
12791 case WDA_SIGNAL_BTAMP_EVENT:
12792 {
12793 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
12794 break;
12795 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]12796#ifdef WLAN_FEATURE_LINK_LAYER_STATS
12797 case WDA_LINK_LAYER_STATS_SET_REQ:
12798 {
12799 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
12800 break;
12801 }
12802 case WDA_LINK_LAYER_STATS_GET_REQ:
12803 {
12804 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
12805 break;
12806 }
12807 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
12808 {
12809 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
12810 break;
12811 }
12812#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]12813#ifdef WLAN_FEATURE_EXTSCAN
12814 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
12815 {
12816 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
12817 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
12818 break;
12819 }
12820 case WDA_EXTSCAN_START_REQ:
12821 {
12822 WDA_ProcessEXTScanStartReq(pWDA,
12823 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
12824 break;
12825 }
12826 case WDA_EXTSCAN_STOP_REQ:
12827 {
12828 WDA_ProcessEXTScanStopReq(pWDA,
12829 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
12830 break;
12831 }
12832 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
12833 {
12834 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
12835 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
12836 break;
12837 }
12838 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
12839 {
12840 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
12841 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
12842 break;
12843 }
12844 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
12845 {
12846 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
12847 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
12848 break;
12849 }
12850 case WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_REQ:
12851 {
12852 WDA_ProcessEXTScanSetSignfRSSIChangeReq(pWDA,
12853 (tSirEXTScanSetSignificantChangeReqParams *)pMsg->bodyptr);
12854 break;
12855 }
12856 case WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_REQ:
12857 {
12858 WDA_ProcessEXTScanResetSignfRSSIChangeReq(pWDA,
12859 (tSirEXTScanResetSignificantChangeReqParams *)pMsg->bodyptr);
12860 break;
12861 }
12862#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12863#ifdef WDA_UT
12864 case WDA_WDI_EVENT_MSG:
12865 {
12866 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
12867 break ;
12868 }
12869#endif
12870 case WDA_UPDATE_BEACON_IND:
12871 {
12872 WDA_ProcessUpdateBeaconParams(pWDA,
12873 (tUpdateBeaconParams *)pMsg->bodyptr);
12874 break;
12875 }
12876 case WDA_SEND_BEACON_REQ:
12877 {
12878 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
12879 break;
12880 }
12881 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
12882 {
12883 WDA_ProcessUpdateProbeRspTemplate(pWDA,
12884 (tSendProbeRespParams *)pMsg->bodyptr);
12885 break;
12886 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12887#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12888 case WDA_SET_MAX_TX_POWER_REQ:
12889 {
12890 WDA_ProcessSetMaxTxPowerReq(pWDA,
12891 (tMaxTxPowerParams *)pMsg->bodyptr);
12892 break;
12893 }
12894#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]12895 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
12896 {
12897 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
12898 pMsg->bodyptr);
12899 break;
12900 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]12901 case WDA_SET_TX_POWER_REQ:
12902 {
12903 WDA_ProcessSetTxPowerReq(pWDA,
12904 (tSirSetTxPowerReq *)pMsg->bodyptr);
12905 break;
12906 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12907 case WDA_SET_P2P_GO_NOA_REQ:
12908 {
12909 WDA_ProcessSetP2PGONOAReq(pWDA,
12910 (tP2pPsParams *)pMsg->bodyptr);
12911 break;
12912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12913 /* timer related messages */
12914 case WDA_TIMER_BA_ACTIVITY_REQ:
12915 {
12916 WDA_BaCheckActivity(pWDA) ;
12917 break ;
12918 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]12919
12920 /* timer related messages */
12921 case WDA_TIMER_TRAFFIC_STATS_IND:
12922 {
12923 WDA_TimerTrafficStatsInd(pWDA);
12924 break;
12925 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12926#ifdef WLAN_FEATURE_VOWIFI_11R
12927 case WDA_AGGR_QOS_REQ:
12928 {
12929 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
12930 break;
12931 }
12932#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12933 case WDA_FTM_CMD_REQ:
12934 {
12935 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
12936 break ;
12937 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12938#ifdef FEATURE_OEM_DATA_SUPPORT
12939 case WDA_START_OEM_DATA_REQ:
12940 {
12941 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
12942 break;
12943 }
12944#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12945 /* Tx Complete Time out Indication */
12946 case WDA_TX_COMPLETE_TIMEOUT_IND:
12947 {
12948 WDA_ProcessTxCompleteTimeOutInd(pWDA);
12949 break;
12950 }
12951 case WDA_WLAN_SUSPEND_IND:
12952 {
12953 WDA_ProcessWlanSuspendInd(pWDA,
12954 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
12955 break;
12956 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12957 case WDA_WLAN_RESUME_REQ:
12958 {
12959 WDA_ProcessWlanResumeReq(pWDA,
12960 (tSirWlanResumeParam *)pMsg->bodyptr) ;
12961 break;
12962 }
12963
12964 case WDA_UPDATE_CF_IND:
12965 {
12966 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
12967 pMsg->bodyptr = NULL;
12968 break;
12969 }
12970#ifdef FEATURE_WLAN_SCAN_PNO
12971 case WDA_SET_PNO_REQ:
12972 {
12973 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
12974 break;
12975 }
12976 case WDA_UPDATE_SCAN_PARAMS_REQ:
12977 {
12978 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
12979 break;
12980 }
12981 case WDA_SET_RSSI_FILTER_REQ:
12982 {
12983 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
12984 break;
12985 }
12986#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12987#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12988 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12989 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12990 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12991 break;
12992 }
12993#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12994 case WDA_SET_TX_PER_TRACKING_REQ:
12995 {
12996 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
12997 break;
12998 }
12999
13000#ifdef WLAN_FEATURE_PACKET_FILTERING
13001 case WDA_8023_MULTICAST_LIST_REQ:
13002 {
13003 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
13004 break;
13005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13006 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
13007 {
13008 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
13009 break;
13010 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13011 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
13012 {
13013 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
13014 break;
13015 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13016 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
13017 {
13018 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
13019 break;
13020 }
13021#endif // WLAN_FEATURE_PACKET_FILTERING
13022
13023
13024 case WDA_TRANSMISSION_CONTROL_IND:
13025 {
13026 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
13027 break;
13028 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13029 case WDA_SET_POWER_PARAMS_REQ:
13030 {
13031 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
13032 break;
13033 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13034#ifdef WLAN_FEATURE_GTK_OFFLOAD
13035 case WDA_GTK_OFFLOAD_REQ:
13036 {
13037 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
13038 break;
13039 }
13040
13041 case WDA_GTK_OFFLOAD_GETINFO_REQ:
13042 {
13043 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
13044 break;
13045 }
13046#endif //WLAN_FEATURE_GTK_OFFLOAD
13047
13048 case WDA_SET_TM_LEVEL_REQ:
13049 {
13050 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
13051 break;
13052 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13053
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13054 case WDA_UPDATE_OP_MODE:
13055 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13056 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
13057 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
13058 {
13059 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13060 }
13061 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13062 {
13063 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
13064 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13065 else
13066 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13067 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13068 }
13069 else
13070 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13071 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13072 break;
13073 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]13074#ifdef WLAN_FEATURE_11W
13075 case WDA_EXCLUDE_UNENCRYPTED_IND:
13076 {
13077 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
13078 break;
13079 }
13080#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13081#ifdef FEATURE_WLAN_TDLS
13082 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
13083 {
13084 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
13085 break;
13086 }
13087#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13088 case WDA_DHCP_START_IND:
13089 {
13090 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13091 break;
13092 }
13093 case WDA_DHCP_STOP_IND:
13094 {
13095 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13096 break;
13097 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13098#ifdef FEATURE_WLAN_LPHB
13099 case WDA_LPHB_CONF_REQ:
13100 {
13101 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
13102 break;
13103 }
13104#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13105 case WDA_ADD_PERIODIC_TX_PTRN_IND:
13106 {
13107 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
13108 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
13109 break;
13110 }
13111 case WDA_DEL_PERIODIC_TX_PTRN_IND:
13112 {
13113 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
13114 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
13115 break;
13116 }
13117
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13118#ifdef FEATURE_WLAN_BATCH_SCAN
13119 case WDA_SET_BATCH_SCAN_REQ:
13120 {
13121 WDA_ProcessSetBatchScanReq(pWDA,
13122 (tSirSetBatchScanReq *)pMsg->bodyptr);
13123 break;
13124 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]13125 case WDA_RATE_UPDATE_IND:
13126 {
13127 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
13128 break;
13129 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13130 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
13131 {
13132 WDA_ProcessTriggerBatchScanResultInd(pWDA,
13133 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
13134 break;
13135 }
13136 case WDA_STOP_BATCH_SCAN_IND:
13137 {
13138 WDA_ProcessStopBatchScanInd(pWDA,
13139 (tSirStopBatchScanInd *)pMsg->bodyptr);
13140 break;
13141 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]13142 case WDA_GET_BCN_MISS_RATE_REQ:
13143 WDA_ProcessGetBcnMissRateReq(pWDA,
13144 (tSirBcnMissRateReq *)pMsg->bodyptr);
13145 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13146#endif
13147
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13148 case WDA_HT40_OBSS_SCAN_IND:
13149 {
13150 WDA_ProcessHT40OBSSScanInd(pWDA,
13151 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
13152 break;
13153 }
13154 case WDA_HT40_OBSS_STOP_SCAN_IND:
13155 {
13156 WDA_ProcessHT40OBSSStopScanInd(pWDA,
13157 (tANI_U8*)pMsg->bodyptr);
13158 break;
13159 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame^]13160// tdlsoffchan
13161#ifdef FEATURE_WLAN_TDLS
13162 case WDA_SET_TDLS_CHAN_SWITCH_REQ:
13163 {
13164 WDA_ProcessSetTdlsChanSwitchReq(pWDA, (tTdlsChanSwitchParams *)pMsg->bodyptr);
13165 break;
13166 }
13167#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13168 default:
13169 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]13170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13171 "No Handling for msg type %x in WDA "
13172 ,pMsg->type);
13173 /* Do Nothing? MSG Body should be freed at here */
13174 if(NULL != pMsg->bodyptr)
13175 {
13176 vos_mem_free(pMsg->bodyptr);
13177 }
13178 //WDA_VOS_ASSERT(0) ;
13179 }
13180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13181 return status ;
13182}
13183
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13184/*
13185 * FUNCTION: WDA_LowLevelIndCallback
13186 * IND API callback from WDI, send Ind to PE
13187 */
13188void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
13189 void* pUserData )
13190{
13191 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
13192#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13193 tSirRSSINotification rssiNotification;
13194#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13195 if(NULL == pWDA)
13196 {
13197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13198 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13199 VOS_ASSERT(0);
13200 return ;
13201 }
13202
13203 switch(wdiLowLevelInd->wdiIndicationType)
13204 {
13205 case WDI_RSSI_NOTIFICATION_IND:
13206 {
13207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13208 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13209#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13210 rssiNotification.bReserved =
13211 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
13212 rssiNotification.bRssiThres1NegCross =
13213 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
13214 rssiNotification.bRssiThres1PosCross =
13215 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
13216 rssiNotification.bRssiThres2NegCross =
13217 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
13218 rssiNotification.bRssiThres2PosCross =
13219 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
13220 rssiNotification.bRssiThres3NegCross =
13221 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
13222 rssiNotification.bRssiThres3PosCross =
13223 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]13224 rssiNotification.avgRssi = (v_S7_t)
13225 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13226 WLANTL_BMPSRSSIRegionChangedNotification(
13227 pWDA->pVosContext,
13228 &rssiNotification);
13229#endif
13230 break ;
13231 }
13232 case WDI_MISSED_BEACON_IND:
13233 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13234 tpSirSmeMissedBeaconInd pMissBeacInd =
13235 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13236 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13237 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13238 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13239 if(NULL == pMissBeacInd)
13240 {
13241 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13242 "%s: VOS MEM Alloc Failure", __func__);
13243 break;
13244 }
13245 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
13246 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
13247 pMissBeacInd->bssIdx =
13248 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
13249 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13250 break ;
13251 }
13252 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
13253 {
13254 /* TODO: Decode Ind and send Ind to PE */
13255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13256 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
13257 break ;
13258 }
13259
13260 case WDI_MIC_FAILURE_IND:
13261 {
13262 tpSirSmeMicFailureInd pMicInd =
13263 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
13264
13265 if(NULL == pMicInd)
13266 {
13267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13268 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13269 break;
13270 }
13271 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13272 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13273 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
13274 pMicInd->length = sizeof(tSirSmeMicFailureInd);
13275 vos_mem_copy(pMicInd->bssId,
13276 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
13277 sizeof(tSirMacAddr));
13278 vos_mem_copy(pMicInd->info.srcMacAddr,
13279 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
13280 sizeof(tSirMacAddr));
13281 vos_mem_copy(pMicInd->info.taMacAddr,
13282 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
13283 sizeof(tSirMacAddr));
13284 vos_mem_copy(pMicInd->info.dstMacAddr,
13285 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
13286 sizeof(tSirMacAddr));
13287 vos_mem_copy(pMicInd->info.rxMacAddr,
13288 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
13289 sizeof(tSirMacAddr));
13290 pMicInd->info.multicast =
13291 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
13292 pMicInd->info.keyId=
13293 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
13294 pMicInd->info.IV1=
13295 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
13296 vos_mem_copy(pMicInd->info.TSC,
13297 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13298 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
13299 (void *)pMicInd , 0) ;
13300 break ;
13301 }
13302 case WDI_FATAL_ERROR_IND:
13303 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]13304 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13305 /* TODO: Decode Ind and send Ind to PE */
13306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13307 "Received WDI_FATAL_ERROR_IND from WDI ");
13308 break ;
13309 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13310 case WDI_DEL_STA_IND:
13311 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13312 tpDeleteStaContext pDelSTACtx =
13313 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
13314
13315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13316 "Received WDI_DEL_STA_IND from WDI ");
13317 if(NULL == pDelSTACtx)
13318 {
13319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13320 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13321 break;
13322 }
13323 vos_mem_copy(pDelSTACtx->addr2,
13324 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
13325 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13326 vos_mem_copy(pDelSTACtx->bssId,
13327 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
13328 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13329 pDelSTACtx->assocId =
13330 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
13331 pDelSTACtx->reasonCode =
13332 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
13333 pDelSTACtx->staId =
13334 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13335 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
13336 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13337 break ;
13338 }
13339 case WDI_COEX_IND:
13340 {
13341 tANI_U32 index;
13342 vos_msg_t vosMsg;
13343 tSirSmeCoexInd *pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
13344 if(NULL == pSmeCoexInd)
13345 {
13346 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13347 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13348 break;
13349 }
13350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13351 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13352 /* Message Header */
13353 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
13354 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13355 /* Info from WDI Indication */
13356 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
13357 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
13358 {
13359 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
13360 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13361 /* VOS message wrapper */
13362 vosMsg.type = eWNI_SME_COEX_IND;
13363 vosMsg.bodyptr = (void *)pSmeCoexInd;
13364 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13365 /* Send message to SME */
13366 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13367 {
13368 /* free the mem and return */
13369 vos_mem_free((v_VOID_t *)pSmeCoexInd);
13370 }
13371 else
13372 {
13373 /* DEBUG */
13374 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13375 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
13376 pSmeCoexInd->coexIndType,
13377 pSmeCoexInd->coexIndData[0],
13378 pSmeCoexInd->coexIndData[1],
13379 pSmeCoexInd->coexIndData[2],
13380 pSmeCoexInd->coexIndData[3]);
13381 }
13382 break;
13383 }
13384 case WDI_TX_COMPLETE_IND:
13385 {
13386 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
13387 /* Calling TxCompleteAck Indication from wda context*/
13388 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13389 "Complete Indication received from HAL");
13390 if( pWDA->pAckTxCbFunc )
13391 {
13392 if( VOS_STATUS_SUCCESS !=
13393 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13394 {
13395 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13396 "Tx Complete timeout Timer Stop Failed ");
13397 }
13398 pWDA->pAckTxCbFunc( pMac, wdiLowLevelInd->wdiIndicationData.tx_complete_status);
13399 pWDA->pAckTxCbFunc = NULL;
13400 }
13401 else
13402 {
13403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13404 "Tx Complete Indication is received after timeout ");
13405 }
13406 break;
13407 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]13408 case WDI_P2P_NOA_START_IND :
13409 {
13410 tSirP2PNoaStart *pP2pNoaStart =
13411 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
13412
13413 if (NULL == pP2pNoaStart)
13414 {
13415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13416 "Memory allocation failure, "
13417 "WDI_P2P_NOA_START_IND not forwarded");
13418 break;
13419 }
13420 pP2pNoaStart->status =
13421 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
13422 pP2pNoaStart->bssIdx =
13423 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
13424 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
13425 (void *)pP2pNoaStart , 0) ;
13426 break;
13427 }
13428
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13429#ifdef FEATURE_WLAN_TDLS
13430 case WDI_TDLS_IND :
13431 {
13432 tSirTdlsInd *pTdlsInd =
13433 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
13434
13435 if (NULL == pTdlsInd)
13436 {
13437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13438 "Memory allocation failure, "
13439 "WDI_TDLS_IND not forwarded");
13440 break;
13441 }
13442 pTdlsInd->status =
13443 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
13444 pTdlsInd->assocId =
13445 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
13446 pTdlsInd->staIdx =
13447 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
13448 pTdlsInd->reasonCode =
13449 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
13450 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
13451 (void *)pTdlsInd , 0) ;
13452 break;
13453 }
13454#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13455 case WDI_P2P_NOA_ATTR_IND :
13456 {
13457 tSirP2PNoaAttr *pP2pNoaAttr =
13458 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13460 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13461 if (NULL == pP2pNoaAttr)
13462 {
13463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13464 "Memory allocation failure, "
13465 "WDI_P2P_NOA_ATTR_IND not forwarded");
13466 break;
13467 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13468 pP2pNoaAttr->index =
13469 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
13470 pP2pNoaAttr->oppPsFlag =
13471 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
13472 pP2pNoaAttr->ctWin =
13473 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
13474
13475 pP2pNoaAttr->uNoa1IntervalCnt =
13476 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
13477 pP2pNoaAttr->uNoa1Duration =
13478 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
13479 pP2pNoaAttr->uNoa1Interval =
13480 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
13481 pP2pNoaAttr->uNoa1StartTime =
13482 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13483 pP2pNoaAttr->uNoa2IntervalCnt =
13484 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
13485 pP2pNoaAttr->uNoa2Duration =
13486 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
13487 pP2pNoaAttr->uNoa2Interval =
13488 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
13489 pP2pNoaAttr->uNoa2StartTime =
13490 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13491 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
13492 (void *)pP2pNoaAttr , 0) ;
13493 break;
13494 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13495#ifdef FEATURE_WLAN_SCAN_PNO
13496 case WDI_PREF_NETWORK_FOUND_IND:
13497 {
13498 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13499 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
13500 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13501 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
13502 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
13503
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13504 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13505 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13506 if (NULL == pPrefNetworkFoundInd)
13507 {
13508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13509 "Memory allocation failure, "
13510 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]13511 if (NULL !=
13512 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13513 {
13514 wpalMemoryFree(
13515 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
13516 );
13517 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13518 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13519 break;
13520 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13521 /* Message Header */
13522 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13523 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13524
13525 /* Info from WDI Indication */
13526 pPrefNetworkFoundInd->ssId.length =
13527 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13528 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13529 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
13530 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
13531 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13532 if (NULL !=
13533 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13534 {
13535 pPrefNetworkFoundInd->frameLength =
13536 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13537 vos_mem_copy( pPrefNetworkFoundInd->data,
13538 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
13539 pPrefNetworkFoundInd->frameLength);
13540 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
13541 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13542 }
13543 else
13544 {
13545 pPrefNetworkFoundInd->frameLength = 0;
13546 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13547 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13548 /* VOS message wrapper */
13549 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
13550 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
13551 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13552 /* Send message to SME */
13553 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13554 {
13555 /* free the mem and return */
13556 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
13557 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13558 break;
13559 }
13560#endif // FEATURE_WLAN_SCAN_PNO
13561
13562#ifdef WLAN_WAKEUP_EVENTS
13563 case WDI_WAKE_REASON_IND:
13564 {
13565 vos_msg_t vosMsg;
13566 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
13567 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
13568 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
13569
13570 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13571 "[WAKE_REASON WDI] WAKE_REASON_IND Type (0x%x) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
13572 wdiLowLevelInd->wdiIndicationType,
13573 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
13574 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
13575 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13576
13577 if (NULL == pWakeReasonInd)
13578 {
13579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13580 "Memory allocation failure, "
13581 "WDI_WAKE_REASON_IND not forwarded");
13582 break;
13583 }
13584
13585 vos_mem_zero(pWakeReasonInd, allocSize);
13586
13587 /* Message Header */
13588 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
13589 pWakeReasonInd->mesgLen = allocSize;
13590
13591 /* Info from WDI Indication */
13592 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
13593 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
13594 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
13595 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
13596 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
13597 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
13598 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
13599 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13600
13601 /* VOS message wrapper */
13602 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
13603 vosMsg.bodyptr = (void *) pWakeReasonInd;
13604 vosMsg.bodyval = 0;
13605
13606 /* Send message to SME */
13607 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13608 {
13609 /* free the mem and return */
13610 vos_mem_free((v_VOID_t *) pWakeReasonInd);
13611 }
13612
13613 break;
13614 }
13615#endif // WLAN_WAKEUP_EVENTS
13616
13617 case WDI_TX_PER_HIT_IND:
13618 {
13619 vos_msg_t vosMsg;
13620 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
13621 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
13622 /* VOS message wrapper */
13623 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
13624 vosMsg.bodyptr = NULL;
13625 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13626 /* Send message to SME */
13627 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13628 {
13629 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
13630 }
13631 break;
13632 }
13633
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13634#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13635 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13636 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13637 vos_msg_t vosMsg;
13638 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13639
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13640 lphbInd =
13641 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
13642 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13643 {
13644 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13645 "%s: LPHB IND buffer alloc Fail", __func__);
13646 return ;
13647 }
13648
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13649 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13650 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13651 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13652 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13653 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13654 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
13655
13656 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13657 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13658 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
13659
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13660 vosMsg.type = eWNI_SME_LPHB_IND;
13661 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13662 vosMsg.bodyval = 0;
13663 /* Send message to SME */
13664 if (VOS_STATUS_SUCCESS !=
13665 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13666 {
13667 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13668 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13669 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13670 }
13671 break;
13672 }
13673#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13674 case WDI_PERIODIC_TX_PTRN_FW_IND:
13675 {
13676 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13677 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
13678 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
13679 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
13680 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
13681 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
13682 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
13683
13684 break;
13685 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13686
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]13687 case WDI_IBSS_PEER_INACTIVITY_IND:
13688 {
13689 tSirIbssPeerInactivityInd *pIbssInd =
13690 (tSirIbssPeerInactivityInd *)
13691 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
13692
13693 if (NULL == pIbssInd)
13694 {
13695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13696 "Memory allocation failure, "
13697 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
13698 break;
13699 }
13700
13701 pIbssInd->bssIdx =
13702 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
13703 pIbssInd->staIdx =
13704 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
13705 vos_mem_copy(pIbssInd->peerAddr,
13706 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
13707 sizeof(tSirMacAddr));
13708 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
13709 break;
13710 }
13711
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13712#ifdef FEATURE_WLAN_BATCH_SCAN
13713 case WDI_BATCH_SCAN_RESULT_IND:
13714 {
13715 void *pBatchScanResult;
13716 void *pCallbackContext;
13717 tpAniSirGlobal pMac;
13718
13719 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13720 "Received WDI_BATCHSCAN_RESULT_IND from FW");
13721
13722 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13723 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13724 {
13725 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13726 "%s:pWDA is NULL", __func__);
13727 VOS_ASSERT(0);
13728 return;
13729 }
13730
13731 pBatchScanResult =
13732 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
13733 if (NULL == pBatchScanResult)
13734 {
13735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13736 "%s:Batch scan result from FW is null can't invoke HDD callback",
13737 __func__);
13738 VOS_ASSERT(0);
13739 return;
13740 }
13741
13742 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13743 if (NULL == pMac)
13744 {
13745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13746 "%s:pMac is NULL", __func__);
13747 VOS_ASSERT(0);
13748 return;
13749 }
13750
13751 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
13752 /*call hdd callback with set batch scan response data*/
13753 if(pMac->pmc.batchScanResultCallback)
13754 {
13755 pMac->pmc.batchScanResultCallback(pCallbackContext,
13756 pBatchScanResult);
13757 }
13758 else
13759 {
13760 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13761 "%s:HDD callback is null", __func__);
13762 VOS_ASSERT(0);
13763 }
13764 break;
13765 }
13766#endif
13767
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]13768#ifdef FEATURE_WLAN_CH_AVOID
13769 case WDI_CH_AVOID_IND:
13770 {
13771 vos_msg_t vosMsg;
13772 tSirChAvoidIndType *chAvoidInd;
13773
13774 chAvoidInd =
13775 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
13776 if (NULL == chAvoidInd)
13777 {
13778 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13779 "%s: CH_AVOID IND buffer alloc Fail", __func__);
13780 return ;
13781 }
13782
13783 chAvoidInd->avoidRangeCount =
13784 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
13785 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
13786 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
13787 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
13788
13789 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13790 "%s : WDA CH avoid notification", __func__);
13791
13792 vosMsg.type = eWNI_SME_CH_AVOID_IND;
13793 vosMsg.bodyptr = chAvoidInd;
13794 vosMsg.bodyval = 0;
13795 /* Send message to SME */
13796 if (VOS_STATUS_SUCCESS !=
13797 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13798 {
13799 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13800 "post eWNI_SME_CH_AVOID_IND to SME Failed");
13801 vos_mem_free(chAvoidInd);
13802 }
13803 break;
13804 }
13805#endif /* FEATURE_WLAN_CH_AVOID */
13806
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13807#ifdef WLAN_FEATURE_LINK_LAYER_STATS
13808 case WDI_LL_STATS_RESULTS_IND:
13809 {
13810 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13811 tpAniSirGlobal pMac;
13812
13813 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13814 "Received WDI_LL_STATS_RESULTS_IND from FW");
13815
13816 /*sanity check*/
13817 if (NULL == pWDA)
13818 {
13819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13820 "%s:pWDA is NULL", __func__);
13821 VOS_ASSERT(0);
13822 return;
13823 }
13824
13825 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13826 (void *)wdiLowLevelInd->
13827 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13828 if (NULL == pLinkLayerStatsInd)
13829 {
13830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13831 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
13832 __func__);
13833 VOS_ASSERT(0);
13834 return;
13835 }
13836
13837 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13838 if (NULL == pMac)
13839 {
13840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13841 "%s:pMac is NULL", __func__);
13842 VOS_ASSERT(0);
13843 return;
13844 }
13845
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13846 /* call hdd callback with Link Layer Statistics.
13847 * vdev_id/ifacId in link_stats_results will be
13848 * used to retrieve the correct HDD context
13849 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13850 if (pMac->sme.pLinkLayerStatsIndCallback)
13851 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13852 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13853 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13854 pLinkLayerStatsInd,
13855 wdiLowLevelInd->
13856 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13857 }
13858 else
13859 {
13860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13861 "%s:HDD callback is null", __func__);
13862 }
13863 break;
13864 }
13865#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
13866
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]13867#ifdef WLAN_FEATURE_EXTSCAN
13868 case WDI_EXTSCAN_PROGRESS_IND:
13869 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
13870 case WDI_EXTSCAN_SCAN_RESULT_IND:
13871 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
13872 case WDI_EXTSCAN_SIGN_RSSI_RESULT_IND:
13873 {
13874 void *pEXTScanData;
13875 void *pCallbackContext;
13876 tpAniSirGlobal pMac;
13877 tANI_U16 indType;
13878
13879 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13880 "Received WDI_EXTSCAN Indications from FW");
13881 /*sanity check*/
13882 if (NULL == pWDA)
13883 {
13884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13885 "%s:pWDA is NULL", __func__);
13886 VOS_ASSERT(0);
13887 return;
13888 }
13889 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
13890 {
13891 indType = WDA_EXTSCAN_PROGRESS_IND;
13892
13893 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13894 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
13895 }
13896 if (wdiLowLevelInd->wdiIndicationType ==
13897 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
13898 {
13899 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
13900
13901 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13902 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
13903 }
13904 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
13905 {
13906 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
13907
13908 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13909 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
13910 }
13911 if (wdiLowLevelInd->wdiIndicationType ==
13912 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
13913 {
13914 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
13915
13916 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13917 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
13918 }
13919 if (wdiLowLevelInd->wdiIndicationType ==
13920 WDI_EXTSCAN_SIGN_RSSI_RESULT_IND)
13921 {
13922 indType = WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND;
13923
13924 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13925 "WDI_EXTSCAN Indication is WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND");
13926 }
13927
13928 pEXTScanData =
13929 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
13930 if (NULL == pEXTScanData)
13931 {
13932 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13933 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
13934 __func__);
13935 VOS_ASSERT(0);
13936 return;
13937 }
13938
13939 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13940 if (NULL == pMac)
13941 {
13942 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13943 "%s:pMac is NULL", __func__);
13944 VOS_ASSERT(0);
13945 return;
13946 }
13947
13948 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
13949
13950 if(pMac->sme.pEXTScanIndCb)
13951 {
13952 pMac->sme.pEXTScanIndCb(pCallbackContext,
13953 indType,
13954 pEXTScanData);
13955 }
13956 else
13957 {
13958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13959 "%s:HDD callback is null", __func__);
13960 }
13961 break;
13962 }
13963#endif /* WLAN_FEATURE_EXTSCAN */
13964
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13965 default:
13966 {
13967 /* TODO error */
13968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13969 "Received UNKNOWN Indication from WDI ");
13970 }
13971 }
13972 return ;
13973}
13974
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13975/*
13976 * BA related processing in WDA.
13977 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13978void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
13979 void* pUserData)
13980{
13981 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13982 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13983 if(NULL == pWdaParams)
13984 {
13985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13986 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13987 VOS_ASSERT(0) ;
13988 return ;
13989 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13990 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13991 vos_mem_free(pWdaParams->wdaMsgParam) ;
13992 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13993 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13995 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13996 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
13997 {
13998 tANI_U8 i = 0 ;
13999 tBaActivityInd *baActivityInd = NULL ;
14000 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
14001 tANI_U8 allocSize = sizeof(tBaActivityInd)
14002 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
14003 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
14004 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14005 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14006 if(NULL == baActivityInd)
14007 {
14008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14009 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14010 VOS_ASSERT(0) ;
14011 return;
14012 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14013 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
14014 sizeof(tSirMacAddr)) ;
14015 baActivityInd->baCandidateCnt = baCandidateCount ;
14016
14017 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
14018 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
14019
14020 for(i = 0 ; i < baCandidateCount ; i++)
14021 {
14022 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14023 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
14024 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14025 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
14026 {
14027 baCandidate->baInfo[tid].fBaEnable =
14028 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
14029 baCandidate->baInfo[tid].startingSeqNum =
14030 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
14031 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]14032 wdiBaCandidate++ ;
14033 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14034 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14035 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
14036 }
14037 else
14038 {
14039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14040 "BA Trigger RSP with Failure received ");
14041 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14042 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14043}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14044
14045
14046/*
14047 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
14048 * during MCC
14049 */
14050void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
14051{
14052 wpt_uint32 enabled;
14053 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
14054 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
14055 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
14056
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14057 if (NULL == pMac )
14058 {
14059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14060 "%s: Invoked with invalid MAC context ", __func__ );
14061 VOS_ASSERT(0);
14062 return;
14063 }
14064
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14065 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14066 != eSIR_SUCCESS)
14067 {
14068 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14069 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14070 return;
14071 }
14072
14073 if(!enabled)
14074 {
14075 return;
14076 }
14077
14078 if(NULL == pWDA)
14079 {
14080 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14081 "%s:WDA context is NULL", __func__);
14082 VOS_ASSERT(0);
14083 return;
14084 }
14085
14086 if(activate)
14087 {
14088 if( VOS_STATUS_SUCCESS !=
14089 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14090 {
14091 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14092 "Traffic Stats Timer Start Failed ");
14093 return;
14094 }
14095 WDI_DS_ActivateTrafficStats();
14096 }
14097 else
14098 {
14099 WDI_DS_DeactivateTrafficStats();
14100 WDI_DS_ClearTrafficStats();
14101
14102 if( VOS_STATUS_SUCCESS !=
14103 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14104 {
14105 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14106 "Traffic Stats Timer Stop Failed ");
14107 return;
14108 }
14109 }
14110}
14111
14112/*
14113 * Traffic Stats Timer handler
14114 */
14115void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
14116{
14117 WDI_Status wdiStatus;
14118 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
14119 WDI_TrafficStatsIndType trafficStatsIndParams;
14120 wpt_uint32 length, enabled;
14121 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14122
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14123 if (NULL == pMac )
14124 {
14125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14126 "%s: Invoked with invalid MAC context ", __func__ );
14127 VOS_ASSERT(0);
14128 return;
14129 }
14130
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14131 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14132 != eSIR_SUCCESS)
14133 {
14134 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14135 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14136 return;
14137 }
14138
14139 if(!enabled)
14140 {
14141 WDI_DS_DeactivateTrafficStats();
14142 return;
14143 }
14144
14145 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
14146
14147 if(pWdiTrafficStats != NULL)
14148 {
14149 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
14150 trafficStatsIndParams.length = length;
14151 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]14152 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14153 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
14154 trafficStatsIndParams.pUserData = pWDA;
14155
14156 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
14157
14158 if(WDI_STATUS_PENDING == wdiStatus)
14159 {
14160 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14161 "Pending received for %s:%d ",__func__,__LINE__ );
14162 }
14163 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
14164 {
14165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14166 "Failure in %s:%d ",__func__,__LINE__ );
14167 }
14168
14169 WDI_DS_ClearTrafficStats();
14170 }
14171 else
14172 {
14173 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14174 "pWdiTrafficStats is Null");
14175 }
14176
14177 if( VOS_STATUS_SUCCESS !=
14178 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14179 {
14180 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14181 "Traffic Stats Timer Start Failed ");
14182 return;
14183 }
14184}
14185
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14186/*
14187 * BA Activity check timer handler
14188 */
14189void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
14190{
14191 tANI_U8 curSta = 0 ;
14192 tANI_U8 tid = 0 ;
14193 tANI_U8 size = 0 ;
14194 tANI_U8 baCandidateCount = 0 ;
14195 tANI_U8 newBaCandidate = 0 ;
14196 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
14197
14198 if(NULL == pWDA)
14199 {
14200 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14201 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14202 VOS_ASSERT(0);
14203 return ;
14204 }
14205 if(WDA_MAX_STA < pWDA->wdaMaxSta)
14206 {
14207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14208 "Inconsistent STA entries in WDA");
14209 VOS_ASSERT(0) ;
14210 }
14211 /* walk through all STA entries and find out TX packet count */
14212 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
14213 {
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]14214#ifdef WLAN_SOFTAP_VSTA_FEATURE
14215 // We can only do BA on "hard" STAs.
14216 if (!(IS_HWSTA_IDX(curSta)))
14217 {
14218 continue;
14219 }
14220#endif //WLAN_SOFTAP_VSTA_FEATURE
14221 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
14222 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14223 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14224 tANI_U32 txPktCount = 0 ;
14225 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14226 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14227 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
14228 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14229 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
14230 curSta, tid, &txPktCount)))
14231 {
14232#if 0
14233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14234 "************* %d:%d, %d ",curSta, txPktCount,
14235 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
14236#endif
14237 if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14238 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14239 && (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
14240 curSta, tid)))
14241 {
14242 /* get prepare for sending message to HAL */
14243 //baCandidate[baCandidateCount].staIdx = curSta ;
14244 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
14245 newBaCandidate = WDA_ENABLE_BA ;
14246 }
14247 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
14248 }
14249 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14250 /* fill the entry for all the sta with given TID's */
14251 if(WDA_ENABLE_BA == newBaCandidate)
14252 {
14253 /* move to next BA candidate */
14254 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
14255 size += sizeof(WDI_TriggerBAReqCandidateType) ;
14256 baCandidateCount++ ;
14257 newBaCandidate = WDA_DISABLE_BA ;
14258 }
14259 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14260 /* prepare and send message to hal */
14261 if( 0 < baCandidateCount)
14262 {
14263 WDI_Status status = WDI_STATUS_SUCCESS ;
14264 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
14265 tWDA_ReqParams *pWdaParams =
14266 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14267 if(NULL == pWdaParams)
14268 {
14269 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14270 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14271 VOS_ASSERT(0) ;
14272 return;
14273 }
14274 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
14275 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
14276 if(NULL == wdiTriggerBaReq)
14277 {
14278 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14279 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14280 VOS_ASSERT(0) ;
14281 vos_mem_free(pWdaParams);
14282 return;
14283 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14284 do
14285 {
14286 WDI_TriggerBAReqinfoType *triggerBaInfo =
14287 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
14288 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
14289 /* TEMP_FIX: Need to see if WDI need check for assoc session for
14290 * for each request */
14291 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
14292 triggerBaInfo->ucBASessionID = 0;
14293 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
14294 } while(0) ;
14295 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
14296 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14297 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14298 pWdaParams->pWdaContext = pWDA;
14299 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
14300 pWdaParams->wdaMsgParam = NULL;
14301 status = WDI_TriggerBAReq(wdiTriggerBaReq,
14302 WDA_TriggerBaReqCallback, pWdaParams) ;
14303 if(IS_WDI_STATUS_FAILURE(status))
14304 {
14305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14306 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
14307 vos_mem_free(pWdaParams->wdaMsgParam) ;
14308 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14309 vos_mem_free(pWdaParams) ;
14310 }
14311 }
14312 else
14313 {
14314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14315 "There is no TID for initiating BA");
14316 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14317 if( VOS_STATUS_SUCCESS !=
14318 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14319 {
14320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14321 "BA Activity Timer Stop Failed ");
14322 return ;
14323 }
14324 if( VOS_STATUS_SUCCESS !=
14325 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14326 {
14327 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14328 "BA Activity Timer Start Failed ");
14329 return;
14330 }
14331 return ;
14332}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14333/*
14334 * WDA common routine to create timer used by WDA.
14335 */
14336static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
14337{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14338 VOS_STATUS status = VOS_STATUS_SUCCESS ;
14339 tANI_U32 val = 0 ;
14340 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14341
14342 if(NULL == pMac)
14343 {
14344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14345 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14346 VOS_ASSERT(0);
14347 return VOS_STATUS_E_FAILURE;
14348 }
14349 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
14350 != eSIR_SUCCESS)
14351 {
14352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14353 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
14354 return VOS_STATUS_E_FAILURE;
14355 }
14356 val = SYS_MS_TO_TICKS(val) ;
14357
14358 /* BA activity check timer */
14359 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
14360 "BA Activity Check timer", WDA_TimerHandler,
14361 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
14362 if(status != TX_SUCCESS)
14363 {
14364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14365 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14366 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14367 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14368 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14369 /* Tx Complete Timeout timer */
14370 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
14371 "Tx Complete Check timer", WDA_TimerHandler,
14372 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14373 if(status != TX_SUCCESS)
14374 {
14375 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14376 "Unable to create Tx Complete Timeout timer");
14377 /* Destroy timer of BA activity check timer */
14378 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14379 if(status != TX_SUCCESS)
14380 {
14381 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14382 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14383 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14384 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14385 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14386 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14387
14388 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
14389
14390 /* Traffic Stats timer */
14391 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
14392 "Traffic Stats timer", WDA_TimerHandler,
14393 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
14394 if(status != TX_SUCCESS)
14395 {
14396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14397 "Unable to create traffic stats timer");
14398 /* Destroy timer of BA activity check timer */
14399 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14400 if(status != TX_SUCCESS)
14401 {
14402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14403 "Unable to Destroy BA activity timer");
14404 }
14405 /* Destroy timer of tx complete timer */
14406 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14407 if(status != TX_SUCCESS)
14408 {
14409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14410 "Unable to Tx complete timer");
14411 }
14412 return VOS_STATUS_E_FAILURE ;
14413 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14414 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14415}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14416/*
14417 * WDA common routine to destroy timer used by WDA.
14418 */
14419static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
14420{
14421 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14422 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14423 if(status != TX_SUCCESS)
14424 {
14425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14426 "Unable to Destroy Tx Complete Timeout timer");
14427 return eSIR_FAILURE ;
14428 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14429 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14430 if(status != TX_SUCCESS)
14431 {
14432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14433 "Unable to Destroy BA activity timer");
14434 return eSIR_FAILURE ;
14435 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14436 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
14437 if(status != TX_SUCCESS)
14438 {
14439 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14440 "Unable to Destroy traffic stats timer");
14441 return eSIR_FAILURE ;
14442 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14443 return eSIR_SUCCESS ;
14444}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14445/*
14446 * WDA timer handler.
14447 */
14448void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
14449{
14450 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
14451 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14452 /*
14453 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
14454 */
14455 wdaMsg.type = timerInfo ;
14456 wdaMsg.bodyptr = NULL;
14457 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14458 /* post the message.. */
14459 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
14460 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
14461 {
14462 vosStatus = VOS_STATUS_E_BADMSG;
14463 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14464}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14465/*
14466 * WDA Tx Complete timeout Indication.
14467 */
14468void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
14469{
14470 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14471 if( pWDA->pAckTxCbFunc )
14472 {
14473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14474 "TxComplete timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14475 pWDA->pAckTxCbFunc( pMac, 0);
14476 pWDA->pAckTxCbFunc = NULL;
14477 }
14478 else
14479 {
14480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14481 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14482 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14483}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14484/*
14485 * WDA Set REG Domain to VOS NV
14486 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14487eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
14488 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14489{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14490 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14491 {
14492 return eHAL_STATUS_INVALID_PARAMETER;
14493 }
14494 return eHAL_STATUS_SUCCESS;
14495}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14496
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14497#ifdef FEATURE_WLAN_SCAN_PNO
14498/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14499 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14500 *
14501 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14502void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14503{
14504 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14505 tSirPNOScanReq *pPNOScanReqParams;
14506
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14507 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14508 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14509 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14510 {
14511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14512 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14513 VOS_ASSERT(0) ;
14514 return ;
14515 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14516
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14517 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14518 if(pPNOScanReqParams->statusCallback)
14519 {
14520 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14521 (status == WDI_STATUS_SUCCESS) ?
14522 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
14523 }
14524
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14525 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14526 vos_mem_free(pWdaParams->wdaMsgParam);
14527 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14528
14529 return ;
14530}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14531/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14532 * FUNCTION: WDA_PNOScanReqCallback
14533 * Free memory.
14534 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
14535 */
14536void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14537{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14538 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14539 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14540
14541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14542 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14543
14544 if(NULL == pWdaParams)
14545 {
14546 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14547 "%s: pWdaParams received NULL", __func__);
14548 VOS_ASSERT(0);
14549 return;
14550 }
14551
14552 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14553 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14554 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14555 if(pPNOScanReqParams->statusCallback)
14556 {
14557 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14558 VOS_STATUS_E_FAILURE);
14559 }
14560
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14561 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14562 vos_mem_free(pWdaParams->wdaMsgParam);
14563 vos_mem_free(pWdaParams);
14564 }
14565
14566 return;
14567}
14568/*
14569 * FUNCTION: WDA_UpdateScanParamsRespCallback
14570 *
14571 */
14572void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
14573{
14574 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14576 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14577 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14578 {
14579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14580 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14581 VOS_ASSERT(0) ;
14582 return ;
14583 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14584
14585 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14586 vos_mem_free(pWdaParams->wdaMsgParam);
14587 vos_mem_free(pWdaParams);
14588
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14589 return ;
14590}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14591/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14592 * FUNCTION: WDA_UpdateScanParamsReqCallback
14593 * Free memory.
14594 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
14595 */
14596void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14597{
14598 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14599
14600 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14601 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14602
14603 if(NULL == pWdaParams)
14604 {
14605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14606 "%s: pWdaParams received NULL", __func__);
14607 VOS_ASSERT(0);
14608 return;
14609 }
14610
14611 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14612 {
14613 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14614 vos_mem_free(pWdaParams->wdaMsgParam);
14615 vos_mem_free(pWdaParams);
14616 }
14617
14618 return;
14619}
14620/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14621 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14622 * Request to WDI to set Preferred Network List.Offload
14623 */
14624VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
14625 tSirPNOScanReq *pPNOScanReqParams)
14626{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14627 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14628 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
14629 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
14630 tWDA_ReqParams *pWdaParams ;
14631 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14633 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14634 if(NULL == pwdiPNOScanReqInfo)
14635 {
14636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14637 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14638 VOS_ASSERT(0);
14639 return VOS_STATUS_E_NOMEM;
14640 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14641 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14642 if(NULL == pWdaParams)
14643 {
14644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14645 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14646 VOS_ASSERT(0);
14647 vos_mem_free(pwdiPNOScanReqInfo);
14648 return VOS_STATUS_E_NOMEM;
14649 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14650 //
14651 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
14652 //
14653 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
14654 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14655 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
14656 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
14657 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14658 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
14659 {
14660 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
14661 &pPNOScanReqParams->aNetworks[i],
14662 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
14663 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14664 /*Scan timer intervals*/
14665 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
14666 &pPNOScanReqParams->scanTimers,
14667 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14668 /*Probe template for 2.4GHz band*/
14669 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
14670 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14671 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14672 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
14673 pPNOScanReqParams->p24GProbeTemplate,
14674 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14675 /*Probe template for 5GHz band*/
14676 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
14677 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14678 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14679 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
14680 pPNOScanReqParams->p5GProbeTemplate,
14681 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14682 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
14683 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14684
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14685 /* Store Params pass it to WDI */
14686 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
14687 pWdaParams->pWdaContext = pWDA;
14688 /* Store param pointer as passed in by caller */
14689 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14690 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14691 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14692 if(IS_WDI_STATUS_FAILURE(status))
14693 {
14694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14695 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14696 if(pPNOScanReqParams->statusCallback)
14697 {
14698 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14699 VOS_STATUS_E_FAILURE);
14700 }
14701
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14702 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14703 vos_mem_free(pWdaParams->wdaMsgParam);
14704 pWdaParams->wdaWdiApiMsgParam = NULL;
14705 pWdaParams->wdaMsgParam = NULL;
14706 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14707 return CONVERT_WDI2VOS_STATUS(status) ;
14708}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14709
14710#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14711
14712void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
14713{
14714 /*Convert the CSR Auth types to WDI Auth types */
14715 switch (csrAuthType)
14716 {
14717 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
14718 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14719 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14720#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14721 case eCSR_AUTH_TYPE_CCKM_WPA:
14722 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
14723 break;
14724#endif
14725 case eCSR_AUTH_TYPE_WPA:
14726 *AuthType = eWDA_AUTH_TYPE_WPA;
14727 break;
14728 case eCSR_AUTH_TYPE_WPA_PSK:
14729 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
14730 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14731#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14732 case eCSR_AUTH_TYPE_CCKM_RSN:
14733 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
14734 break;
14735#endif
14736 case eCSR_AUTH_TYPE_RSN:
14737 *AuthType = eWDA_AUTH_TYPE_RSN;
14738 break;
14739 case eCSR_AUTH_TYPE_RSN_PSK:
14740 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
14741 break;
14742#if defined WLAN_FEATURE_VOWIFI_11R
14743 case eCSR_AUTH_TYPE_FT_RSN:
14744 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
14745 break;
14746 case eCSR_AUTH_TYPE_FT_RSN_PSK:
14747 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
14748 break;
14749#endif
14750#ifdef FEATURE_WLAN_WAPI
14751 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
14752 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
14753 break;
14754 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
14755 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
14756 break;
14757#endif /* FEATURE_WLAN_WAPI */
14758 case eCSR_AUTH_TYPE_SHARED_KEY:
14759 case eCSR_AUTH_TYPE_AUTOSWITCH:
14760 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14761 break;
14762#if 0
14763 case eCSR_AUTH_TYPE_SHARED_KEY:
14764 *AuthType = eWDA_AUTH_TYPE_SHARED_KEY;
14765 break;
14766 case eCSR_AUTH_TYPE_AUTOSWITCH:
14767 *AuthType = eWDA_AUTH_TYPE_AUTOSWITCH;
14768#endif
14769 default:
14770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14771 "%s: Unknown Auth Type", __func__);
14772 break;
14773 }
14774}
14775void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
14776{
14777 switch (csrEncrType)
14778 {
14779 case eCSR_ENCRYPT_TYPE_NONE:
14780 *EncrType = WDI_ED_NONE;
14781 break;
14782 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
14783 case eCSR_ENCRYPT_TYPE_WEP40:
14784 *EncrType = WDI_ED_WEP40;
14785 break;
14786 case eCSR_ENCRYPT_TYPE_WEP104:
14787 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
14788 *EncrType = WDI_ED_WEP104;
14789 break;
14790 case eCSR_ENCRYPT_TYPE_TKIP:
14791 *EncrType = WDI_ED_TKIP;
14792 break;
14793 case eCSR_ENCRYPT_TYPE_AES:
14794 *EncrType = WDI_ED_CCMP;
14795 break;
14796#ifdef WLAN_FEATURE_11W
14797 case eCSR_ENCRYPT_TYPE_AES_CMAC:
14798 *EncrType = WDI_ED_AES_128_CMAC;
14799 break;
14800#endif
14801#ifdef FEATURE_WLAN_WAPI
14802 case eCSR_ENCRYPT_TYPE_WPI:
14803 *EncrType = WDI_ED_WPI;
14804 break;
14805#endif
14806 case eCSR_ENCRYPT_TYPE_ANY:
14807 *EncrType = WDI_ED_ANY;
14808 break;
14809
14810 default:
14811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14812 "%s: Unknown Encryption Type", __func__);
14813 break;
14814 }
14815}
14816
14817/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14818 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14819 * Request to WDI to set Roam Offload Scan
14820 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14821VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14822 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
14823{
14824 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14825 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
14826 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14827 tWDA_ReqParams *pWdaParams ;
14828 v_U8_t csrAuthType;
14829 WDI_RoamNetworkType *pwdiRoamNetworkType;
14830 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
14831 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14832 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14833 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14834 {
14835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14836 "%s: VOS MEM Alloc Failure", __func__);
14837 VOS_ASSERT(0);
14838 return VOS_STATUS_E_NOMEM;
14839 }
14840 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14841 if (NULL == pWdaParams)
14842 {
14843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14844 "%s: VOS MEM Alloc Failure", __func__);
14845 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14846 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14847 return VOS_STATUS_E_NOMEM;
14848 }
14849
14850 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14851 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14852 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14853 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
14854 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14855 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
14856 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
14857 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
14858 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
14859 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
14860 sizeof(pwdiRoamNetworkType->currAPbssid));
14861 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
14862 csrAuthType);
14863 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
14864 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
14865 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
14866 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
14867 pwdiRoamOffloadScanInfo->LookupThreshold =
14868 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]14869 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
14870 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14871 pwdiRoamOffloadScanInfo->RoamRssiDiff =
14872 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]14873 pwdiRoamOffloadScanInfo->MAWCEnabled =
14874 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14875 pwdiRoamOffloadScanInfo->Command =
14876 pRoamOffloadScanReqParams->Command ;
14877 pwdiRoamOffloadScanInfo->StartScanReason =
14878 pRoamOffloadScanReqParams->StartScanReason ;
14879 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
14880 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
14881 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
14882 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
14883 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
14884 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
14885 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
14886 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
14887 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
14888 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14889 pwdiRoamOffloadScanInfo->IsESEEnabled =
14890 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14891 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
14892 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
14893 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
14894 pwdiRoamNetworkType->ssId.ucLength =
14895 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
14896 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
14897 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
14898 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
14899 pwdiRoamNetworkType->ChannelCount =
14900 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
14901 pwdiRoamOffloadScanInfo->ChannelCacheType =
14902 pRoamOffloadScanReqParams->ChannelCacheType;
14903 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
14904 pRoamOffloadScanReqParams->ValidChannelList,
14905 pRoamOffloadScanReqParams->ValidChannelCount);
14906 pwdiRoamOffloadScanInfo->ValidChannelCount =
14907 pRoamOffloadScanReqParams->ValidChannelCount;
14908 pwdiRoamOffloadScanInfo->us24GProbeSize =
14909 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14910 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14911 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
14912 pRoamOffloadScanReqParams->p24GProbeTemplate,
14913 pwdiRoamOffloadScanInfo->us24GProbeSize);
14914 pwdiRoamOffloadScanInfo->us5GProbeSize =
14915 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14916 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14917 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
14918 pRoamOffloadScanReqParams->p5GProbeTemplate,
14919 pwdiRoamOffloadScanInfo->us5GProbeSize);
14920 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
14921 pRoamOffloadScanReqParams->MDID.mdiePresent;
14922 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
14923 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14924 pwdiRoamOffloadScanInfo->nProbes =
14925 pRoamOffloadScanReqParams->nProbes;
14926 pwdiRoamOffloadScanInfo->HomeAwayTime =
14927 pRoamOffloadScanReqParams->HomeAwayTime;
14928 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14929 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14930 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14931 pWdaParams->pWdaContext = pWDA;
14932 /* Store param pointer as passed in by caller */
14933 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14934 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14935 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
14936 if(IS_WDI_STATUS_FAILURE(status))
14937 {
14938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14939 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
14940 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14941 vos_mem_free(pWdaParams->wdaMsgParam);
14942 pWdaParams->wdaWdiApiMsgParam = NULL;
14943 pWdaParams->wdaMsgParam = NULL;
14944 }
14945 return CONVERT_WDI2VOS_STATUS(status) ;
14946}
14947#endif
14948
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14949/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14950 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14951 *
14952 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14953void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14954{
14955 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14956
14957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14958 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14959
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14960 if(NULL == pWdaParams)
14961 {
14962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14963 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14964 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14965 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14966 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14967
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14968 vos_mem_free(pWdaParams->wdaMsgParam) ;
14969 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14970 vos_mem_free(pWdaParams) ;
14971
14972 return ;
14973}
14974/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14975 * FUNCTION: WDA_RssiFilterReqCallback
14976 * Free memory.
14977 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
14978 */
14979void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
14980{
14981 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14982
14983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14984 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14985
14986 if(NULL == pWdaParams)
14987 {
14988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14989 "%s: pWdaParams received NULL", __func__);
14990 VOS_ASSERT(0);
14991 return;
14992 }
14993
14994 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14995 {
14996 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14997 vos_mem_free(pWdaParams->wdaMsgParam);
14998 vos_mem_free(pWdaParams);
14999 }
15000
15001 return;
15002}
15003/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15004 * FUNCTION: WDA_ProcessSetPreferredNetworkList
15005 * Request to WDI to set Preferred Network List.Offload
15006 */
15007VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
15008 tSirSetRSSIFilterReq* pRssiFilterParams)
15009{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15010 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15011 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
15012 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
15013 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15015 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15016 if(NULL == pwdiSetRssiFilterReqInfo)
15017 {
15018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15019 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15020 VOS_ASSERT(0);
15021 return VOS_STATUS_E_NOMEM;
15022 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15023 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15024 if(NULL == pWdaParams)
15025 {
15026 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15027 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15028 VOS_ASSERT(0);
15029 vos_mem_free(pwdiSetRssiFilterReqInfo);
15030 return VOS_STATUS_E_NOMEM;
15031 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15032 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15033 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
15034 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15035
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15036 /* Store Params pass it to WDI */
15037 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
15038 pWdaParams->pWdaContext = pWDA;
15039 /* Store param pointer as passed in by caller */
15040 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15041 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15042 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15043 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15044 if(IS_WDI_STATUS_FAILURE(status))
15045 {
15046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15047 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
15048 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15049 vos_mem_free(pWdaParams->wdaMsgParam);
15050 pWdaParams->wdaWdiApiMsgParam = NULL;
15051 pWdaParams->wdaMsgParam = NULL;
15052 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15053 return CONVERT_WDI2VOS_STATUS(status) ;
15054}
15055
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15056/*
15057 * FUNCTION: WDA_ProcessUpdateScanParams
15058 * Request to WDI to update Scan Parameters
15059 */
15060VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
15061 tSirUpdateScanParams *pUpdateScanParams)
15062{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15063 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15064 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
15065 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
15066 sizeof(WDI_UpdateScanParamsInfoType)) ;
15067 tWDA_ReqParams *pWdaParams ;
15068 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15069 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15070 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15071 if(NULL == wdiUpdateScanParamsInfoType)
15072 {
15073 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15074 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15075 VOS_ASSERT(0);
15076 return VOS_STATUS_E_NOMEM;
15077 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15078 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15079 if ( NULL == pWdaParams )
15080 {
15081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15082 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15083 VOS_ASSERT(0);
15084 vos_mem_free(wdiUpdateScanParamsInfoType);
15085 return VOS_STATUS_E_NOMEM;
15086 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15087 //
15088 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
15089 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15091 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
15092 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
15093 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]15094 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15095 pUpdateScanParams->b11dEnabled,
15096 pUpdateScanParams->b11dResolved,
15097 pUpdateScanParams->ucChannelCount,
15098 pUpdateScanParams->usPassiveMinChTime,
15099 pUpdateScanParams->usPassiveMaxChTime,
15100 pUpdateScanParams->usActiveMinChTime,
15101 pUpdateScanParams->usActiveMaxChTime,
15102 sizeof(tSirUpdateScanParams),
15103 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
15104
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15105 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
15106 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15107 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
15108 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15109 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
15110 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15111 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
15112 pUpdateScanParams->usActiveMaxChTime;
15113 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
15114 pUpdateScanParams->usActiveMinChTime;
15115 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
15116 pUpdateScanParams->usPassiveMaxChTime;
15117 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
15118 pUpdateScanParams->usPassiveMinChTime;
15119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15120 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]15121 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
15122 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15123
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15124 for ( i = 0; i <
15125 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
15126 i++)
15127 {
15128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15129 "Update Scan Parameters channel: %d",
15130 pUpdateScanParams->aChannels[i]);
15131
15132 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
15133 pUpdateScanParams->aChannels[i];
15134 }
15135
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15136 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
15137 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15138
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15139 /* Store Params pass it to WDI */
15140 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
15141 pWdaParams->pWdaContext = pWDA;
15142 /* Store param pointer as passed in by caller */
15143 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15144
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15145
15146
15147 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15148 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15149 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15150 if(IS_WDI_STATUS_FAILURE(status))
15151 {
15152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15153 "Failure in Update Scan Params EQ WDI API, free all the memory " );
15154 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15155 vos_mem_free(pWdaParams->wdaMsgParam);
15156 vos_mem_free(pWdaParams);
15157 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15158 return CONVERT_WDI2VOS_STATUS(status) ;
15159}
15160#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15161
15162#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
15163/*
15164 * FUNCTION: WDA_RoamOffloadScanReqCallback
15165 *
15166 */
15167void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
15168{
15169 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15170 vos_msg_t vosMsg;
15171 wpt_uint8 reason = 0;
15172
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]15173 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15174 "<------ %s " ,__func__);
15175 if (NULL == pWdaParams)
15176 {
15177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15178 "%s: pWdaParams received NULL", __func__);
15179 VOS_ASSERT(0) ;
15180 return ;
15181 }
15182 if ( pWdaParams != NULL )
15183 {
15184 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
15185 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15186 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15187 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15188 }
15189 if ( pWdaParams->wdaMsgParam != NULL)
15190 {
15191 vos_mem_free(pWdaParams->wdaMsgParam);
15192 }
15193
15194 vos_mem_free(pWdaParams) ;
15195 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15196 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
15197 vosMsg.bodyptr = NULL;
15198 if (WDI_STATUS_SUCCESS != status)
15199 {
15200 reason = 0;
15201 }
15202 vosMsg.bodyval = reason;
15203 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15204 {
15205 /* free the mem and return */
15206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]15207 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15208 }
15209
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15210 return ;
15211}
15212#endif
15213
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15214/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15215 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15216 *
15217 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15218void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15219{
15220 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15221
15222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15223 "<------ %s " ,__func__);
15224
15225 if(NULL == pWdaParams)
15226 {
15227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15228 "%s: pWdaParams received NULL", __func__);
15229 VOS_ASSERT(0);
15230 return;
15231 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15232
15233 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15234 vos_mem_free(pWdaParams->wdaMsgParam);
15235 vos_mem_free(pWdaParams);
15236
15237 return;
15238}
15239/*
15240 * FUNCTION: WDA_SetPowerParamsReqCallback
15241 * Free memory.
15242 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
15243 */
15244void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
15245{
15246 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15247
15248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15249 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15250
15251 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15252 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15254 "%s: pWdaParams received NULL", __func__);
15255 VOS_ASSERT(0);
15256 return;
15257 }
15258
15259 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15260 {
15261 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15262 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15263 vos_mem_free(pWdaParams);
15264 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15265
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15266 return;
15267}
15268
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15269#ifdef WLAN_FEATURE_PACKET_FILTERING
15270/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15271 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15272 *
15273 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15274void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15275 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
15276 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15277{
15278 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15279 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15280 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15281 if(NULL == pWdaParams)
15282 {
15283 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15284 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15285 VOS_ASSERT(0) ;
15286 return ;
15287 }
15288
15289 vos_mem_free(pWdaParams->wdaMsgParam) ;
15290 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15291 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15292 //print a msg, nothing else to do
15293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15294 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15295 return ;
15296}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15297/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15298 * FUNCTION: WDA_8023MulticastListReqCallback
15299 * Free memory.
15300 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
15301 */
15302void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
15303{
15304 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15305
15306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15307 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15308
15309 if(NULL == pWdaParams)
15310 {
15311 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15312 "%s: pWdaParams received NULL", __func__);
15313 VOS_ASSERT(0);
15314 return;
15315 }
15316
15317 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15318 {
15319 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15320 vos_mem_free(pWdaParams->wdaMsgParam);
15321 vos_mem_free(pWdaParams);
15322 }
15323
15324 return;
15325}
15326/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15327 * FUNCTION: WDA_Process8023MulticastListReq
15328 * Request to WDI to add 8023 Multicast List
15329 */
15330VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
15331 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
15332{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15333 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15334 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
15335 tWDA_ReqParams *pWdaParams ;
15336 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15337 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15338 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15339 pwdiFltPktSetMcListReqParamsType =
15340 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
15341 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
15342 ) ;
15343 if(NULL == pwdiFltPktSetMcListReqParamsType)
15344 {
15345 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15346 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15347 return VOS_STATUS_E_NOMEM;
15348 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15349 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15350 if(NULL == pWdaParams)
15351 {
15352 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15353 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15354 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
15355 return VOS_STATUS_E_NOMEM;
15356 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15357
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15358 //
15359 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
15360 //
15361 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15362 pRcvFltMcAddrList->ulMulticastAddrCnt;
15363
15364 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
15365 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
15366 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
15367 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
15368
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15369 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
15370 {
15371 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
15372 &(pRcvFltMcAddrList->multicastAddr[i]),
15373 sizeof(tSirMacAddr));
15374 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15375 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
15376 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15377
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15378 /* Store Params pass it to WDI */
15379 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
15380 pWdaParams->pWdaContext = pWDA;
15381 /* Store param pointer as passed in by caller */
15382 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15383 status = WDI_8023MulticastListReq(
15384 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15385 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15386 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15387 if(IS_WDI_STATUS_FAILURE(status))
15388 {
15389 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15390 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
15391 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15392 vos_mem_free(pWdaParams->wdaMsgParam);
15393 vos_mem_free(pWdaParams);
15394 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15395 return CONVERT_WDI2VOS_STATUS(status) ;
15396}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15397/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15398 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15399 *
15400 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15401void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15402 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
15403 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15404{
15405 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15406 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15407 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15408 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15409 if(NULL == pWdaParams)
15410 {
15411 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15412 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15413 VOS_ASSERT(0) ;
15414 return ;
15415 }
15416
15417 vos_mem_free(pWdaParams->wdaMsgParam) ;
15418 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15419 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15420 //print a msg, nothing else to do
15421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15422 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15423 return ;
15424}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15425
15426/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15427 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
15428 * Free memory.
15429 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15430 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15431void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15432 void* pUserData)
15433{
15434 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15435
15436 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15437 "<------ %s, wdiStatus: %d",
15438 __func__, wdiStatus);
15439
15440 if (NULL == pWdaParams)
15441 {
15442 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15443 "%s: Invalid pWdaParams pointer", __func__);
15444 VOS_ASSERT(0);
15445 return;
15446 }
15447
15448 if (IS_WDI_STATUS_FAILURE(wdiStatus))
15449 {
15450 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15451 vos_mem_free(pWdaParams->wdaMsgParam);
15452 vos_mem_free(pWdaParams);
15453 }
15454
15455 return;
15456}
15457
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15458/*
15459 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
15460 * Request to WDI to set Receive Filters
15461 */
15462VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
15463 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
15464{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15465 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15466 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
15467 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
15468 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
15469 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
15470 tWDA_ReqParams *pWdaParams ;
15471 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15473 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15474 if(NULL == pwdiSetRcvPktFilterReqParamsType)
15475 {
15476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15477 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15478 VOS_ASSERT(0);
15479 return VOS_STATUS_E_NOMEM;
15480 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15481 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15482 if(NULL == pWdaParams)
15483 {
15484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15485 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15486 VOS_ASSERT(0);
15487 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
15488 return VOS_STATUS_E_NOMEM;
15489 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15490 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
15491 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
15492 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
15493 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15494 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
15495 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
15496
15497 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
15498 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15499
15500 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15501 "FID %d FT %d NParams %d CT %d",
15502 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
15503 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
15504 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
15505 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15506 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
15507 {
15508 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
15509 &pRcvPktFilterCfg->paramsData[i],
15510 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15512 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15513 pwdiSetRcvPktFilterReqParamsType->
15514 wdiPktFilterCfg.paramsData[i].protocolLayer,
15515 pwdiSetRcvPktFilterReqParamsType->
15516 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15518 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15519 pwdiSetRcvPktFilterReqParamsType->
15520 wdiPktFilterCfg.paramsData[i].dataOffset,
15521 pwdiSetRcvPktFilterReqParamsType->
15522 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15523 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15524 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15525 pwdiSetRcvPktFilterReqParamsType->
15526 wdiPktFilterCfg.paramsData[i].compareData[0],
15527 pwdiSetRcvPktFilterReqParamsType->
15528 wdiPktFilterCfg.paramsData[i].compareData[1],
15529 pwdiSetRcvPktFilterReqParamsType->
15530 wdiPktFilterCfg.paramsData[i].compareData[2],
15531 pwdiSetRcvPktFilterReqParamsType->
15532 wdiPktFilterCfg.paramsData[i].compareData[3],
15533 pwdiSetRcvPktFilterReqParamsType->
15534 wdiPktFilterCfg.paramsData[i].compareData[4],
15535 pwdiSetRcvPktFilterReqParamsType->
15536 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15538 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15539 pwdiSetRcvPktFilterReqParamsType->
15540 wdiPktFilterCfg.paramsData[i].dataMask[0],
15541 pwdiSetRcvPktFilterReqParamsType->
15542 wdiPktFilterCfg.paramsData[i].dataMask[1],
15543 pwdiSetRcvPktFilterReqParamsType->
15544 wdiPktFilterCfg.paramsData[i].dataMask[2],
15545 pwdiSetRcvPktFilterReqParamsType->
15546 wdiPktFilterCfg.paramsData[i].dataMask[3],
15547 pwdiSetRcvPktFilterReqParamsType->
15548 wdiPktFilterCfg.paramsData[i].dataMask[4],
15549 pwdiSetRcvPktFilterReqParamsType->
15550 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15551 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15552 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15553 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15554 /* Store Params pass it to WDI */
15555 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
15556 pWdaParams->pWdaContext = pWDA;
15557 /* Store param pointer as passed in by caller */
15558 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15559 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15560 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15561 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15562 if(IS_WDI_STATUS_FAILURE(status))
15563 {
15564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15565 "Failure in SetFilter(),free all the memory,status %d ",status);
15566 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15567 vos_mem_free(pWdaParams->wdaMsgParam);
15568 vos_mem_free(pWdaParams);
15569 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15570 return CONVERT_WDI2VOS_STATUS(status) ;
15571}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15572/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15573 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15574 *
15575 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15576void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15577 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
15578 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15579{
15580 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15581 tWDA_CbContext *pWDA;
15582 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
15583 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
15584 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
15585 tANI_U8 i;
15586 vos_msg_t vosMsg;
15587
15588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15589 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15590 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
15591
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15592 if(NULL == pRcvFltPktMatchCntRsp)
15593 {
15594 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15595 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15596 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15597 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15598 return ;
15599 }
15600
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15601 if(NULL == pWdaParams)
15602 {
15603 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15604 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15605 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15606 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15607 return ;
15608 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15609 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
15610 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15611 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
15612 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
15613
15614 /* Message Header */
15615 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15616 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
15617
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15618 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15619
15620 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
15621 {
15622 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
15623 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
15624 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15625 /* VOS message wrapper */
15626 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15627 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
15628 vosMsg.bodyval = 0;
15629 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15630 {
15631 /* free the mem and return */
15632 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
15633 }
15634
15635 vos_mem_free(pWdaParams->wdaMsgParam) ;
15636 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15637 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15638
15639 return;
15640}
15641/*
15642 * FUNCTION: WDA_FilterMatchCountReqCallback
15643 * Free memory and send RSP back to SME.
15644 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
15645 */
15646void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
15647{
15648 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15649 vos_msg_t vosMsg;
15650
15651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15652 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15653
15654 if(NULL == pWdaParams)
15655 {
15656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15657 "%s: pWdaParams received NULL", __func__);
15658 VOS_ASSERT(0);
15659 return;
15660 }
15661
15662 /* VOS message wrapper */
15663 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15664 vosMsg.bodyptr = NULL;
15665 vosMsg.bodyval = 0;
15666
15667 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15668 {
15669 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15670 vos_mem_free(pWdaParams->wdaMsgParam);
15671 vos_mem_free(pWdaParams);
15672 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
15673 }
15674
15675 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15676}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15677/*
15678 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
15679 * Request to WDI to get PC Filter Match Count
15680 */
15681VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
15682{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15683 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15684 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
15685 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
15686 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15688 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15689 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
15690 {
15691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15692 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15693 VOS_ASSERT(0);
15694 return VOS_STATUS_E_NOMEM;
15695 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15696 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
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: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15701 VOS_ASSERT(0);
15702 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
15703 return VOS_STATUS_E_NOMEM;
15704 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15705
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15706 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
15707 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15708
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15709 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
15710 pRcvFltPktMatchRsp->bssId,
15711 sizeof(wpt_macAddr));
15712
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15713 /* Store Params pass it to WDI */
15714 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
15715 pWdaParams->pWdaContext = pWDA;
15716 /* Store param pointer as passed in by caller */
15717 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15718 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15719 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15720 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15721 if(IS_WDI_STATUS_FAILURE(status))
15722 {
15723 /* failure returned by WDI API */
15724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15725 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
15726 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15727 vos_mem_free(pWdaParams) ;
15728 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
15729 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
15730 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15731 return CONVERT_WDI2VOS_STATUS(status) ;
15732}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15733/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15734 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15735 *
15736 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15737void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15738 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
15739 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15740{
15741 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15743 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15744/* WDA_VOS_ASSERT(NULL != pWdaParams); */
15745 if(NULL == pWdaParams)
15746 {
15747 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15748 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15749 VOS_ASSERT(0) ;
15750 return ;
15751 }
15752
15753 vos_mem_free(pWdaParams->wdaMsgParam) ;
15754 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15755 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15756 //print a msg, nothing else to do
15757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15758 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15759 return ;
15760}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15761/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15762 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
15763 * Free memory.
15764 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
15765 */
15766void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15767{
15768 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15769
15770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15771 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15772
15773 if(NULL == pWdaParams)
15774 {
15775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15776 "%s: Invalid pWdaParams pointer", __func__);
15777 VOS_ASSERT(0);
15778 return;
15779 }
15780
15781 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15782 {
15783 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15784 vos_mem_free(pWdaParams->wdaMsgParam);
15785 vos_mem_free(pWdaParams);
15786 }
15787
15788 return;
15789}
15790/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15791 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
15792 * Request to WDI to clear Receive Filters
15793 */
15794VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
15795 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
15796{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15797 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15798 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
15799 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
15800 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15802 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15803 if(NULL == pwdiRcvFltPktClearReqParamsType)
15804 {
15805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15806 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15807 VOS_ASSERT(0);
15808 return VOS_STATUS_E_NOMEM;
15809 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15810 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15811 if(NULL == pWdaParams)
15812 {
15813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15814 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15815 VOS_ASSERT(0);
15816 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
15817 return VOS_STATUS_E_NOMEM;
15818 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15819 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
15820 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15821 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
15822 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
15823 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
15824 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15825
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15826 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15827 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15828 /* Store Params pass it to WDI */
15829 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
15830 pWdaParams->pWdaContext = pWDA;
15831 /* Store param pointer as passed in by caller */
15832 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15833 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15834 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15835 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15836 if(IS_WDI_STATUS_FAILURE(status))
15837 {
15838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15839 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
15840 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]15841 vos_mem_free(pWdaParams->wdaMsgParam);
15842 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15843 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15844 return CONVERT_WDI2VOS_STATUS(status) ;
15845}
15846#endif // WLAN_FEATURE_PACKET_FILTERING
15847
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15848/*
15849 * FUNCTION: WDA_ProcessSetPowerParamsReq
15850 * Request to WDI to set power params
15851 */
15852VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
15853 tSirSetPowerParamsReq *pPowerParams)
15854{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15855 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15856 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
15857 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15858 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15860 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15861 if(NULL == pwdiSetPowerParamsReqInfo)
15862 {
15863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15864 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15865 VOS_ASSERT(0);
15866 return VOS_STATUS_E_NOMEM;
15867 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15868 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15869 if(NULL == pWdaParams)
15870 {
15871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15872 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15873 VOS_ASSERT(0);
15874 vos_mem_free(pwdiSetPowerParamsReqInfo);
15875 return VOS_STATUS_E_NOMEM;
15876 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15877
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15878
15879 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
15880 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15881 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
15882 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15883 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
15884 pPowerParams->uListenInterval;
15885 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
15886 pPowerParams->uBcastMcastFilter;
15887 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
15888 pPowerParams->uEnableBET;
15889 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
15890 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]15891 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
15892 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15893 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
15894 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15895
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15896 /* Store Params pass it to WDI */
15897 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
15898 pWdaParams->pWdaContext = pWDA;
15899 /* Store param pointer as passed in by caller */
15900 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15901 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15902 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15903 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15904 if(IS_WDI_STATUS_FAILURE(status))
15905 {
15906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15907 "Failure in Set power params REQ WDI API, free all the memory " );
15908 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15909 vos_mem_free(pWdaParams->wdaMsgParam);
15910 pWdaParams->wdaWdiApiMsgParam = NULL;
15911 pWdaParams->wdaMsgParam = NULL;
15912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15913 return CONVERT_WDI2VOS_STATUS(status) ;
15914}
15915
15916/*
15917 * FUNCTION: WDA_SetTmLevelRspCallback
15918 * Set TM Level response
15919 */
15920void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
15921{
15922 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15923
15924 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15925 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15926
15927 if(NULL == pWdaParams)
15928 {
15929 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15930 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15931 VOS_ASSERT(0) ;
15932 return ;
15933 }
15934
15935 /* Dose not need to send notification to upper layer
15936 * Just free allocated resources */
15937 if( pWdaParams != NULL )
15938 {
15939 if( pWdaParams->wdaWdiApiMsgParam != NULL )
15940 {
15941 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15942 }
15943 vos_mem_free(pWdaParams->wdaMsgParam) ;
15944 vos_mem_free(pWdaParams) ;
15945 }
15946}
15947
15948/*
15949 * FUNCTION: WDA_ProcessSetTmLevelReq
15950 * Set TM Level request
15951 */
15952VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
15953 tAniSetTmLevelReq *setTmLevelReq)
15954{
15955 WDI_Status status = WDI_STATUS_SUCCESS ;
15956 tWDA_ReqParams *pWdaParams ;
15957 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
15958 (WDI_SetTmLevelReqType *)vos_mem_malloc(
15959 sizeof(WDI_SetTmLevelReqType)) ;
15960 if(NULL == wdiSetTmLevelReq)
15961 {
15962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15963 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15964 VOS_ASSERT(0);
15965 return VOS_STATUS_E_NOMEM;
15966 }
15967
15968 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15969 if(NULL == pWdaParams)
15970 {
15971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15972 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15973 VOS_ASSERT(0);
15974 vos_mem_free(wdiSetTmLevelReq);
15975 return VOS_STATUS_E_NOMEM;
15976 }
15977
15978 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15979 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15980
15981 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
15982 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
15983
15984 pWdaParams->pWdaContext = pWDA;
15985 pWdaParams->wdaMsgParam = setTmLevelReq;
15986 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
15987
15988 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
15989 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
15990
15991 if(IS_WDI_STATUS_FAILURE(status))
15992 {
15993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]15994 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15995 vos_mem_free(pWdaParams->wdaMsgParam) ;
15996 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15997 vos_mem_free(pWdaParams) ;
15998 }
15999
16000 return CONVERT_WDI2VOS_STATUS(status) ;
16001}
16002
16003VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
16004 tpTxControlParams pTxCtrlParam)
16005{
16006 VOS_STATUS wdaStatus;
16007
16008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16009 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16010 if( pTxCtrlParam == NULL )
16011 {
16012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16013 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16014 return VOS_STATUS_E_FAILURE;
16015 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16016 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
16017 {
16018 wdaStatus = WDA_SuspendDataTx(pWDA);
16019 }
16020 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
16021 {
16022 wdaStatus = WDA_ResumeDataTx(pWDA);
16023 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16024 return wdaStatus;
16025}
16026
16027 /* FUNCTION WDA_featureCapsExchange
16028 * WDA API to invoke capability exchange between host and FW.
16029 */
16030void WDA_featureCapsExchange(v_PVOID_t pVosContext)
16031{
16032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16033 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16034 WDI_featureCapsExchangeReq( NULL, pVosContext);
16035}
16036
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]16037/* FUNCTION WDA_disableCapablityFeature
16038 * WDA API to diable Active mode offload in host.
16039 */
16040void WDA_disableCapablityFeature(tANI_U8 feature_index)
16041{
16042 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16043 "%s:enter", __func__ );
16044 WDI_disableCapablityFeature(feature_index);
16045}
16046
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16047 /* FUNCTION WDA_getHostWlanFeatCaps
16048 * Wrapper for WDI API, that will return if the feature (enum value).passed
16049 * to this API is supported or not in Host
16050 * return value
16051 * 0 - implies feature is NOT Supported
16052 * any non zero value - implies feature is SUPPORTED
16053 */
16054tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
16055{
16056 return WDI_getHostWlanFeatCaps(featEnumValue);
16057}
16058
16059 /* FUNCTION WDA_getFwWlanFeatCaps
16060 * Wrapper for WDI API, that will return if the feature (enum value).passed
16061 * to this API is supported or not in FW
16062 * return value
16063 * 0 - implies feature is NOT Supported
16064 * any non zero value - implies feature is SUPPORTED
16065 */
16066tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
16067{
16068 return WDI_getFwWlanFeatCaps(featEnumValue);
16069}
16070
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]16071
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16072/*
16073 * FUNCTION: WDA_shutdown
16074 * Shutdown WDA/WDI without handshaking with Riva.
16075 * Synchronous function.
16076 */
16077VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
16078{
16079 WDI_Status wdiStatus;
16080 //tANI_U8 eventIdx = 0;
16081 VOS_STATUS status = VOS_STATUS_SUCCESS;
16082 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16083 if (NULL == pWDA)
16084 {
16085 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16086 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16087 VOS_ASSERT(0);
16088 return VOS_STATUS_E_FAILURE;
16089 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16090 /* FTM mode stay START_STATE */
16091 if( (WDA_READY_STATE != pWDA->wdaState) &&
16092 (WDA_INIT_STATE != pWDA->wdaState) &&
16093 (WDA_START_STATE != pWDA->wdaState) )
16094 {
16095 VOS_ASSERT(0);
16096 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16097
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16098 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
16099 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16100 {
16101 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16102 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16103 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]16104 else
16105 {
16106 vos_event_destroy(&pWDA->ftmStopDoneEvent);
16107 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16108
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16109 /* call WDI shutdown */
16110 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16111 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
16112 {
16113 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16114 "error in WDA Stop" );
16115 status = VOS_STATUS_E_FAILURE;
16116 }
16117 /* WDI stop is synchrnous, shutdown is complete when it returns */
16118 pWDA->wdaState = WDA_STOP_STATE;
16119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16120 /* shutdown should perform the stop & close actions. */
16121 /* Destroy the event */
16122 status = vos_event_destroy(&pWDA->txFrameEvent);
16123 if(!VOS_IS_STATUS_SUCCESS(status))
16124 {
16125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16126 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16127 status = VOS_STATUS_E_FAILURE;
16128 }
16129 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
16130 if(!VOS_IS_STATUS_SUCCESS(status))
16131 {
16132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16133 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16134 status = VOS_STATUS_E_FAILURE;
16135 }
16136 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
16137 if(!VOS_IS_STATUS_SUCCESS(status))
16138 {
16139 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16140 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16141 status = VOS_STATUS_E_FAILURE;
16142 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16143 /* free WDA context */
16144 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
16145 if ( !VOS_IS_STATUS_SUCCESS(status) )
16146 {
16147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16148 "error in WDA close " );
16149 status = VOS_STATUS_E_FAILURE;
16150 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16151 return status;
16152}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16153
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16154/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16155 * FUNCTION: WDA_setNeedShutdown
16156 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16157 */
16158
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16159void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16160{
16161 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16162 if(pWDA == NULL)
16163 {
16164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16165 "Could not get the WDA Context pointer" );
16166 return;
16167 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16168 pWDA->needShutdown = TRUE;
16169}
16170/*
16171 * FUNCTION: WDA_needShutdown
16172 * WDA needs a shutdown
16173 */
16174
16175v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
16176{
16177 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16178 if(pWDA == NULL)
16179 {
16180 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16181 "Could not get the WDA Context pointer" );
16182 return 0;
16183 }
16184 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16185}
16186
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16187#ifdef WLAN_FEATURE_11AC
16188/*
16189 * FUNCTION: WDA_SetBeaconFilterReqCallback
16190 *
16191 */
16192void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
16193{
16194 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16196 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16197 if(NULL == pWdaParams)
16198 {
16199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16200 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16201 VOS_ASSERT(0) ;
16202 return ;
16203 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16204
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16205 vos_mem_free(pWdaParams->wdaMsgParam) ;
16206 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16207 vos_mem_free(pWdaParams) ;
16208 /*
16209 * No respone required for SetBeaconFilter req so just free the request
16210 * param here
16211 */
16212
16213 return ;
16214}
16215
16216VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
16217 tUpdateVHTOpMode *pData)
16218{
16219 WDI_Status status = WDI_STATUS_SUCCESS ;
16220 tWDA_ReqParams *pWdaParams ;
16221 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
16222 sizeof(WDI_UpdateVHTOpMode)) ;
16223 if(NULL == wdiTemp)
16224 {
16225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16226 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16227 VOS_ASSERT(0);
16228 return VOS_STATUS_E_NOMEM;
16229 }
16230 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16231 if(NULL == pWdaParams)
16232 {
16233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16234 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16235 VOS_ASSERT(0);
16236 vos_mem_free(wdiTemp);
16237 return VOS_STATUS_E_NOMEM;
16238 }
16239
16240 wdiTemp->opMode = pData->opMode;
16241 wdiTemp->staId = pData->staId;
16242
16243 pWdaParams->pWdaContext = pWDA;
16244 /* Store Req pointer, as this will be used for response */
16245 pWdaParams->wdaMsgParam = (void *)pData;
16246 /* store Params pass it to WDI */
16247 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
16248
16249 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
16250
16251 if(IS_WDI_STATUS_FAILURE(status))
16252 {
16253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16254 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
16255 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16256 vos_mem_free(pWdaParams->wdaMsgParam);
16257 vos_mem_free(pWdaParams);
16258 }
16259 return CONVERT_WDI2VOS_STATUS(status) ;
16260}
16261#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16262
16263/*==========================================================================
16264 FUNCTION WDA_TransportChannelDebug
16265
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]16266 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16267 Display Transport Channel debugging information
16268 User may request to display DXE channel snapshot
16269 Or if host driver detects any abnormal stcuk may display
16270
16271 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16272 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]16273 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16274 debugFlags : Enable stall detect features
16275 defined by WPAL_DeviceDebugFlags
16276 These features may effect
16277 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16278
16279 RETURN VALUE
16280 NONE
16281
16282===========================================================================*/
16283void WDA_TransportChannelDebug
16284(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16285 tpAniSirGlobal pMac,
16286 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16287 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16288)
16289{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16290 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16291 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16292}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]16293
16294/*==========================================================================
16295 FUNCTION WDA_SetEnableSSR
16296
16297 DESCRIPTION
16298 API to enable/disable SSR on WDI timeout
16299
16300 PARAMETERS
16301 enableSSR : enable/disable SSR
16302
16303 RETURN VALUE
16304 NONE
16305
16306===========================================================================*/
16307void WDA_SetEnableSSR(v_BOOL_t enableSSR)
16308{
16309 WDI_SetEnableSSR(enableSSR);
16310}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]16311
16312#ifdef FEATURE_WLAN_LPHB
16313/*
16314 * FUNCTION: WDA_LPHBconfRspCallback
16315 *
16316 */
16317void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
16318{
16319 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
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 /* Do not need to send notification to upper layer
16332 * Just free allocated resources */
16333 if (pWdaParams != NULL)
16334 {
16335 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16336 {
16337 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16338 }
16339 vos_mem_free(pWdaParams->wdaMsgParam) ;
16340 vos_mem_free(pWdaParams) ;
16341 }
16342
16343 return;
16344}
16345
16346/*
16347 * FUNCTION: WDA_ProcessLPHBConfReq
16348 *
16349 */
16350VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
16351 tSirLPHBReq *pData)
16352{
16353 WDI_Status wdiStatus;
16354 tWDA_ReqParams *pWdaParams ;
16355
16356 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16357 "------> %s " , __func__);
16358
16359 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16360 if (NULL == pWdaParams)
16361 {
16362 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16363 "%s: VOS MEM Alloc Failure", __func__);
16364 VOS_ASSERT(0);
16365 vos_mem_free(pData);
16366 return VOS_STATUS_E_NOMEM;
16367 }
16368
16369 pWdaParams->pWdaContext = pWDA;
16370 pWdaParams->wdaMsgParam = (void *)pData;
16371 pWdaParams->wdaWdiApiMsgParam = NULL;
16372
16373 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
16374 if (WDI_STATUS_PENDING == wdiStatus)
16375 {
16376 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16377 "Pending received for %s:%d ", __func__, __LINE__);
16378 }
16379 else if (WDI_STATUS_SUCCESS != wdiStatus)
16380 {
16381 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16382 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
16383 vos_mem_free(pWdaParams->wdaMsgParam);
16384 vos_mem_free(pWdaParams);
16385 }
16386
16387 return CONVERT_WDI2VOS_STATUS(wdiStatus);
16388}
16389#endif /* FEATURE_WLAN_LPHB */
16390
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]16391void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
16392 void* pUserData)
16393{
16394 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
16395
16396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16397 "<------ %s " ,__func__);
16398 if (NULL == pBcnMissRateInfo)
16399 {
16400 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16401 "%s: pWdaParams received NULL", __func__);
16402 VOS_ASSERT(0) ;
16403 return ;
16404 }
16405 if (pBcnMissRateInfo->callback)
16406 {
16407 pBcnMissRateInfo->callback(status, bcnMissRate,
16408 pBcnMissRateInfo->data);
16409 }
16410 vos_mem_free(pUserData);
16411
16412 return;
16413}
16414
16415v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
16416 tSirBcnMissRateReq *pData)
16417{
16418 WDI_Status wdiStatus;
16419 tSirBcnMissRateInfo *pBcnMissRateInfo;
16420
16421 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16422 "------> %s " , __func__);
16423
16424 pBcnMissRateInfo =
16425 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
16426 if (NULL == pBcnMissRateInfo)
16427 {
16428 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16429 "%s: VOS MEM Alloc Failure", __func__);
16430 VOS_ASSERT(0);
16431 vos_mem_free(pData);
16432 return;
16433 }
16434
16435 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
16436 pBcnMissRateInfo->data = pData->data;
16437
16438 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
16439 WDA_GetBcnMissRateCallback,
16440 pData->bssid);
16441 if (WDI_STATUS_PENDING == wdiStatus)
16442 {
16443 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16444 "Pending received for %s:%d ", __func__, __LINE__);
16445 }
16446 else if (WDI_STATUS_SUCCESS != wdiStatus)
16447 {
16448 if (pBcnMissRateInfo->callback)
16449 {
16450 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
16451 -1, pBcnMissRateInfo->data);
16452 }
16453 }
16454 vos_mem_free(pData);
16455}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16456
16457#ifdef WLAN_FEATURE_EXTSCAN
16458
16459/*==========================================================================
16460 FUNCTION WDA_EXTScanStartRspCallback
16461
16462 DESCRIPTION
16463 API to send EXTScan Start Response to HDD
16464
16465 PARAMETERS
16466 pEventData: Response from FW
16467 pUserData:
16468===========================================================================*/
16469void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
16470{
16471 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16472 tWDA_CbContext *pWDA = NULL;
16473 void *pCallbackContext;
16474 tpAniSirGlobal pMac;
16475
16476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16477 "%s:", __func__);
16478 if (NULL == pWdaParams)
16479 {
16480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16481 "%s: pWdaParams received NULL", __func__);
16482 VOS_ASSERT(0);
16483 return;
16484 }
16485
16486 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16487
16488 if (NULL == pWDA)
16489 {
16490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16491 "%s: pWDA received NULL", __func__);
16492 VOS_ASSERT(0);
16493 goto error;
16494 }
16495
16496 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16497 if (NULL == pMac)
16498 {
16499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16500 "%s:pMac is NULL", __func__);
16501 VOS_ASSERT(0);
16502 goto error;
16503 }
16504
16505 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16506
16507 if (pMac->sme.pEXTScanIndCb)
16508 {
16509 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_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
16519error:
16520
16521 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16522 {
16523 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16524 }
16525 if (pWdaParams->wdaMsgParam != NULL)
16526 {
16527 vos_mem_free(pWdaParams->wdaMsgParam);
16528 }
16529 vos_mem_free(pWdaParams) ;
16530
16531 return;
16532}
16533
16534/*==========================================================================
16535 FUNCTION WDA_EXTScanStopRspCallback
16536
16537 DESCRIPTION
16538 API to send EXTScan Stop Response to HDD
16539
16540 PARAMETERS
16541 pEventData: Response from FW
16542 pUserData:
16543===========================================================================*/
16544void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
16545{
16546 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16547 tWDA_CbContext *pWDA = NULL;
16548 void *pCallbackContext;
16549 tpAniSirGlobal pMac;
16550
16551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16552 "%s:", __func__);
16553 if (NULL == pWdaParams)
16554 {
16555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16556 "%s: pWdaParams received NULL", __func__);
16557 VOS_ASSERT(0);
16558 return;
16559 }
16560
16561 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16562
16563 if (NULL == pWDA)
16564 {
16565 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16566 "%s: pWDA received NULL", __func__);
16567 VOS_ASSERT(0);
16568 goto error;
16569 }
16570
16571 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16572 if (NULL == pMac)
16573 {
16574 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16575 "%s:pMac is NULL", __func__);
16576 VOS_ASSERT(0);
16577 goto error;
16578 }
16579 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16580
16581 if (pMac->sme.pEXTScanIndCb)
16582 {
16583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16584 "%s:HDD call back function called", __func__);
16585 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
16586 pEventData);
16587 }
16588 else
16589 {
16590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16591 "%s:HDD callback is null", __func__);
16592 VOS_ASSERT(0);
16593 }
16594
16595error:
16596
16597 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16598 {
16599 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16600 }
16601 if (pWdaParams->wdaMsgParam != NULL)
16602 {
16603 vos_mem_free(pWdaParams->wdaMsgParam);
16604 }
16605 vos_mem_free(pWdaParams) ;
16606
16607
16608 return;
16609}
16610
16611/*==========================================================================
16612 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
16613
16614 DESCRIPTION
16615 API to send EXTScan Get Cached Results Response to HDD
16616
16617 PARAMETERS
16618 pEventData: Response from FW
16619 pUserData:
16620===========================================================================*/
16621void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
16622{
16623 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16624 tWDA_CbContext *pWDA = NULL;
16625 void *pCallbackContext;
16626 tpAniSirGlobal pMac;
16627
16628 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16629 "%s: ", __func__);
16630 if (NULL == pWdaParams)
16631 {
16632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16633 "%s: pWdaParams received NULL", __func__);
16634 VOS_ASSERT(0);
16635 return;
16636 }
16637
16638 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16639
16640 if (NULL == pWDA)
16641 {
16642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16643 "%s: pWDA received NULL", __func__);
16644 VOS_ASSERT(0);
16645 goto error;
16646 }
16647
16648 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16649 if (NULL == pMac)
16650 {
16651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16652 "%s:pMac is NULL", __func__);
16653 VOS_ASSERT(0);
16654 goto error;
16655 }
16656
16657 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16658
16659 if (pMac->sme.pEXTScanIndCb)
16660 {
16661 pMac->sme.pEXTScanIndCb(pCallbackContext,
16662 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
16663 pEventData);
16664 }
16665 else
16666 {
16667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16668 "%s:HDD callback is null", __func__);
16669 VOS_ASSERT(0);
16670 }
16671
16672
16673error:
16674
16675 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16676 {
16677 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16678 }
16679 if (pWdaParams->wdaMsgParam != NULL)
16680 {
16681 vos_mem_free(pWdaParams->wdaMsgParam);
16682 }
16683 vos_mem_free(pWdaParams) ;
16684
16685 return;
16686}
16687
16688/*==========================================================================
16689 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
16690
16691 DESCRIPTION
16692 API to send EXTScan Get Capabilities Response to HDD
16693
16694 PARAMETERS
16695 pEventData: Response from FW
16696 pUserData:
16697===========================================================================*/
16698void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
16699{
16700 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16701 tWDA_CbContext *pWDA = NULL;
16702 void *pCallbackContext;
16703 tpAniSirGlobal pMac;
16704
16705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16706 "%s:", __func__);
16707 if (NULL == pWdaParams)
16708 {
16709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16710 "%s: pWdaParams received NULL", __func__);
16711 VOS_ASSERT(0);
16712 return;
16713 }
16714
16715 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16716
16717 if (NULL == pWDA)
16718 {
16719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16720 "%s: pWDA received NULL", __func__);
16721 VOS_ASSERT(0);
16722 goto error;
16723 }
16724
16725 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16726 if (NULL == pMac)
16727 {
16728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16729 "%s:pMac is NULL", __func__);
16730 VOS_ASSERT(0);
16731 goto error;
16732 }
16733
16734 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16735
16736 if (pMac->sme.pEXTScanIndCb)
16737 {
16738 pMac->sme.pEXTScanIndCb(pCallbackContext,
16739 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
16740 pEventData);
16741 }
16742 else
16743 {
16744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16745 "%s:HDD callback is null", __func__);
16746 VOS_ASSERT(0);
16747 }
16748
16749
16750error:
16751
16752 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16753 {
16754 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16755 }
16756 if (pWdaParams->wdaMsgParam != NULL)
16757 {
16758 vos_mem_free(pWdaParams->wdaMsgParam);
16759 }
16760 vos_mem_free(pWdaParams) ;
16761
16762 return;
16763}
16764
16765/*==========================================================================
16766 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
16767
16768 DESCRIPTION
16769 API to send EXTScan Set BSSID Hotlist Response to HDD
16770
16771 PARAMETERS
16772 pEventData: Response from FW
16773 pUserData:
16774===========================================================================*/
16775void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16776{
16777 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16778 tWDA_CbContext *pWDA = NULL;
16779 void *pCallbackContext;
16780 tpAniSirGlobal pMac;
16781
16782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16783 "%s: ", __func__);
16784 if (NULL == pWdaParams)
16785 {
16786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16787 "%s: pWdaParams received NULL", __func__);
16788 VOS_ASSERT(0) ;
16789 return;
16790 }
16791
16792 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16793
16794 if (NULL == pWDA)
16795 {
16796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16797 "%s: pWDA received NULL", __func__);
16798 VOS_ASSERT(0);
16799 goto error;
16800 }
16801
16802 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16803 if (NULL == pMac)
16804 {
16805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16806 "%s:pMac is NULL", __func__);
16807 VOS_ASSERT(0);
16808 goto error;
16809 }
16810
16811 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16812
16813 if (pMac->sme.pEXTScanIndCb)
16814 {
16815 pMac->sme.pEXTScanIndCb(pCallbackContext,
16816 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
16817 pEventData);
16818 }
16819 else
16820 {
16821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16822 "%s:HDD callback is null", __func__);
16823 VOS_ASSERT(0);
16824 }
16825
16826
16827error:
16828
16829 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16830 {
16831 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16832 }
16833 if (pWdaParams->wdaMsgParam != NULL)
16834 {
16835 vos_mem_free(pWdaParams->wdaMsgParam);
16836 }
16837 vos_mem_free(pWdaParams) ;
16838
16839 return;
16840}
16841
16842/*==========================================================================
16843 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
16844
16845 DESCRIPTION
16846 API to send EXTScan ReSet BSSID Hotlist Response to HDD
16847
16848 PARAMETERS
16849 pEventData: Response from FW
16850 pUserData:
16851===========================================================================*/
16852void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16853{
16854 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16855 tWDA_CbContext *pWDA = NULL;
16856 void *pCallbackContext;
16857 tpAniSirGlobal pMac;
16858
16859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16860 "%s:", __func__);
16861 if (NULL == pWdaParams)
16862 {
16863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16864 "%s: pWdaParams received NULL", __func__);
16865 VOS_ASSERT(0) ;
16866 return;
16867 }
16868
16869 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16870
16871 if (NULL == pWDA)
16872 {
16873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16874 "%s: pWDA received NULL", __func__);
16875 VOS_ASSERT(0);
16876 goto error;
16877 }
16878
16879 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16880 if (NULL == pMac)
16881 {
16882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16883 "%s:pMac is NULL", __func__);
16884 VOS_ASSERT(0);
16885 goto error;
16886 }
16887
16888 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16889
16890 if (pMac->sme.pEXTScanIndCb)
16891 {
16892 pMac->sme.pEXTScanIndCb(pCallbackContext,
16893 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
16894 pEventData);
16895 }
16896 else
16897 {
16898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16899 "%s:HDD callback is null", __func__);
16900 VOS_ASSERT(0);
16901 }
16902
16903
16904error:
16905
16906 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16907 {
16908 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16909 }
16910 if (pWdaParams->wdaMsgParam != NULL)
16911 {
16912 vos_mem_free(pWdaParams->wdaMsgParam);
16913 }
16914 vos_mem_free(pWdaParams) ;
16915
16916 return;
16917}
16918
16919/*==========================================================================
16920 FUNCTION WDA_EXTScanSetSignfRSSIChangeRspCallback
16921
16922 DESCRIPTION
16923 API to send EXTScan Set Significant RSSI Change RSP to HDD
16924
16925 PARAMETERS
16926 pEventData: Response from FW
16927 pUserData:
16928===========================================================================*/
16929void WDA_EXTScanSetSignfRSSIChangeRspCallback(void *pEventData, void* pUserData)
16930{
16931 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16932 tWDA_CbContext *pWDA = NULL;
16933 void *pCallbackContext;
16934 tpAniSirGlobal pMac;
16935
16936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16937 "%s:", __func__);
16938 if (NULL == pWdaParams)
16939 {
16940 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16941 "%s: pWdaParams received NULL", __func__);
16942 VOS_ASSERT(0) ;
16943 return;
16944 }
16945
16946 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16947
16948 if (NULL == pWDA)
16949 {
16950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16951 "%s: pWDA received NULL", __func__);
16952 VOS_ASSERT(0);
16953 goto error;
16954 }
16955
16956 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16957 if (NULL == pMac)
16958 {
16959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16960 "%s:pMac is NULL", __func__);
16961 VOS_ASSERT(0);
16962 goto error;
16963 }
16964
16965 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16966
16967 if (pMac->sme.pEXTScanIndCb)
16968 {
16969 pMac->sme.pEXTScanIndCb(pCallbackContext,
16970 WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_RSP,
16971 pEventData);
16972 }
16973 else
16974 {
16975 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16976 "%s:HDD callback is null", __func__);
16977 VOS_ASSERT(0);
16978 }
16979
16980
16981error:
16982
16983 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16984 {
16985 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16986 }
16987 if (pWdaParams->wdaMsgParam != NULL)
16988 {
16989 vos_mem_free(pWdaParams->wdaMsgParam);
16990 }
16991 vos_mem_free(pWdaParams) ;
16992
16993 return;
16994}
16995
16996/*==========================================================================
16997 FUNCTION WDA_EXTScanResetSignfRSSIChangeRspCallback
16998
16999 DESCRIPTION
17000 API to send EXTScan Set Significant RSSI Change RSP to HDD
17001
17002 PARAMETERS
17003 pEventData: Response from FW
17004 pUserData:
17005===========================================================================*/
17006void WDA_EXTScanResetSignfRSSIChangeRspCallback(void *pEventData,
17007 void* pUserData)
17008{
17009 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17010 tWDA_CbContext *pWDA = NULL;
17011 void *pCallbackContext;
17012 tpAniSirGlobal pMac;
17013
17014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17015 "%s:", __func__);
17016 if (NULL == pWdaParams)
17017 {
17018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17019 "%s: pWdaParams received NULL", __func__);
17020 VOS_ASSERT(0) ;
17021 return;
17022 }
17023
17024 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17025
17026 if (NULL == pWDA)
17027 {
17028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17029 "%s: pWDA received NULL", __func__);
17030 VOS_ASSERT(0);
17031 goto error;
17032 }
17033
17034 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17035 if (NULL == pMac)
17036 {
17037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17038 "%s:pMac is NULL", __func__);
17039 VOS_ASSERT(0);
17040 goto error;
17041 }
17042
17043 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17044
17045 if (pMac->sme.pEXTScanIndCb)
17046 {
17047 pMac->sme.pEXTScanIndCb(pCallbackContext,
17048 WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_RSP,
17049 pEventData);
17050 }
17051 else
17052 {
17053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17054 "%s:HDD callback is null", __func__);
17055 VOS_ASSERT(0);
17056 }
17057
17058
17059error:
17060
17061 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17062 {
17063 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17064 }
17065 if (pWdaParams->wdaMsgParam != NULL)
17066 {
17067 vos_mem_free(pWdaParams->wdaMsgParam);
17068 }
17069 vos_mem_free(pWdaParams) ;
17070
17071 return;
17072}
17073
17074/*==========================================================================
17075 FUNCTION WDA_ProcessEXTScanStartReq
17076
17077 DESCRIPTION
17078 API to send EXTScan Start Request to WDI
17079
17080 PARAMETERS
17081 pWDA: Pointer to WDA context
17082 wdaRequest: Pointer to EXTScan req parameters
17083===========================================================================*/
17084VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
17085 tSirEXTScanStartReqParams *wdaRequest)
17086{
17087 WDI_Status status = WDI_STATUS_SUCCESS;
17088 tWDA_ReqParams *pWdaParams;
17089
17090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17091 "%s: ", __func__);
17092 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17093 if (NULL == pWdaParams)
17094 {
17095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17096 "%s: VOS MEM Alloc Failure", __func__);
17097 VOS_ASSERT(0);
17098 return VOS_STATUS_E_NOMEM;
17099 }
17100 pWdaParams->pWdaContext = pWDA;
17101 pWdaParams->wdaMsgParam = wdaRequest;
17102 pWdaParams->wdaWdiApiMsgParam = NULL;
17103
17104 status = WDI_EXTScanStartReq((void *)wdaRequest,
17105 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
17106 (void *)pWdaParams);
17107 if (IS_WDI_STATUS_FAILURE(status))
17108 {
17109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17110 "Failure to request. Free all the memory " );
17111 vos_mem_free(pWdaParams->wdaMsgParam);
17112 vos_mem_free(pWdaParams);
17113 }
17114 return CONVERT_WDI2VOS_STATUS(status);
17115}
17116
17117/*==========================================================================
17118 FUNCTION WDA_ProcessEXTScanStopReq
17119
17120 DESCRIPTION
17121 API to send EXTScan Start Request to WDI
17122
17123 PARAMETERS
17124 pWDA: Pointer to WDA context
17125 wdaRequest: Pointer to EXTScan req parameters
17126===========================================================================*/
17127VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
17128 tSirEXTScanStopReqParams *wdaRequest)
17129{
17130 WDI_Status status = WDI_STATUS_SUCCESS;
17131 tWDA_ReqParams *pWdaParams;
17132
17133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17134 "%s:", __func__);
17135 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17136 if (NULL == pWdaParams)
17137 {
17138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17139 "%s: VOS MEM Alloc Failure", __func__);
17140 VOS_ASSERT(0);
17141 return VOS_STATUS_E_NOMEM;
17142 }
17143 pWdaParams->pWdaContext = pWDA;
17144 pWdaParams->wdaMsgParam = wdaRequest;
17145 pWdaParams->wdaWdiApiMsgParam = NULL;
17146
17147 status = WDI_EXTScanStopReq((void *)wdaRequest,
17148 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
17149 (void *)pWdaParams);
17150 if (IS_WDI_STATUS_FAILURE(status))
17151 {
17152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17153 "Failure to request. Free all the memory " );
17154 vos_mem_free(pWdaParams->wdaMsgParam);
17155 vos_mem_free(pWdaParams);
17156 }
17157 return CONVERT_WDI2VOS_STATUS(status);
17158}
17159
17160/*==========================================================================
17161 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
17162
17163 DESCRIPTION
17164 API to send EXTScan Get Cached Results Request to WDI
17165
17166 PARAMETERS
17167 pWDA: Pointer to WDA context
17168 wdaRequest: Pointer to EXTScan req parameters
17169===========================================================================*/
17170VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
17171 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
17172{
17173 WDI_Status status = WDI_STATUS_SUCCESS;
17174 tWDA_ReqParams *pWdaParams;
17175
17176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17177 "%s: ", __func__);
17178 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17179 if (NULL == pWdaParams)
17180 {
17181 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17182 "%s: VOS MEM Alloc Failure", __func__);
17183 VOS_ASSERT(0);
17184 return VOS_STATUS_E_NOMEM;
17185 }
17186 pWdaParams->pWdaContext = pWDA;
17187 pWdaParams->wdaMsgParam = wdaRequest;
17188 pWdaParams->wdaWdiApiMsgParam = NULL;
17189
17190 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
17191 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
17192 (void *)pWdaParams);
17193 if (IS_WDI_STATUS_FAILURE(status))
17194 {
17195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17196 "Failure to request. Free all the memory " );
17197 vos_mem_free(pWdaParams->wdaMsgParam);
17198 vos_mem_free(pWdaParams);
17199 }
17200 return CONVERT_WDI2VOS_STATUS(status);
17201}
17202
17203/*==========================================================================
17204 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
17205
17206 DESCRIPTION
17207 API to send EXTScan Get Capabilities Request to WDI
17208
17209 PARAMETERS
17210 pWDA: Pointer to WDA context
17211 wdaRequest: Pointer to EXTScan req parameters
17212===========================================================================*/
17213VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
17214 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
17215{
17216 WDI_Status status = WDI_STATUS_SUCCESS;
17217 tWDA_ReqParams *pWdaParams;
17218
17219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17220 "%s:", __func__);
17221 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17222 if (NULL == pWdaParams)
17223 {
17224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17225 "%s: VOS MEM Alloc Failure", __func__);
17226 VOS_ASSERT(0);
17227 return VOS_STATUS_E_NOMEM;
17228 }
17229 pWdaParams->pWdaContext = pWDA;
17230 pWdaParams->wdaMsgParam = wdaRequest;
17231 pWdaParams->wdaWdiApiMsgParam = NULL;
17232
17233 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
17234 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
17235 (void *)pWdaParams);
17236 if (IS_WDI_STATUS_FAILURE(status))
17237 {
17238 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17239 "Failure to request. Free all the memory " );
17240 vos_mem_free(pWdaParams->wdaMsgParam);
17241 vos_mem_free(pWdaParams);
17242 }
17243 return CONVERT_WDI2VOS_STATUS(status);
17244}
17245
17246/*==========================================================================
17247 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
17248
17249 DESCRIPTION
17250 API to send Set BSSID Hotlist Request to WDI
17251
17252 PARAMETERS
17253 pWDA: Pointer to WDA context
17254 wdaRequest: Pointer to EXTScan req parameters
17255===========================================================================*/
17256VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17257 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
17258{
17259 WDI_Status status = WDI_STATUS_SUCCESS;
17260 tWDA_ReqParams *pWdaParams;
17261
17262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17263 "%s: ", __func__);
17264 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17265 if (NULL == pWdaParams)
17266 {
17267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17268 "%s: VOS MEM Alloc Failure", __func__);
17269 VOS_ASSERT(0);
17270 return VOS_STATUS_E_NOMEM;
17271 }
17272 pWdaParams->pWdaContext = pWDA;
17273 pWdaParams->wdaMsgParam = wdaRequest;
17274 pWdaParams->wdaWdiApiMsgParam = NULL;
17275
17276 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
17277 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
17278 (void *)pWdaParams);
17279 if (IS_WDI_STATUS_FAILURE(status))
17280 {
17281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17282 "Failure to request. Free all the memory " );
17283 vos_mem_free(pWdaParams->wdaMsgParam);
17284 vos_mem_free(pWdaParams);
17285 }
17286 return CONVERT_WDI2VOS_STATUS(status);
17287}
17288
17289/*==========================================================================
17290 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
17291
17292 DESCRIPTION
17293 API to send Reset BSSID Hotlist Request to WDI
17294
17295 PARAMETERS
17296 pWDA: Pointer to WDA context
17297 wdaRequest: Pointer to EXTScan req parameters
17298===========================================================================*/
17299VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17300 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
17301{
17302 WDI_Status status = WDI_STATUS_SUCCESS;
17303 tWDA_ReqParams *pWdaParams;
17304
17305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17306 "%s:", __func__);
17307 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17308 if (NULL == pWdaParams)
17309 {
17310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17311 "%s: VOS MEM Alloc Failure", __func__);
17312 VOS_ASSERT(0);
17313 return VOS_STATUS_E_NOMEM;
17314 }
17315 pWdaParams->pWdaContext = pWDA;
17316 pWdaParams->wdaMsgParam = wdaRequest;
17317 pWdaParams->wdaWdiApiMsgParam = NULL;
17318
17319 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
17320 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
17321 (void *)pWdaParams);
17322 if (IS_WDI_STATUS_FAILURE(status))
17323 {
17324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17325 "Failure to request. Free all the memory " );
17326 vos_mem_free(pWdaParams->wdaMsgParam);
17327 vos_mem_free(pWdaParams);
17328 }
17329 return CONVERT_WDI2VOS_STATUS(status);
17330}
17331
17332/*==========================================================================
17333 FUNCTION WDA_ProcessEXTScanSetSignfRSSIChangeReq
17334
17335 DESCRIPTION
17336 API to send Set Significant RSSI Change Request to WDI
17337
17338 PARAMETERS
17339 pWDA: Pointer to WDA context
17340 wdaRequest: Pointer to EXTScan req parameters
17341===========================================================================*/
17342VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17343 tSirEXTScanSetSignificantChangeReqParams *wdaRequest)
17344{
17345 WDI_Status status = WDI_STATUS_SUCCESS;
17346 tWDA_ReqParams *pWdaParams;
17347
17348 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17349 "%s: ", __func__);
17350 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17351 if (NULL == pWdaParams)
17352 {
17353 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17354 "%s: VOS MEM Alloc Failure", __func__);
17355 VOS_ASSERT(0);
17356 return VOS_STATUS_E_NOMEM;
17357 }
17358 pWdaParams->pWdaContext = pWDA;
17359 pWdaParams->wdaMsgParam = wdaRequest;
17360 pWdaParams->wdaWdiApiMsgParam = NULL;
17361
17362 status = WDI_EXTScanSetSignfRSSIChangeReq((void *)wdaRequest,
17363 (WDI_EXTScanSetSignfRSSIChangeRspCb)WDA_EXTScanSetSignfRSSIChangeRspCallback,
17364 (void *)pWdaParams);
17365 if (IS_WDI_STATUS_FAILURE(status))
17366 {
17367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17368 "Failure to request. Free all the memory " );
17369 vos_mem_free(pWdaParams->wdaMsgParam);
17370 vos_mem_free(pWdaParams);
17371 }
17372 return CONVERT_WDI2VOS_STATUS(status);
17373}
17374
17375/*==========================================================================
17376 FUNCTION WDA_ProcessEXTScanResetSignfRSSIChangeReq
17377
17378 DESCRIPTION
17379 API to send Reset Significant RSSI Change Request to WDI
17380
17381 PARAMETERS
17382 pWDA: Pointer to WDA context
17383 wdaRequest: Pointer to EXTScan req parameters
17384===========================================================================*/
17385VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17386 tSirEXTScanResetSignificantChangeReqParams *wdaRequest)
17387{
17388 WDI_Status status = WDI_STATUS_SUCCESS;
17389 tWDA_ReqParams *pWdaParams;
17390
17391 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17392 "%s:", __func__);
17393 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17394 if (NULL == pWdaParams)
17395 {
17396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17397 "%s: VOS MEM Alloc Failure", __func__);
17398 VOS_ASSERT(0);
17399 return VOS_STATUS_E_NOMEM;
17400 }
17401 pWdaParams->pWdaContext = pWDA;
17402 pWdaParams->wdaMsgParam = wdaRequest;
17403 pWdaParams->wdaWdiApiMsgParam = NULL;
17404
17405 status = WDI_EXTScanResetSignfRSSIChangeReq((void *)wdaRequest,
17406 (WDI_EXTScanResetSignfRSSIChangeRspCb)
17407 WDA_EXTScanResetSignfRSSIChangeRspCallback,
17408 (void *)pWdaParams);
17409 if (IS_WDI_STATUS_FAILURE(status))
17410 {
17411 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17412 "Failure to request. Free all the memory " );
17413 vos_mem_free(pWdaParams->wdaMsgParam);
17414 vos_mem_free(pWdaParams);
17415 }
17416 return CONVERT_WDI2VOS_STATUS(status);
17417}
17418#endif /* WLAN_FEATURE_EXTSCAN */
17419
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]17420#ifdef WLAN_FEATURE_LINK_LAYER_STATS
17421
17422/*==========================================================================
17423 FUNCTION WDA_LLStatsSetRspCallback
17424
17425 DESCRIPTION
17426 API to process set link layer statistics response from FW
17427
17428 PARAMETERS
17429 pRsp: Pointer to set link layer statistics response
17430 pUserData: Pointer to user data
17431
17432 RETURN VALUE
17433 NONE
17434
17435===========================================================================*/
17436void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
17437{
17438 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17439
17440
17441 if (NULL == pWdaParams)
17442 {
17443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17444 "%s: pWdaParams received NULL", __func__);
17445 VOS_ASSERT(0) ;
17446 return ;
17447 }
17448
17449 /* Do not need to send notification to upper layer
17450 * Just free allocated resources */
17451 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17452 {
17453 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17454 }
17455 if (pWdaParams->wdaMsgParam != NULL)
17456 {
17457 vos_mem_free(pWdaParams->wdaMsgParam);
17458 }
17459 vos_mem_free(pWdaParams) ;
17460
17461 return;
17462}
17463
17464/*==========================================================================
17465 FUNCTION WDA_ProcessLLStatsSetReq
17466
17467 DESCRIPTION
17468 API to send Set Link Layer Stats request to WDI
17469
17470 PARAMETERS
17471 pWDA: Pointer to WDA context
17472 wdaRequest: Pointer to set Link Layer Stats req parameters
17473===========================================================================*/
17474VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
17475 tSirLLStatsSetReq *wdaRequest)
17476{
17477 WDI_Status status = WDI_STATUS_SUCCESS;
17478 tWDA_ReqParams *pWdaParams;
17479
17480 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17481 if (NULL == pWdaParams)
17482 {
17483 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17484 "%s: VOS MEM Alloc Failure", __func__);
17485 VOS_ASSERT(0);
17486 return VOS_STATUS_E_NOMEM;
17487 }
17488 pWdaParams->pWdaContext = pWDA;
17489 pWdaParams->wdaMsgParam = wdaRequest;
17490 pWdaParams->wdaWdiApiMsgParam = NULL;
17491
17492 status = WDI_LLStatsSetReq((void *)wdaRequest,
17493 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
17494 (void *)pWdaParams);
17495 if (IS_WDI_STATUS_FAILURE(status))
17496 {
17497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17498 "Failure to request. Free all the memory " );
17499 vos_mem_free(pWdaParams->wdaMsgParam);
17500 vos_mem_free(pWdaParams);
17501 }
17502 return CONVERT_WDI2VOS_STATUS(status);
17503}
17504
17505/*==========================================================================
17506 FUNCTION WDA_LLStatsGetRspCallback
17507
17508 DESCRIPTION
17509 API to process get link layer statistics response from FW
17510
17511 PARAMETERS
17512 pRsp: Pointer to get link layer statistics response
17513 pUserData: Pointer to user data
17514
17515 RETURN VALUE
17516 NONE
17517
17518===========================================================================*/
17519void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
17520{
17521 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17522
17523 if (NULL == pWdaParams)
17524 {
17525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17526 "%s: pWdaParams received NULL", __func__);
17527 VOS_ASSERT(0) ;
17528 return ;
17529 }
17530
17531 /* Do not need to send notification to upper layer
17532 * Just free allocated resources */
17533 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17534 {
17535 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17536 }
17537 if (pWdaParams->wdaMsgParam != NULL)
17538 {
17539 vos_mem_free(pWdaParams->wdaMsgParam);
17540 }
17541 vos_mem_free(pWdaParams) ;
17542
17543 return;
17544}
17545
17546/*==========================================================================
17547 FUNCTION WDA_ProcessLLStatsGetReq
17548
17549 DESCRIPTION
17550 API to send Get Link Layer Stats request to WDI
17551
17552 PARAMETERS
17553 pWDA: Pointer to WDA context
17554 wdaRequest: Pointer to get Link Layer Stats req parameters
17555===========================================================================*/
17556VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
17557 tSirLLStatsGetReq *wdaRequest)
17558{
17559 WDI_Status status = WDI_STATUS_SUCCESS;
17560 tWDA_ReqParams *pWdaParams;
17561
17562 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17563 if (NULL == pWdaParams)
17564 {
17565 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17566 "%s: VOS MEM Alloc Failure", __func__);
17567 VOS_ASSERT(0);
17568 return VOS_STATUS_E_NOMEM;
17569 }
17570 pWdaParams->pWdaContext = pWDA;
17571 pWdaParams->wdaMsgParam = wdaRequest;
17572 pWdaParams->wdaWdiApiMsgParam = NULL;
17573
17574 status = WDI_LLStatsGetReq((void *) wdaRequest,
17575 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
17576 (void *)pWdaParams);
17577 if (IS_WDI_STATUS_FAILURE(status))
17578 {
17579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17580 "Failure to request. Free all the memory " );
17581 vos_mem_free(pWdaParams->wdaMsgParam);
17582 vos_mem_free(pWdaParams);
17583 }
17584 return CONVERT_WDI2VOS_STATUS(status);
17585}
17586
17587/*==========================================================================
17588 FUNCTION WDA_LLStatsClearRspCallback
17589
17590 DESCRIPTION
17591 API to process clear link layer statistics response from FW
17592
17593 PARAMETERS
17594 pRsp: Pointer to clear link layer statistics response
17595 pUserData: Pointer to user data
17596
17597 RETURN VALUE
17598 NONE
17599
17600===========================================================================*/
17601void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
17602{
17603 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17604
17605
17606 if (NULL == pWdaParams)
17607 {
17608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17609 "%s: pWdaParams received NULL", __func__);
17610 VOS_ASSERT(0) ;
17611 return ;
17612 }
17613 /* Do not need to send notification to upper layer
17614 * Just free allocated resources */
17615 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17616 {
17617 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17618 }
17619 if (pWdaParams->wdaMsgParam != NULL)
17620 {
17621 vos_mem_free(pWdaParams->wdaMsgParam);
17622 }
17623 vos_mem_free(pWdaParams) ;
17624 return;
17625}
17626
17627/*==========================================================================
17628 FUNCTION WDA_ProcessLLStatsClearReq
17629
17630 DESCRIPTION
17631 API to send Clear Link Layer Stats request to WDI
17632
17633 PARAMETERS
17634 pWDA: Pointer to WDA context
17635 wdaRequest: Pointer to earLink Layer Stats req
17636===========================================================================*/
17637VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
17638 tSirLLStatsClearReq *wdaRequest)
17639{
17640 WDI_Status status = WDI_STATUS_SUCCESS;
17641 tWDA_ReqParams *pWdaParams;
17642
17643 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17644 if (NULL == pWdaParams)
17645 {
17646 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17647 "%s: VOS MEM Alloc Failure", __func__);
17648 VOS_ASSERT(0);
17649 return VOS_STATUS_E_NOMEM;
17650 }
17651 pWdaParams->pWdaContext = pWDA;
17652 pWdaParams->wdaMsgParam = wdaRequest;
17653 pWdaParams->wdaWdiApiMsgParam = NULL;
17654
17655 status = WDI_LLStatsClearReq((void *) wdaRequest,
17656 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
17657 (void *)pWdaParams);
17658 if (IS_WDI_STATUS_FAILURE(status))
17659 {
17660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17661 "Failure to request. Free all the memory " );
17662 vos_mem_free(pWdaParams->wdaMsgParam);
17663 vos_mem_free(pWdaParams);
17664 }
17665 return CONVERT_WDI2VOS_STATUS(status);
17666}
17667
17668#endif /* WLAN_FEATURE_LINK_LAYER_STATS */