Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / 6f22c1ff29567465490fa1702795a54483a04f67 / . / CORE / WDA / src / wlan_qct_wda.c
blob: a49a3415c26d6e29fd1497c2b152720b9493ebaf [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]2 * Copyright (c) 2012-2014 The Linux Foundation. All rights reserved.
3 *
4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
5 *
6 *
7 * Permission to use, copy, modify, and/or distribute this software for
8 * any purpose with or without fee is hereby granted, provided that the
9 * above copyright notice and this permission notice appear in all
10 * copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 * PERFORMANCE OF THIS SOFTWARE.
20 */
21
22/*
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame]23 * This file was originally distributed by Qualcomm Atheros, Inc.
24 * under proprietary terms before Copyright ownership was assigned
25 * to the Linux Foundation.
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]26 */
27
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]28
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame]29
30
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]31/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]32 W L A N _ Q C T _ WDA . C
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]33 OVERVIEW:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]34 This software unit holds the implementation of the WLAN Transport Layer.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]35 The functions externalized by this module are to be called ONLY by other
36 WLAN modules that properly register with the Transport Layer initially.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]37 DEPENDENCIES:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]38 Are listed for each API below.
39
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]40 Copyright (c) 2010-2011 QUALCOMM Incorporated.
41 All Rights Reserved.
42 Qualcomm Confidential and Proprietary
43===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]44/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]45 EDIT HISTORY FOR FILE
46
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]47 This section contains comments describing changes made to the module.
48 Notice that changes are listed in reverse chronological order.
49
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]50 $Header$$DateTime$$Author$
51
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]52 when who what, where, why
53---------- --- -------------------------------------------------
5410/05/2011 haparna Adding support for Keep Alive Feature
552010-12-30 smiryala UMAC convergence changes
562010-08-19 adwivedi WLAN DAL AL(WDA) layer for Prima
57===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]58#include "vos_mq.h"
59#include "vos_api.h"
60#include "vos_packet.h"
61#include "vos_nvitem.h"
62#include "sirApi.h"
63#include "wlan_qct_pal_packet.h"
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]64#include "wlan_qct_pal_device.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]65#include "wlan_qct_wda.h"
66#include "wlan_qct_wda_msg.h"
67#include "wlan_qct_wdi_cfg.h"
68#include "wlan_qct_wdi.h"
69#include "wlan_qct_wdi_ds.h"
70#include "wlan_hal_cfg.h"
71/**********************/
72#include "wniApi.h"
73#include "cfgApi.h"
74#include "limApi.h"
75#include "wlan_qct_tl.h"
76#include "wlan_qct_tli_ba.h"
77#include "limUtils.h"
78#include "btcApi.h"
79#include "vos_sched.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]80#include "pttMsgApi.h"
81#include "wlan_qct_sys.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]82/* Used MACRO's */
83/* Get WDA context from vOSS module */
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]84#define WDA_2_4_GHZ_MAX_FREQ 3000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]85#define VOS_GET_WDA_CTXT(a) vos_get_context(VOS_MODULE_ID_WDA, a)
86#define VOS_GET_MAC_CTXT(a) vos_get_context(VOS_MODULE_ID_PE, a)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]87#define WDA_BA_TX_FRM_THRESHOLD (5)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]88#define CONVERT_WDI2SIR_STATUS(x) \
89 ((WDI_STATUS_SUCCESS != (x)) ? eSIR_FAILURE : eSIR_SUCCESS)
90
91#define IS_WDI_STATUS_FAILURE(status) \
92 ((WDI_STATUS_SUCCESS != (status)) && (WDI_STATUS_PENDING != (status)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]93#define CONVERT_WDI2VOS_STATUS(x) \
94 ((IS_WDI_STATUS_FAILURE(x)) ? VOS_STATUS_E_FAILURE : VOS_STATUS_SUCCESS)
95
96/* macro's for acessing TL API/data structures */
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]97#define WDA_TL_GET_STA_STATE(a, b, c) WLANTL_GetSTAState(a, b, c)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]98#define WDA_TL_GET_TX_PKTCOUNT(a, b, c, d) WLANTL_GetTxPktCount(a, b, c, d)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]99#define WDA_GET_BA_TXFLAG(a, b, c) \
100 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) & (1 << (c)))
101
102#define WDA_SET_BA_TXFLAG(a, b, c) \
103 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) |= (1 << (c)))
104
105#define WDA_CLEAR_BA_TXFLAG(a, b, c) \
106 (((a)->wdaStaInfo[b].ucUseBaBitmap) &= ~(1 << c))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]107#define WDA_TL_BA_SESSION_ADD(a, b, c, d, e, f, g) \
108 WLANTL_BaSessionAdd(a, b, c, d, e, f, g)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]109/* timer related Macros */
110#define WDA_CREATE_TIMER(a, b, c, d, e, f, g) \
111 tx_timer_create(a, b, c, d, e, f, g)
112#define WDA_START_TIMER(a) tx_timer_activate(a)
113#define WDA_STOP_TIMER(a) tx_timer_deactivate(a)
114#define WDA_DESTROY_TIMER(a) tx_timer_delete(a)
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]115#define WDA_WDI_START_TIMEOUT (WDI_RESPONSE_TIMEOUT + 5000)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]116
117#define WDA_LAST_POLLED_THRESHOLD(a, curSta, tid) \
118 ((a)->wdaStaInfo[curSta].framesTxed[tid] + WDA_BA_TX_FRM_THRESHOLD)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]119#define WDA_BA_MAX_WINSIZE (64)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]120#define WDA_INVALID_KEY_INDEX 0xFF
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]121#define WDA_NUM_PWR_SAVE_CFG 11
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]122#define WDA_TX_COMPLETE_TIME_OUT_VALUE 1000
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]123#define WDA_TRAFFIC_STATS_TIME_OUT_VALUE 1000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]124
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]125#define WDA_MAX_RETRIES_TILL_RING_EMPTY 1000 /* MAX 10000 msec = 10 seconds wait */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]126
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]127#define WDA_WAIT_MSEC_TILL_RING_EMPTY 10 /* 10 msec wait per cycle */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]128#define WDA_IS_NULL_MAC_ADDRESS(mac_addr) \
129 ((mac_addr[0] == 0x00) && (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) &&\
130 (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) && (mac_addr[3] == 0x00))
131
132#define WDA_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
133#define WDA_MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]134#define WDA_DUMPCMD_WAIT_TIMEOUT 10000
135
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]136/* extern declarations */
137extern void vos_WDAComplete_cback(v_PVOID_t pVosContext);
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]138extern wpt_uint8 WDI_GetActiveSessionsCount (void *pWDICtx, wpt_macAddr macBSSID, wpt_boolean skipBSSID);
139
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]140/* forward declarations */
141void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
142 void *pBodyptr, tANI_U32 bodyVal) ;
143VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
144 WDI_StartReqParamsType *wdiStartParams ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]145VOS_STATUS WDA_wdiCompleteCB(v_PVOID_t pVosContext) ;
146VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams);
147
148extern v_BOOL_t sys_validateStaConfig( void *pImage, unsigned long cbFile,
149 void **ppStaConfig, v_SIZE_t *pcbStaConfig ) ;
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]150void processCfgDownloadReq(tpAniSirGlobal pMac) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]151void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
152 WDI_ConfigBSSReqInfoType *wdiBssParams, tAddBssParams *wdaBssParams) ;
153void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
154 WDI_ConfigStaReqInfoType *wdiStaParams, tAddStaParams *wdaStaParams) ;
155void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
156 void* pUserData ) ;
157static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA) ;
158static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA);
159void WDA_BaCheckActivity(tWDA_CbContext *pWDA) ;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]160void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]161void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams, void* pUserData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]162#ifdef WLAN_FEATURE_VOWIFI_11R
163VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA, tAggrAddTsParams *pAggrAddTsReqParams);
164#endif /* WLAN_FEATURE_VOWIFI_11R */
165
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]166void WDA_TimerHandler(v_VOID_t *pWDA, tANI_U32 timerInfo) ;
167void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pContext) ;
168VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]169#ifdef FEATURE_WLAN_SCAN_PNO
170static VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA, tSirPNOScanReq *pPNOScanReqParams);
171static VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA, tSirSetRSSIFilterReq* pRssiFilterParams);
172static VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA, tSirUpdateScanParams *pUpdateScanParams);
173#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]174#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]175VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,tSirRoamOffloadScanReq *pRoamOffloadScanReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]176void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData);
177void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType);
178void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType);
179#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]180#ifdef WLAN_FEATURE_PACKET_FILTERING
181static VOS_STATUS WDA_Process8023MulticastListReq (
182 tWDA_CbContext *pWDA,
183 tSirRcvFltMcAddrList *pRcvFltMcAddrLis
184 );
185static VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (
186 tWDA_CbContext *pWDA,
187 tSirRcvPktFilterCfgType *pRcvPktFilterCfg
188 );
189static VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (
190 tWDA_CbContext *pWDA,
191 tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp
192 );
193static VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (
194 tWDA_CbContext *pWDA,
195 tSirRcvFltPktClearParam *pRcvFltPktClearParam
196 );
197#endif // WLAN_FEATURE_PACKET_FILTERING
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]198VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA, tSirSetPowerParamsReq *pPowerParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]199static VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
200 tpTxControlParams pTxCtrlParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]201VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
202 v_U8_t *pDefaultKeyId,
203 v_U8_t *pNumKeys,
204 WDI_KeysType *pWdiKeys );
205
206#ifdef WLAN_FEATURE_GTK_OFFLOAD
207static VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA, tpSirGtkOffloadParams pGtkOffloadParams);
208static VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA, tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp);
209#endif // WLAN_FEATURE_GTK_OFFLOAD
210
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]211v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
212 tSirBcnMissRateReq *pData);
213
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]214VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
215 tAniSetTmLevelReq *setTmLevelReq);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]216#ifdef WLAN_FEATURE_11AC
217VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
218 tUpdateVHTOpMode *pData);
219#endif
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]220
221#ifdef FEATURE_WLAN_LPHB
222VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
223 tSirLPHBReq *pData);
224#endif /* FEATURE_WLAN_LPHB */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]225
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]226#ifdef WLAN_FEATURE_EXTSCAN
227VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
228 tSirEXTScanStartReqParams *wdaRequest);
229VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
230 tSirEXTScanStopReqParams *wdaRequest);
231VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
232 tSirEXTScanGetCachedResultsReqParams *wdaRequest);
233VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
234 tSirGetEXTScanCapabilitiesReqParams *wdaRequest);
235VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
236 tSirEXTScanSetBssidHotListReqParams *wdaRequest);
237VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
238 tSirEXTScanResetBssidHotlistReqParams *wdaRequest);
239VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
240 tSirEXTScanSetSignificantChangeReqParams *wdaRequest);
241VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
242 tSirEXTScanResetSignificantChangeReqParams *wdaRequest);
243#endif /* WLAN_FEATURE_EXTSCAN */
244
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]245#ifdef WLAN_FEATURE_LINK_LAYER_STATS
246VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
247 tSirLLStatsSetReq *wdaRequest);
248
249VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
250 tSirLLStatsGetReq *wdaRequest);
251
252VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
253 tSirLLStatsClearReq *wdaRequest);
254#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]255/*
256 * FUNCTION: WDA_open
257 * Allocate the WDA context
258 */
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]259VOS_STATUS WDA_open(v_PVOID_t pVosContext, v_PVOID_t devHandle,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]260 tMacOpenParameters *pMacParams )
261{
262 tWDA_CbContext *wdaContext;
263 VOS_STATUS status;
264 WDI_DeviceCapabilityType wdiDevCapability = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]265 /* Allocate WDA context */
266 status = vos_alloc_context(pVosContext, VOS_MODULE_ID_WDA,
267 (v_VOID_t **)&wdaContext, sizeof(tWDA_CbContext)) ;
268 if(!VOS_IS_STATUS_SUCCESS(status))
269 {
270 return VOS_STATUS_E_NOMEM;
271 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]272 /*__asm int 3;*/
273 vos_mem_zero(wdaContext,sizeof(tWDA_CbContext));
274
275 /* Initialize data structures */
276 wdaContext->pVosContext = pVosContext;
277 wdaContext->wdaState = WDA_INIT_STATE;
278 wdaContext->uTxFlowMask = WDA_TXFLOWMASK;
279
280 /* Initialize WDA-WDI synchronization event */
281 status = vos_event_init(&wdaContext->wdaWdiEvent);
282 if(!VOS_IS_STATUS_SUCCESS(status))
283 {
284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]285 "WDI Sync Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]286 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]288 /* Init Frame transfer event */
289 status = vos_event_init(&wdaContext->txFrameEvent);
290 if(!VOS_IS_STATUS_SUCCESS(status))
291 {
292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]293 "VOS Mgmt Frame Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]294 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]295 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]296 status = vos_event_init(&wdaContext->suspendDataTxEvent);
297 if(!VOS_IS_STATUS_SUCCESS(status))
298 {
299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]300 "VOS suspend data tx Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]301 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]302 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]303 status = vos_event_init(&wdaContext->waitOnWdiIndicationCallBack);
304 if(!VOS_IS_STATUS_SUCCESS(status))
305 {
306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]307 "VOS wait On Wdi Ind Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]308 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]309 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]310 vos_trace_setLevel(VOS_MODULE_ID_WDA,VOS_TRACE_LEVEL_ERROR);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]311 wdaContext->driverMode = pMacParams->driverType;
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]312 if(WDI_STATUS_SUCCESS != WDI_Init(devHandle, &wdaContext->pWdiContext,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]313 &wdiDevCapability, pMacParams->driverType))
314 {
315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
316 "WDI Init failed" );
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]317 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]318 }
319 else
320 {
321 pMacParams->maxStation = wdiDevCapability.ucMaxSTASupported ;
322 pMacParams->maxBssId = wdiDevCapability.ucMaxBSSSupported;
323 pMacParams->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]324 /* update max STA in WDA used for BA */
325 wdaContext->wdaMaxSta = pMacParams->maxStation;
326 /* store the frameTransRequired flag in wdaContext, to send this to HAL
327 * in WDA_Start
328 */
329 wdaContext->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
330 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]331 return status;
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]332
333error:
334 vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
335 return VOS_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]336}
337
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]338/*
339 * FUNCTION: WDA_preStart
340 * Trigger DAL-AL to start CFG download
341 */
342VOS_STATUS WDA_preStart(v_PVOID_t pVosContext)
343{
344 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
345 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]346 /*
347 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
348 */
349 wdaMsg.type = WNI_CFG_DNLD_REQ ;
350 wdaMsg.bodyptr = NULL;
351 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]352 /* post the message.. */
353 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
354 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
355 {
356 vosStatus = VOS_STATUS_E_BADMSG;
357 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]358 return( vosStatus );
359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]360/*
361 * FUNCTION: WDA_wdiStartCallback
362 * Once WDI_Start is finished, WDI start callback will be called by WDI
363 * to indicate completion of WDI_Start.
364 */
365void WDA_wdiStartCallback(WDI_StartRspParamsType *wdiRspParams,
366 void *pVosContext)
367{
368 tWDA_CbContext *wdaContext;
369 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]370 if (NULL == pVosContext)
371 {
372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]373 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]374 return;
375 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]376 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
377 if (NULL == wdaContext)
378 {
379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]380 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]381 return;
382 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]383 if (WDI_STATUS_SUCCESS != wdiRspParams->wdiStatus)
384 {
385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]386 "%s: WDI_Start() failure reported", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]387 }
388 else
389 {
390 wdaContext->wdaState = WDA_START_STATE;
391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]392 /* extract and save version information from the Start Response */
393 wdaContext->wcnssWlanCompiledVersion.major =
394 wdiRspParams->wlanCompiledVersion.major;
395 wdaContext->wcnssWlanCompiledVersion.minor =
396 wdiRspParams->wlanCompiledVersion.minor;
397 wdaContext->wcnssWlanCompiledVersion.version =
398 wdiRspParams->wlanCompiledVersion.version;
399 wdaContext->wcnssWlanCompiledVersion.revision =
400 wdiRspParams->wlanCompiledVersion.revision;
401 wdaContext->wcnssWlanReportedVersion.major =
402 wdiRspParams->wlanReportedVersion.major;
403 wdaContext->wcnssWlanReportedVersion.minor =
404 wdiRspParams->wlanReportedVersion.minor;
405 wdaContext->wcnssWlanReportedVersion.version =
406 wdiRspParams->wlanReportedVersion.version;
407 wdaContext->wcnssWlanReportedVersion.revision =
408 wdiRspParams->wlanReportedVersion.revision;
409 wpalMemoryCopy(wdaContext->wcnssSoftwareVersionString,
410 wdiRspParams->wcnssSoftwareVersion,
411 sizeof(wdaContext->wcnssSoftwareVersionString));
412 wpalMemoryCopy(wdaContext->wcnssHardwareVersionString,
413 wdiRspParams->wcnssHardwareVersion,
414 sizeof(wdaContext->wcnssHardwareVersionString));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]415 /* Notify WDA_start that WDI_Start has completed */
416 status = vos_event_set(&wdaContext->wdaWdiEvent);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]417 if (VOS_STATUS_SUCCESS != status)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]418 {
419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]420 "%s: Unable to unblock WDA_start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]421 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]422 return;
423}
424
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]425/*
426 * FUNCTION: WDA_start
427 * Prepare TLV configuration and call WDI_Start.
428 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]429VOS_STATUS WDA_start(v_PVOID_t pVosContext)
430{
431 tWDA_CbContext *wdaContext;
432 VOS_STATUS status;
433 WDI_Status wdiStatus;
434 WDI_StartReqParamsType wdiStartParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]435 if (NULL == pVosContext)
436 {
437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]438 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]439 return VOS_STATUS_E_FAILURE;
440 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]441 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
442 if (NULL == wdaContext)
443 {
444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]445 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]446 return VOS_STATUS_E_FAILURE;
447 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]448 /* Non-FTM mode, WDA status for START must be INIT
449 * FTM mode, WDA Status for START can be INIT or STOP */
450 if ( (WDA_INIT_STATE != wdaContext->wdaState) &&
451 (WDA_STOP_STATE != wdaContext->wdaState) )
452 {
453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
454 "%s: Invoked from wrong state %d",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]455 __func__, wdaContext->wdaState );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]456 return VOS_STATUS_E_FAILURE;
457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]458 /* initialize the wdiStartParam. Note that we can create this on
459 the stack since we won't exit until WDI_Start() completes or
460 times out */
461 vos_mem_set(&wdiStartParam, sizeof(wdiStartParam), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]462 wdiStartParam.wdiDriverType = wdaContext->driverMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]463 /* prepare the config TLV for the WDI */
464 status = WDA_prepareConfigTLV(pVosContext, &wdiStartParam);
465 if ( !VOS_IS_STATUS_SUCCESS(status) )
466 {
467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]468 "%s: Unable to prepare Config TLV", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]469 return VOS_STATUS_E_FAILURE;
470 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]471 /* note from here onwards if an error occurs we must
472 reclaim the config TLV buffer */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]473 wdiStartParam.wdiLowLevelIndCB = WDA_lowLevelIndCallback;
474 wdiStartParam.pIndUserData = (v_PVOID_t *)wdaContext;
475 wdiStartParam.wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]476 /* initialize the WDA-WDI synchronization event */
477 vos_event_reset(&wdaContext->wdaWdiEvent);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]478 /* call WDI start */
479 wdiStatus = WDI_Start(&wdiStartParam,
480 (WDI_StartRspCb)WDA_wdiStartCallback,
481 (v_VOID_t *)pVosContext);
482 if ( IS_WDI_STATUS_FAILURE(wdiStatus) )
483 {
484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]485 "%s: WDI Start failed", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]486 vos_mem_free(wdiStartParam.pConfigBuffer);
487 return VOS_STATUS_E_FAILURE;
488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]489 /* wait for WDI start to invoke our callback */
490 status = vos_wait_single_event( &wdaContext->wdaWdiEvent,
491 WDA_WDI_START_TIMEOUT );
492 if ( !VOS_IS_STATUS_SUCCESS(status) )
493 {
494 if ( VOS_STATUS_E_TIMEOUT == status )
495 {
496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]497 "%s: Timeout occurred during WDI_Start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]498 }
499 else
500 {
501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
502 "%s: Error %d while waiting for WDI_Start",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]503 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]504 }
505 vos_mem_free(wdiStartParam.pConfigBuffer);
506 return VOS_STATUS_E_FAILURE;
507 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]508 /* WDI_Start() has completed so we can resume our work */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]509 /* we no longer need the config TLV */
510 vos_mem_free(wdiStartParam.pConfigBuffer);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]511 /* if we are not in the START state then WDI_Start() failed */
512 if (WDA_START_STATE != wdaContext->wdaState)
513 {
514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]515 "%s: WDI_Start() failure detected", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]516 return VOS_STATUS_E_FAILURE;
517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]518 /* FTM mode does not need to monitor BA activity */
519 if ( eDRIVER_TYPE_MFG != wdaContext->driverMode )
520 {
521 status = wdaCreateTimers(wdaContext) ;
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]522 if(VOS_STATUS_SUCCESS == status)
523 {
524 wdaContext->wdaTimersCreated = VOS_TRUE;
525 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]526 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]527 else
528 {
529 vos_event_init(&wdaContext->ftmStopDoneEvent);
530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]531 return status;
532}
533
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]534/*
535 * FUNCTION: WDA_prepareConfigTLV
536 * Function to prepare CFG for DAL(WDA)
537 */
538VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
539 WDI_StartReqParamsType *wdiStartParams )
540{
541 /* get pMac to acess CFG data base */
542 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
543 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
544 tHalCfg *tlvStruct = NULL ;
545 tANI_U8 *tlvStructStart = NULL ;
546 tANI_U32 strLength = WNI_CFG_STA_ID_LEN;
547 v_PVOID_t *configParam;
548 tANI_U32 configParamSize;
549 tANI_U32 *configDataValue;
550 WDI_WlanVersionType wcnssCompiledApiVersion;
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]551 tANI_U8 i;
552
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]553 if ((NULL == pMac)||(NULL == wdaContext))
554 {
555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]556 "%s: Invoked with invalid wdaContext or pMac", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]557 VOS_ASSERT(0);
558 return VOS_STATUS_E_FAILURE;
559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]560 configParamSize = (sizeof(tHalCfg) * QWLAN_HAL_CFG_MAX_PARAMS) +
561 WNI_CFG_STA_ID_LEN +
562 WNI_CFG_EDCA_WME_ACBK_LEN +
563 WNI_CFG_EDCA_WME_ACBE_LEN +
564 WNI_CFG_EDCA_WME_ACVI_LEN +
565 WNI_CFG_EDCA_WME_ACVO_LEN +
566 + (QWLAN_HAL_CFG_INTEGER_PARAM * sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]567 /* malloc memory for all configs in one shot */
568 configParam = vos_mem_malloc(configParamSize);
569
570 if(NULL == configParam )
571 {
572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]573 "%s:configParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]574 VOS_ASSERT(0) ;
575 return VOS_STATUS_E_NOMEM;
576 }
577 vos_mem_set(configParam, configParamSize, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]578 wdiStartParams->pConfigBuffer = configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]579 tlvStruct = (tHalCfg *)configParam;
580 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]581 /* TODO: Remove Later */
582 /* QWLAN_HAL_CFG_STA_ID */
583 tlvStruct->type = QWLAN_HAL_CFG_STA_ID;
584 configDataValue = (tANI_U32*)((tANI_U8 *) tlvStruct + sizeof(tHalCfg));
585 if(wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8*)configDataValue, &strLength) !=
586 eSIR_SUCCESS)
587 {
588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
589 "Failed to get value for WNI_CFG_STA_ID");
590 goto handle_failure;
591 }
592 tlvStruct->length = strLength ;
593 /* calculate the pad bytes to have the CFG in aligned format */
594 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
595 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]596 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
597 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]598 /* QWLAN_HAL_CFG_CURRENT_TX_ANTENNA */
599 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
600 tlvStruct->length = sizeof(tANI_U32);
601 configDataValue = (tANI_U32 *)(tlvStruct + 1);
602 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_TX_ANTENNA, configDataValue )
603 != eSIR_SUCCESS)
604 {
605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
606 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
607 goto handle_failure;
608 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]609 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
610 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]611 /* QWLAN_HAL_CFG_CURRENT_RX_ANTENNA */
612 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
613 tlvStruct->length = sizeof(tANI_U32);
614 configDataValue = (tANI_U32 *)(tlvStruct + 1);
615 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_RX_ANTENNA, configDataValue) !=
616 eSIR_SUCCESS)
617 {
618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
619 "Failed to get value for WNI_CFG_CURRENT_RX_ANTENNA");
620 goto handle_failure;
621 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]622 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
623 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]624 /* QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE */
625 tlvStruct->type = QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
626 tlvStruct->length = sizeof(tANI_U32);
627 configDataValue = (tANI_U32 *)(tlvStruct + 1);
628 if(wlan_cfgGetInt(pMac, WNI_CFG_LOW_GAIN_OVERRIDE, configDataValue )
629 != eSIR_SUCCESS)
630 {
631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
632 "Failed to get value for WNI_CFG_LOW_GAIN_OVERRIDE");
633 goto handle_failure;
634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]635 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
636 + sizeof(tHalCfg) + tlvStruct->length)) ;
637
638 /* QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN */
639 tlvStruct->type = QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
640 tlvStruct->length = sizeof(tANI_U32);
641 configDataValue = (tANI_U32 *)(tlvStruct + 1);
642 if(wlan_cfgGetInt(pMac, WNI_CFG_POWER_STATE_PER_CHAIN,
643 configDataValue ) != eSIR_SUCCESS)
644 {
645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
646 "Failed to get value for WNI_CFG_POWER_STATE_PER_CHAIN");
647 goto handle_failure;
648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]649 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
650 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]651 /* QWLAN_HAL_CFG_CAL_PERIOD */
652 tlvStruct->type = QWLAN_HAL_CFG_CAL_PERIOD;
653 tlvStruct->length = sizeof(tANI_U32);
654 configDataValue = (tANI_U32 *)(tlvStruct + 1);
655 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_PERIOD, configDataValue )
656 != eSIR_SUCCESS)
657 {
658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
659 "Failed to get value for WNI_CFG_CAL_PERIOD");
660 goto handle_failure;
661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]662 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
663 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]664 /* QWLAN_HAL_CFG_CAL_CONTROL */
665 tlvStruct->type = QWLAN_HAL_CFG_CAL_CONTROL ;
666 tlvStruct->length = sizeof(tANI_U32);
667 configDataValue = (tANI_U32 *)(tlvStruct + 1);
668 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_CONTROL, configDataValue )
669 != eSIR_SUCCESS)
670 {
671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
672 "Failed to get value for WNI_CFG_CAL_CONTROL");
673 goto handle_failure;
674 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]675 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
676 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]677 /* QWLAN_HAL_CFG_PROXIMITY */
678 tlvStruct->type = QWLAN_HAL_CFG_PROXIMITY ;
679 tlvStruct->length = sizeof(tANI_U32);
680 configDataValue = (tANI_U32 *)(tlvStruct + 1);
681 if(wlan_cfgGetInt(pMac, WNI_CFG_PROXIMITY, configDataValue )
682 != eSIR_SUCCESS)
683 {
684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
685 "Failed to get value for WNI_CFG_PROXIMITY");
686 goto handle_failure;
687 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]688 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
689 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]690 /* QWLAN_HAL_CFG_NETWORK_DENSITY */
691 tlvStruct->type = QWLAN_HAL_CFG_NETWORK_DENSITY ;
692 tlvStruct->length = sizeof(tANI_U32);
693 configDataValue = (tANI_U32 *)(tlvStruct + 1);
694 if(wlan_cfgGetInt(pMac, WNI_CFG_NETWORK_DENSITY, configDataValue )
695 != eSIR_SUCCESS)
696 {
697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
698 "Failed to get value for WNI_CFG_NETWORK_DENSITY");
699 goto handle_failure;
700 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]701 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
702 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]703 /* QWLAN_HAL_CFG_MAX_MEDIUM_TIME */
704 tlvStruct->type = QWLAN_HAL_CFG_MAX_MEDIUM_TIME ;
705 tlvStruct->length = sizeof(tANI_U32);
706 configDataValue = (tANI_U32 *)(tlvStruct + 1);
707 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MEDIUM_TIME, configDataValue ) !=
708 eSIR_SUCCESS)
709 {
710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
711 "Failed to get value for WNI_CFG_MAX_MEDIUM_TIME");
712 goto handle_failure;
713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]714 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
715 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]716 /* QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU */
717 tlvStruct->type = QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU ;
718 tlvStruct->length = sizeof(tANI_U32);
719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
720 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MPDUS_IN_AMPDU,
721 configDataValue ) != eSIR_SUCCESS)
722 {
723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
724 "Failed to get value for WNI_CFG_MAX_MPDUS_IN_AMPDU");
725 goto handle_failure;
726 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]727 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
728 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]729 /* QWLAN_HAL_CFG_RTS_THRESHOLD */
730 tlvStruct->type = QWLAN_HAL_CFG_RTS_THRESHOLD ;
731 tlvStruct->length = sizeof(tANI_U32);
732 configDataValue = (tANI_U32 *)(tlvStruct + 1);
733 if(wlan_cfgGetInt(pMac, WNI_CFG_RTS_THRESHOLD, configDataValue ) !=
734 eSIR_SUCCESS)
735 {
736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
737 "Failed to get value for WNI_CFG_RTS_THRESHOLD");
738 goto handle_failure;
739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]740 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
741 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]742 /* QWLAN_HAL_CFG_SHORT_RETRY_LIMIT */
743 tlvStruct->type = QWLAN_HAL_CFG_SHORT_RETRY_LIMIT ;
744 tlvStruct->length = sizeof(tANI_U32);
745 configDataValue = (tANI_U32 *)(tlvStruct + 1);
746 if(wlan_cfgGetInt(pMac, WNI_CFG_SHORT_RETRY_LIMIT, configDataValue ) !=
747 eSIR_SUCCESS)
748 {
749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
750 "Failed to get value for WNI_CFG_SHORT_RETRY_LIMIT");
751 goto handle_failure;
752 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]753 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
754 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]755 /* QWLAN_HAL_CFG_LONG_RETRY_LIMIT */
756 tlvStruct->type = QWLAN_HAL_CFG_LONG_RETRY_LIMIT ;
757 tlvStruct->length = sizeof(tANI_U32);
758 configDataValue = (tANI_U32 *)(tlvStruct + 1);
759 if(wlan_cfgGetInt(pMac, WNI_CFG_LONG_RETRY_LIMIT, configDataValue ) !=
760 eSIR_SUCCESS)
761 {
762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
763 "Failed to get value for WNI_CFG_LONG_RETRY_LIMIT");
764 goto handle_failure;
765 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]766 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
767 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]768 /* QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD */
769 tlvStruct->type = QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD ;
770 tlvStruct->length = sizeof(tANI_U32);
771 configDataValue = (tANI_U32 *)(tlvStruct + 1);
772 if(wlan_cfgGetInt(pMac, WNI_CFG_FRAGMENTATION_THRESHOLD,
773 configDataValue ) != eSIR_SUCCESS)
774 {
775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
776 "Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD");
777 goto handle_failure;
778 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]779 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
780 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]781 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO */
782 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO ;
783 tlvStruct->length = sizeof(tANI_U32);
784 configDataValue = (tANI_U32 *)(tlvStruct + 1);
785 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ZERO,
786 configDataValue ) != eSIR_SUCCESS)
787 {
788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
789 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ZERO");
790 goto handle_failure;
791 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]792 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
793 + sizeof(tHalCfg) + tlvStruct->length));
794
795 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE */
796 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE ;
797 tlvStruct->length = sizeof(tANI_U32);
798 configDataValue = (tANI_U32 *)(tlvStruct + 1);
799 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ONE,
800 configDataValue ) != eSIR_SUCCESS)
801 {
802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
803 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ONE");
804 goto handle_failure;
805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]806 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
807 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]808 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO */
809 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO ;
810 tlvStruct->length = sizeof(tANI_U32);
811 configDataValue = (tANI_U32 *)(tlvStruct + 1);
812 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_TWO,
813 configDataValue ) != eSIR_SUCCESS)
814 {
815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
816 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_TWO");
817 goto handle_failure;
818 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]819 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
820 + sizeof(tHalCfg) + tlvStruct->length));
821
822 /* QWLAN_HAL_CFG_FIXED_RATE */
823 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE ;
824 tlvStruct->length = sizeof(tANI_U32);
825 configDataValue = (tANI_U32 *)(tlvStruct + 1);
826 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE, configDataValue)
827 != eSIR_SUCCESS)
828 {
829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
830 "Failed to get value for WNI_CFG_FIXED_RATE");
831 goto handle_failure;
832 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]833 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
834 + sizeof(tHalCfg) + tlvStruct->length));
835
836 /* QWLAN_HAL_CFG_RETRYRATE_POLICY */
837 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_POLICY ;
838 tlvStruct->length = sizeof(tANI_U32);
839 configDataValue = (tANI_U32 *)(tlvStruct + 1);
840 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_POLICY, configDataValue )
841 != eSIR_SUCCESS)
842 {
843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
844 "Failed to get value for WNI_CFG_RETRYRATE_POLICY");
845 goto handle_failure;
846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]847 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
848 + sizeof(tHalCfg) + tlvStruct->length));
849
850 /* QWLAN_HAL_CFG_RETRYRATE_SECONDARY */
851 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_SECONDARY ;
852 tlvStruct->length = sizeof(tANI_U32);
853 configDataValue = (tANI_U32 *)(tlvStruct + 1);
854 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_SECONDARY,
855 configDataValue ) != eSIR_SUCCESS)
856 {
857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
858 "Failed to get value for WNI_CFG_RETRYRATE_SECONDARY");
859 goto handle_failure;
860 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]861 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
862 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]863 /* QWLAN_HAL_CFG_RETRYRATE_TERTIARY */
864 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_TERTIARY ;
865 tlvStruct->length = sizeof(tANI_U32);
866 configDataValue = (tANI_U32 *)(tlvStruct + 1);
867 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_TERTIARY,
868 configDataValue ) != eSIR_SUCCESS)
869 {
870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
871 "Failed to get value for WNI_CFG_RETRYRATE_TERTIARY");
872 goto handle_failure;
873 }
874 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
875 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]876 /* QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION */
877 tlvStruct->type = QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION ;
878 tlvStruct->length = sizeof(tANI_U32);
879 configDataValue = (tANI_U32 *)(tlvStruct + 1);
880 if(wlan_cfgGetInt(pMac, WNI_CFG_FORCE_POLICY_PROTECTION,
881 configDataValue ) != eSIR_SUCCESS)
882 {
883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
884 "Failed to get value for WNI_CFG_FORCE_POLICY_PROTECTION");
885 goto handle_failure;
886 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]887 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
888 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]889 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ */
890 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ ;
891 tlvStruct->length = sizeof(tANI_U32);
892 configDataValue = (tANI_U32 *)(tlvStruct + 1);
893 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_24GHZ,
894 configDataValue ) != eSIR_SUCCESS)
895 {
896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
897 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_24GHZ");
898 goto handle_failure;
899 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
901 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]902 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ */
903 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ ;
904 tlvStruct->length = sizeof(tANI_U32);
905 configDataValue = (tANI_U32 *)(tlvStruct + 1);
906 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_5GHZ,
907 configDataValue ) != eSIR_SUCCESS)
908 {
909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
910 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_5GHZ");
911 goto handle_failure;
912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]913 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
914 + sizeof(tHalCfg) + tlvStruct->length);
915
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]916 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ */
917 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ ;
918 tlvStruct->length = sizeof(tANI_U32);
919 configDataValue = (tANI_U32 *)(tlvStruct + 1);
920 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_24GHZ,
921 configDataValue ) != eSIR_SUCCESS)
922 {
923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
924 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_24GHZ");
925 goto handle_failure;
926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]927 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
928 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]929 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ */
930 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ ;
931 tlvStruct->length = sizeof(tANI_U32);
932 configDataValue = (tANI_U32 *)(tlvStruct + 1);
933 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_5GHZ,
934 configDataValue ) != eSIR_SUCCESS)
935 {
936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
937 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_5GHZ");
938 goto handle_failure;
939 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]940 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
941 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]942 /* QWLAN_HAL_CFG_MAX_BA_SESSIONS */
943 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_SESSIONS ;
944 tlvStruct->length = sizeof(tANI_U32);
945 configDataValue = (tANI_U32 *)(tlvStruct + 1);
946 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_SESSIONS, configDataValue ) !=
947 eSIR_SUCCESS)
948 {
949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
950 "Failed to get value for WNI_CFG_MAX_BA_SESSIONS");
951 goto handle_failure;
952 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]953 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
954 + sizeof(tHalCfg) + tlvStruct->length);
955
956 /* QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT */
957 tlvStruct->type = QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT ;
958 tlvStruct->length = sizeof(tANI_U32);
959 configDataValue = (tANI_U32 *)(tlvStruct + 1);
960 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
961 configDataValue ) != eSIR_SUCCESS)
962 {
963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
964 "Failed to get value for WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
965 goto handle_failure;
966 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]967 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
968 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]969 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER */
970 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER ;
971 tlvStruct->length = sizeof(tANI_U32);
972 configDataValue = (tANI_U32 *)(tlvStruct + 1);
973 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_BCN_FILTER,
974 configDataValue ) != eSIR_SUCCESS)
975 {
976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
977 "Failed to get value for WNI_CFG_PS_ENABLE_BCN_FILTER");
978 goto handle_failure;
979 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]980 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
981 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]982 /* QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR */
983 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR ;
984 tlvStruct->length = sizeof(tANI_U32);
985 configDataValue = (tANI_U32 *)(tlvStruct + 1);
986 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_RSSI_MONITOR,
987 configDataValue ) != eSIR_SUCCESS)
988 {
989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
990 "Failed to get value for WNI_CFG_PS_ENABLE_RSSI_MONITOR");
991 goto handle_failure;
992 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]993 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
994 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]995 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
996 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE ;
997 tlvStruct->length = sizeof(tANI_U32);
998 configDataValue = (tANI_U32 *)(tlvStruct + 1);
999 if(wlan_cfgGetInt(pMac, WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE,
1000 configDataValue ) != eSIR_SUCCESS)
1001 {
1002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1003 "Failed to get value for WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE");
1004 goto handle_failure;
1005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1006 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1007 + sizeof(tHalCfg) + tlvStruct->length);
1008
1009 /* QWLAN_HAL_CFG_STATS_PERIOD */
1010 tlvStruct->type = QWLAN_HAL_CFG_STATS_PERIOD ;
1011 tlvStruct->length = sizeof(tANI_U32);
1012 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1013 if(wlan_cfgGetInt(pMac, WNI_CFG_STATS_PERIOD, configDataValue ) !=
1014 eSIR_SUCCESS)
1015 {
1016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1017 "Failed to get value for WNI_CFG_STATS_PERIOD");
1018 goto handle_failure;
1019 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1021 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1022 /* QWLAN_HAL_CFG_CFP_MAX_DURATION */
1023 tlvStruct->type = QWLAN_HAL_CFG_CFP_MAX_DURATION ;
1024 tlvStruct->length = sizeof(tANI_U32);
1025 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1026 if(wlan_cfgGetInt(pMac, WNI_CFG_CFP_MAX_DURATION, configDataValue ) !=
1027 eSIR_SUCCESS)
1028 {
1029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1030 "Failed to get value for WNI_CFG_CFP_MAX_DURATION");
1031 goto handle_failure;
1032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1033 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1034 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1035 /* QWLAN_HAL_CFG_FRAME_TRANS_ENABLED */
1036 tlvStruct->type = QWLAN_HAL_CFG_FRAME_TRANS_ENABLED ;
1037 tlvStruct->length = sizeof(tANI_U32);
1038 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1039 vos_mem_copy(configDataValue, &wdaContext->frameTransRequired,
1040 sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1041 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1042 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1043 /* QWLAN_HAL_CFG_DTIM_PERIOD */
1044 tlvStruct->type = QWLAN_HAL_CFG_DTIM_PERIOD ;
1045 tlvStruct->length = sizeof(tANI_U32);
1046 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1047 if(wlan_cfgGetInt(pMac, WNI_CFG_DTIM_PERIOD, configDataValue)
1048 != eSIR_SUCCESS)
1049 {
1050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1051 "Failed to get value for WNI_CFG_DTIM_PERIOD");
1052 goto handle_failure;
1053 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1054 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1055 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1056 /* QWLAN_HAL_CFG_EDCA_WMM_ACBK */
1057 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBK ;
1058 strLength = WNI_CFG_EDCA_WME_ACBK_LEN;
1059 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1060 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBK, (tANI_U8 *)configDataValue,
1061 &strLength) != eSIR_SUCCESS)
1062 {
1063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1064 "Failed to get value for WNI_CFG_EDCA_WME_ACBK");
1065 goto handle_failure;
1066 }
1067 tlvStruct->length = strLength;
1068 /* calculate the pad bytes to have the CFG in aligned format */
1069 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1070 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1071 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1072 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1073 /* QWLAN_HAL_CFG_EDCA_WMM_ACBE */
1074 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBE ;
1075 strLength = WNI_CFG_EDCA_WME_ACBE_LEN;
1076 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1077 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBE, (tANI_U8 *)configDataValue,
1078 &strLength) != eSIR_SUCCESS)
1079 {
1080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1081 "Failed to get value for WNI_CFG_EDCA_WME_ACBE");
1082 goto handle_failure;
1083 }
1084 tlvStruct->length = strLength;
1085 /* calculate the pad bytes to have the CFG in aligned format */
1086 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1087 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1088 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1089 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1090 /* QWLAN_HAL_CFG_EDCA_WMM_ACVI */
1091 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVO ;
1092 strLength = WNI_CFG_EDCA_WME_ACVI_LEN;
1093 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1094 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVO, (tANI_U8 *)configDataValue,
1095 &strLength) != eSIR_SUCCESS)
1096 {
1097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1098 "Failed to get value for WNI_CFG_EDCA_WME_ACVI");
1099 goto handle_failure;
1100 }
1101 tlvStruct->length = strLength;
1102 /* calculate the pad bytes to have the CFG in aligned format */
1103 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1104 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1105 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1106 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1107 /* QWLAN_HAL_CFG_EDCA_WMM_ACVO */
1108 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVI ;
1109 strLength = WNI_CFG_EDCA_WME_ACVO_LEN;
1110 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1111 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVI, (tANI_U8 *)configDataValue,
1112 &strLength) != eSIR_SUCCESS)
1113 {
1114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1115 "Failed to get value for WNI_CFG_EDCA_WME_ACVO");
1116 goto handle_failure;
1117 }
1118 tlvStruct->length = strLength;
1119 /* calculate the pad bytes to have the CFG in aligned format */
1120 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1121 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1122 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1123 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1124 /* QWLAN_HAL_CFG_BA_THRESHOLD_HIGH */
1125 tlvStruct->type = QWLAN_HAL_CFG_BA_THRESHOLD_HIGH ;
1126 tlvStruct->length = sizeof(tANI_U32);
1127 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1128 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_THRESHOLD_HIGH, configDataValue)
1129 != eSIR_SUCCESS)
1130 {
1131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1132 "Failed to get value for WNI_CFG_BA_THRESHOLD_HIGH");
1133 goto handle_failure;
1134 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1135 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1136 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1137 /* QWLAN_HAL_CFG_MAX_BA_BUFFERS */
1138 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_BUFFERS ;
1139 tlvStruct->length = sizeof(tANI_U32);
1140 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1141 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_BUFFERS, configDataValue)
1142 != eSIR_SUCCESS)
1143 {
1144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1145 "Failed to get value for WNI_CFG_MAX_BA_BUFFERS");
1146 goto handle_failure;
1147 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1148 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1149 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1150 /* QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE */
1151 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE ;
1152 tlvStruct->length = sizeof(tANI_U32);
1153 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1154 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_PS_POLL_VALUE, configDataValue)
1155 != eSIR_SUCCESS)
1156 {
1157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1158 "Failed to get value for WNI_CFG_DYNAMIC_PS_POLL_VALUE");
1159 goto handle_failure;
1160 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1161 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1162 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1163 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI */
1164 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI ;
1165 tlvStruct->length = sizeof(tANI_U32);
1166 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1167 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI, configDataValue)
1168 != eSIR_SUCCESS)
1169 {
1170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1171 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI");
1172 goto handle_failure;
1173 }
1174 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1175 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1176 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS */
1177 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS ;
1178 tlvStruct->length = sizeof(tANI_U32);
1179 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1180 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, configDataValue)
1181 != eSIR_SUCCESS)
1182 {
1183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1184 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS");
1185 goto handle_failure;
1186 }
1187 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1188 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1189 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI */
1190 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI ;
1191 tlvStruct->length = sizeof(tANI_U32);
1192 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1193 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI, configDataValue)
1194 != eSIR_SUCCESS)
1195 {
1196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1197 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI");
1198 goto handle_failure;
1199 }
1200 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1201 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1202 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS */
1203 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS ;
1204 tlvStruct->length = sizeof(tANI_U32);
1205 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1206 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, configDataValue)
1207 != eSIR_SUCCESS)
1208 {
1209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1210 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS");
1211 goto handle_failure;
1212 }
1213 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1214 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1215 /* QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN */
1216 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN ;
1217 tlvStruct->length = sizeof(tANI_U32);
1218 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1219 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_WAKEUP_EN, configDataValue)
1220 != eSIR_SUCCESS)
1221 {
1222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1223 "Failed to get value for WNI_CFG_TELE_BCN_WAKEUP_EN");
1224 goto handle_failure;
1225 }
1226 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1227 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1228 /* QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD */
1229 tlvStruct->type = QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD ;
1230 tlvStruct->length = sizeof(tANI_U32);
1231 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1232 if(wlan_cfgGetInt(pMac, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, configDataValue)
1233 != eSIR_SUCCESS)
1234 {
1235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1236 "Failed to get value for WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD");
1237 goto handle_failure;
1238 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1239 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1240 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1241 /*QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE*/
1242 tlvStruct->type = QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE ;
1243 tlvStruct->length = sizeof(tANI_U32);
1244 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1245 if(wlan_cfgGetInt(pMac, WNI_CFG_TX_PWR_CTRL_ENABLE, configDataValue)
1246 != eSIR_SUCCESS)
1247 {
1248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1249 "Failed to get value for WNI_CFG_TX_PWR_CTRL_ENABLE");
1250 goto handle_failure;
1251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1252 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1253 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1254 /* QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP */
1255 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP ;
1256 tlvStruct->length = sizeof(tANI_U32);
1257 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1258 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_CLOSE_LOOP, configDataValue)
1259 != eSIR_SUCCESS)
1260 {
1261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1262 "Failed to get value for WNI_CFG_ENABLE_CLOSE_LOOP");
1263 goto handle_failure;
1264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1265 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1266 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1267 /* [COEX] strictly speaking, the Coex parameters are not part of the WLAN_CFG_FILE binary,
1268 * but are from the WLAN_INI_FILE file. However, this is the only parameter download routine
1269 * into FW, so the parameters are added here.
1270 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1271 /* [COEX] QWLAN_HAL_CFG_BTC_EXECUTION_MODE */
1272 tlvStruct->type = QWLAN_HAL_CFG_BTC_EXECUTION_MODE ;
1273 tlvStruct->length = sizeof(tANI_U32);
1274 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1275 *configDataValue = pMac->btc.btcConfig.btcExecutionMode;
1276 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1277 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1278 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK */
1279 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK ;
1280 tlvStruct->length = sizeof(tANI_U32);
1281 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1282 *configDataValue = pMac->btc.btcConfig.btcConsBtSlotsToBlockDuringDhcp;
1283 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1284 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1285 /* [COEX] QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS */
1286 tlvStruct->type = QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS ;
1287 tlvStruct->length = sizeof(tANI_U32);
1288 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1289 *configDataValue = pMac->btc.btcConfig.btcA2DPBtSubIntervalsDuringDhcp;
1290 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1291 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1292 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT */
1293 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT ;
1294 tlvStruct->length = sizeof(tANI_U32);
1295 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1296 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqBt;
1297 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1298 + sizeof(tHalCfg) + tlvStruct->length) ;
1299
1300 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT */
1301 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT ;
1302 tlvStruct->length = sizeof(tANI_U32);
1303 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1304 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageBt;
1305 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1306 + sizeof(tHalCfg) + tlvStruct->length) ;
1307
1308 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT */
1309 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT ;
1310 tlvStruct->length = sizeof(tANI_U32);
1311 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1312 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnBt;
1313 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1314 + sizeof(tHalCfg) + tlvStruct->length) ;
1315
1316 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT */
1317 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT ;
1318 tlvStruct->length = sizeof(tANI_U32);
1319 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1320 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeBt;
1321 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1322 + sizeof(tHalCfg) + tlvStruct->length) ;
1323
1324 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN */
1325 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN ;
1326 tlvStruct->length = sizeof(tANI_U32);
1327 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1328 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqWlan;
1329 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1330 + sizeof(tHalCfg) + tlvStruct->length) ;
1331
1332 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN */
1333 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN ;
1334 tlvStruct->length = sizeof(tANI_U32);
1335 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1336 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageWlan;
1337 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1338 + sizeof(tHalCfg) + tlvStruct->length) ;
1339
1340 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN */
1341 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN ;
1342 tlvStruct->length = sizeof(tANI_U32);
1343 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1344 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnWlan;
1345 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1346 + sizeof(tHalCfg) + tlvStruct->length) ;
1347
1348 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN */
1349 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN ;
1350 tlvStruct->length = sizeof(tANI_U32);
1351 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1352 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeWlan;
1353 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1354 + sizeof(tHalCfg) + tlvStruct->length) ;
1355
1356 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT */
1357 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT ;
1358 tlvStruct->length = sizeof(tANI_U32);
1359 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1360 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenBt;
1361 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1362 + sizeof(tHalCfg) + tlvStruct->length) ;
1363
1364 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN */
1365 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN ;
1366 tlvStruct->length = sizeof(tANI_U32);
1367 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1368 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenWlan;
1369 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1370 + sizeof(tHalCfg) + tlvStruct->length) ;
1371
1372 /* [COEX] QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC */
1373 tlvStruct->type = QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC ;
1374 tlvStruct->length = sizeof(tANI_U32);
1375 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1376 *configDataValue = pMac->btc.btcConfig.btcMaxScoBlockPerc;
1377 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1378 + sizeof(tHalCfg) + tlvStruct->length) ;
1379
1380 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP */
1381 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP ;
1382 tlvStruct->length = sizeof(tANI_U32);
1383 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1384 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnA2dp;
1385 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1386 + sizeof(tHalCfg) + tlvStruct->length) ;
1387
1388 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO */
1389 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO ;
1390 tlvStruct->length = sizeof(tANI_U32);
1391 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1392 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnSco;
1393 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1394 + sizeof(tHalCfg) + tlvStruct->length) ;
1395
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]1396 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_VICTIM; i++)
1397 {
1398 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WAN_FREQ */
1399 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WAN_FREQ + i*4;
1400 tlvStruct->length = sizeof(tANI_U32);
1401 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1402 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWANFreq[i];
1403 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1404 + sizeof(tHalCfg) + tlvStruct->length) ;
1405
1406 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WLAN_FREQ */
1407 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WLAN_FREQ + i*4;
1408 tlvStruct->length = sizeof(tANI_U32);
1409 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1410 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWLANFreq[i];
1411 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1412 + sizeof(tHalCfg) + tlvStruct->length) ;
1413
1414 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG */
1415 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG + i*4;
1416 tlvStruct->length = sizeof(tANI_U32);
1417 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1418 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig[i];
1419 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1420 + sizeof(tHalCfg) + tlvStruct->length) ;
1421
1422 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG2 */
1423 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG2 + i*4;
1424 tlvStruct->length = sizeof(tANI_U32);
1425 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1426 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig2[i];
1427 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1428 + sizeof(tHalCfg) + tlvStruct->length) ;
1429 }
1430
1431 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF */
1432 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF ;
1433 tlvStruct->length = sizeof(tANI_U32);
1434 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1435 *configDataValue = pMac->btc.btcConfig.mwsCoexModemBackoff;
1436 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1437 + sizeof(tHalCfg) + tlvStruct->length) ;
1438
1439 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_CONFIG; i++)
1440 {
1441 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_CONFIGX */
1442 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_CONFIG1 + i;
1443 tlvStruct->length = sizeof(tANI_U32);
1444 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1445 *configDataValue = pMac->btc.btcConfig.mwsCoexConfig[i];
1446 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1447 + sizeof(tHalCfg) + tlvStruct->length) ;
1448 }
1449
1450 /* [COEX] QWLAN_HAL_CFG_SAR_POWER_BACKOFF */
1451 tlvStruct->type = QWLAN_HAL_CFG_SAR_POWER_BACKOFF ;
1452 tlvStruct->length = sizeof(tANI_U32);
1453 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1454 *configDataValue = pMac->btc.btcConfig.SARPowerBackoff;
1455 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1456 + sizeof(tHalCfg) + tlvStruct->length) ;
1457
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1458 /* QWLAN_HAL_CFG_WCNSS_API_VERSION */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1459 tlvStruct->type = QWLAN_HAL_CFG_WCNSS_API_VERSION ;
1460 tlvStruct->length = sizeof(tANI_U32);
1461 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1462 WDI_GetWcnssCompiledApiVersion(&wcnssCompiledApiVersion);
1463 *configDataValue = WLAN_HAL_CONSTRUCT_API_VERSION(wcnssCompiledApiVersion.major,
1464 wcnssCompiledApiVersion.minor,
1465 wcnssCompiledApiVersion.version,
1466 wcnssCompiledApiVersion.revision);
1467 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1468 + sizeof(tHalCfg) + tlvStruct->length) ;
1469
Jeff Johnsond13512a2012-07-17 11:42:19 -0700[diff] [blame]1470 /* QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT */
1471 tlvStruct->type = QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT ;
1472 tlvStruct->length = sizeof(tANI_U32);
1473 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1474 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT,
1475 configDataValue ) != eSIR_SUCCESS)
1476 {
1477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1478 "Failed to get value for WNI_CFG_AP_KEEP_ALIVE_TIMEOUT");
1479 goto handle_failure;
1480 }
1481
1482 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1483 + sizeof(tHalCfg) + tlvStruct->length) ;
1484 /* QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT */
1485 tlvStruct->type = QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT ;
1486 tlvStruct->length = sizeof(tANI_U32);
1487 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1488 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT,
1489 configDataValue ) != eSIR_SUCCESS)
1490 {
1491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1492 "Failed to get value for WNI_CFG_GO_KEEP_ALIVE_TIMEOUT");
1493 goto handle_failure;
1494 }
1495
1496 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1497 + sizeof(tHalCfg) + tlvStruct->length) ;
1498
1499 /* QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST */
1500 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST;
1501 tlvStruct->length = sizeof(tANI_U32);
1502 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1503 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MC_ADDR_LIST, configDataValue)
1504 != eSIR_SUCCESS)
1505 {
1506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1507 "Failed to get value for WNI_CFG_ENABLE_MC_ADDR_LIST");
1508 goto handle_failure;
1509 }
1510
1511 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1512 + sizeof(tHalCfg) + tlvStruct->length) ;
1513
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]1514 /* QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION */
1515 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION ;
1516 tlvStruct->length = sizeof(tANI_U32);
1517 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1518 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION, configDataValue)
1519 != eSIR_SUCCESS)
1520 {
1521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1522 "Failed to get value for WNI_CFG_ENABLE_LPWR_IMG_TRANSITION");
1523 goto handle_failure;
1524 }
1525
1526 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1527 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]1528#ifdef WLAN_SOFTAP_VSTA_FEATURE
1529 tlvStruct->type = QWLAN_HAL_CFG_MAX_ASSOC_LIMIT;
1530 tlvStruct->length = sizeof(tANI_U32);
1531 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1532 if(wlan_cfgGetInt(pMac, WNI_CFG_ASSOC_STA_LIMIT, configDataValue)
1533 != eSIR_SUCCESS)
1534 {
1535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1536 "Failed to get value for WNI_CFG_ASSOC_STA_LIMIT");
1537 goto handle_failure;
1538 }
1539
1540 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1541 + sizeof(tHalCfg) + tlvStruct->length) ;
1542#endif
1543
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]1544 /* QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER */
1545 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER;
1546 tlvStruct->length = sizeof(tANI_U32);
1547 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1548
1549 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, configDataValue)
1550 != eSIR_SUCCESS)
1551 {
1552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1553 "Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
1554 goto handle_failure;
1555 }
1556
1557 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1558 + sizeof(tHalCfg) + tlvStruct->length) ;
1559
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1560/* QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT */
1561 tlvStruct->type = QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT ;
1562 tlvStruct->length = sizeof(tANI_U32);
1563 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1564 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_LINK_MONITOR_TIMEOUT,
1565 configDataValue ) != eSIR_SUCCESS)
1566 {
1567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1568 "Failed to get value for WNI_CFG_AP_LINK_MONITOR_TIMEOUT");
1569 goto handle_failure;
1570 }
1571
1572 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1573 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1574#ifdef FEATURE_WLAN_TDLS
1575 /* QWLAN_HAL_CFG_TDLS_PUAPSD_MASK */
1576 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_MASK;
1577 tlvStruct->length = sizeof(tANI_U32);
1578 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1579 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,
1580 configDataValue ) != eSIR_SUCCESS)
1581 {
1582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1583 "Failed to get value for WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK");
1584 goto handle_failure;
1585 }
1586 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1587 + sizeof(tHalCfg) + tlvStruct->length) ;
1588
1589 /* QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE */
1590 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE;
1591 tlvStruct->length = sizeof(tANI_U32);
1592 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1593 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_BUF_STA_ENABLED,
1594 configDataValue ) != eSIR_SUCCESS)
1595 {
1596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1597 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1598 goto handle_failure;
1599 }
1600 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1601 + sizeof(tHalCfg) + tlvStruct->length) ;
1602 /* QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME */
1603 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME;
1604 tlvStruct->length = sizeof(tANI_U32);
1605 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1606 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_PUAPSD_INACT_TIME,
1607 configDataValue ) != eSIR_SUCCESS)
1608 {
1609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1610 "Failed to get value for WNI_CFG_TDLS_PUAPSD_INACT_TIME");
1611 goto handle_failure;
1612 }
1613 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1614 + sizeof(tHalCfg) + tlvStruct->length) ;
1615 /* QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP */
1616 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP;
1617 tlvStruct->length = sizeof(tANI_U32);
1618 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1619 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,
1620 configDataValue ) != eSIR_SUCCESS)
1621 {
1622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1623 "Failed to get value for WNI_CFG_TDLS_RX_FRAME_THRESHOLD");
1624 goto handle_failure;
1625 }
1626 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1627 + sizeof(tHalCfg) + tlvStruct->length) ;
Naresh Jayaramf73f3762014-02-04 16:13:20 +0530[diff] [blame]1628 /* QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE */
1629 tlvStruct->type = QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE;
1630 tlvStruct->length = sizeof(tANI_U32);
1631 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1632 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_OFF_CHANNEL_ENABLED,
1633 configDataValue ) != eSIR_SUCCESS)
1634 {
1635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1636 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1637 goto handle_failure;
1638 }
1639 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1640 + sizeof(tHalCfg) + tlvStruct->length) ;
1641
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1642#endif
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1643
Sudhir Sattayappa Kohallida1be202013-07-11 12:04:30 -0700[diff] [blame]1644 /* QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN */
1645 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN_FEATURE ;
1646 tlvStruct->length = sizeof(tANI_U32);
1647 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1648 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,
1649 configDataValue ) != eSIR_SUCCESS)
1650 {
1651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1652 "Failed to get value for WNI_CFG_ENABLE_ADAPT_RX_DRAIN");
1653 goto handle_failure;
1654 }
1655
1656 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1657 + sizeof(tHalCfg) + tlvStruct->length) ;
Yue Ma0fd23872013-08-01 15:56:47 -0700[diff] [blame]1658
1659 /* QWLAN_HAL_CFG_FLEX_CONNECT_POWER_FACTOR */
1660 tlvStruct->type = QWLAN_HAL_CFG_FLEXCONNECT_POWER_FACTOR;
1661 tlvStruct->length = sizeof(tANI_U32);
1662 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1663 if(wlan_cfgGetInt(pMac, WNI_CFG_FLEX_CONNECT_POWER_FACTOR, configDataValue)
1664 != eSIR_SUCCESS)
1665 {
1666 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1667 "Failed to get value for WNI_CFG_FLEX_CONNECT_POWER_FACTOR");
1668 goto handle_failure;
1669 }
1670 tlvStruct = (tHalCfg *)(((tANI_U8 *) tlvStruct
1671 + sizeof(tHalCfg) + tlvStruct->length));
1672
Madan Mohan Koyyalamudica454572013-08-07 19:57:03 +0530[diff] [blame]1673 /* QWLAN_HAL_CFG_ANTENNA_DIVERSITY */
1674 tlvStruct->type = QWLAN_HAL_CFG_ANTENNA_DIVERSITY;
1675 tlvStruct->length = sizeof(tANI_U32);
1676 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1677 if (wlan_cfgGetInt(pMac, WNI_CFG_ANTENNA_DIVESITY,
1678 configDataValue ) != eSIR_SUCCESS)
1679 {
1680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1681 "Failed to get value for WNI_CFG_ANTENNA_DIVESITY");
1682 goto handle_failure;
1683 }
1684
1685 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1686 + sizeof(tHalCfg) + tlvStruct->length) ;
1687
Madan Mohan Koyyalamudi2558bc92013-08-24 16:54:31 +0530[diff] [blame]1688 /* QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT */
1689 tlvStruct->type = QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT ;
1690 tlvStruct->length = sizeof(tANI_U32);
1691 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1692 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_LINK_MONITOR_TIMEOUT,
1693 configDataValue ) != eSIR_SUCCESS)
1694 {
1695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1696 "Failed to get value for WNI_CFG_GO_LINK_MONITOR_TIMEOUT");
1697 goto handle_failure;
1698 }
1699 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1700 + sizeof(tHalCfg) + tlvStruct->length) ;
1701
Kiet Lam4bbd3cb2013-11-07 20:03:49 +0530[diff] [blame]1702 /* QWLAN_HAL_CFG_ATH_DISABLE */
1703 tlvStruct->type = QWLAN_HAL_CFG_ATH_DISABLE ;
1704 tlvStruct->length = sizeof(tANI_U32);
1705 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1706 if(wlan_cfgGetInt(pMac, WNI_CFG_ATH_DISABLE,
1707 configDataValue ) != eSIR_SUCCESS)
1708 {
1709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1710 "Failed to get value for WNI_CFG_ATH_DISABLE");
1711 goto handle_failure;
1712 }
1713 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1714 + sizeof(tHalCfg) + tlvStruct->length) ;
1715
c_hpothu6d7dc922013-12-02 12:36:41 +0530[diff] [blame]1716 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_WLAN_LEN */
1717 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1718 tlvStruct->length = sizeof(tANI_U32);
1719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1720 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_WLAN_LEN,
1721 configDataValue ) != eSIR_SUCCESS)
1722 {
1723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1724 "Failed to get value for WNI_CFG_BTC_ACTIVE_WLAN_LEN");
1725 goto handle_failure;
1726 }
1727 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1728 + sizeof(tHalCfg) + tlvStruct->length) ;
1729
1730 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1731 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1732 tlvStruct->length = sizeof(tANI_U32);
1733 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1734 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_BT_LEN,
1735 configDataValue ) != eSIR_SUCCESS)
1736 {
1737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1738 "Failed to get value for WNI_CFG_BTC_ACTIVE_BT_LEN");
1739 goto handle_failure;
1740 }
1741 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1742 + sizeof(tHalCfg) + tlvStruct->length) ;
1743
1744 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN */
1745 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1746 tlvStruct->length = sizeof(tANI_U32);
1747 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1748 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,
1749 configDataValue ) != eSIR_SUCCESS)
1750 {
1751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1752 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN");
1753 goto handle_failure;
1754 }
1755 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1756 + sizeof(tHalCfg) + tlvStruct->length) ;
1757
1758 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1759 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1760 tlvStruct->length = sizeof(tANI_U32);
1761 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1762 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,
1763 configDataValue ) != eSIR_SUCCESS)
1764 {
1765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1766 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_BT_LEN");
1767 goto handle_failure;
1768 }
1769 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1770 + sizeof(tHalCfg) + tlvStruct->length) ;
1771
AnjaneeDevi Kapparapu50239e32014-01-07 18:09:33 +0530[diff] [blame]1772 /* QWLAN_HAL_CFG_ASD_PROBE_INTERVAL */
1773 tlvStruct->type = QWLAN_HAL_CFG_ASD_PROBE_INTERVAL ;
1774 tlvStruct->length = sizeof(tANI_U32);
1775 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1776 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_PROBE_INTERVAL,
1777 configDataValue ) != eSIR_SUCCESS)
1778 {
1779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1780 "Failed to get value for WNI_CFG_ASD_PROBE_INTERVAL");
1781 goto handle_failure;
1782 }
1783 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1784 + sizeof(tHalCfg) + tlvStruct->length) ;
1785
1786 /* QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD */
1787 tlvStruct->type = QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD ;
1788 tlvStruct->length = sizeof(tANI_U32);
1789 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1790 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_TRIGGER_THRESHOLD,
1791 configDataValue ) != eSIR_SUCCESS)
1792 {
1793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1794 "Failed to get value for WNI_CFG_ASD_TRIGGER_THRESHOLD");
1795 goto handle_failure;
1796 }
1797 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1798 + sizeof(tHalCfg) + tlvStruct->length) ;
1799
1800 /* QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD */
1801 tlvStruct->type = QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD ;
1802 tlvStruct->length = sizeof(tANI_U32);
1803 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1804 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD,
1805 configDataValue ) != eSIR_SUCCESS)
1806 {
1807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1808 "Failed to get value for WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD");
1809 goto handle_failure;
1810 }
1811 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1812 + sizeof(tHalCfg) + tlvStruct->length) ;
1813
Leela Venkata Kiran Kumar Reddy Chirala22c159b2013-12-23 18:19:13 -0800[diff] [blame]1814 /* QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO */
1815 tlvStruct->type = QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO ;
1816 tlvStruct->length = sizeof(tANI_U32);
1817 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1818 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CTS2S_DURING_SCO,
1819 configDataValue ) != eSIR_SUCCESS)
1820 {
1821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1822 "Failed to get value for WNI_CFG_BTC_CTS2S_DURING_SCO");
1823 goto handle_failure;
1824 }
1825 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1826 + sizeof(tHalCfg) + tlvStruct->length) ;
1827
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1828 /* QWLAN_HAL_CFG_RA_FILTER_ENABLE */
1829 tlvStruct->type = QWLAN_HAL_CFG_RA_FILTER_ENABLE ;
1830 tlvStruct->length = sizeof(tANI_U32);
1831 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1832
1833 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_FILTER_ENABLE,
1834 configDataValue ) != eSIR_SUCCESS)
1835 {
1836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1837 "Failed to get value for WNI_CFG_RA_FILTER_ENABLE");
1838 goto handle_failure;
1839 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1840 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1841 + sizeof(tHalCfg) + tlvStruct->length) ;
1842
1843 /* QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL */
1844 tlvStruct->type = QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL ;
1845 tlvStruct->length = sizeof(tANI_U32);
1846 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1847
1848 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_RATE_LIMIT_INTERVAL,
1849 configDataValue ) != eSIR_SUCCESS)
1850 {
1851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1852 "Failed to get value for WNI_CFG_RA_RATE_LIMIT_INTERVAL");
1853 goto handle_failure;
1854 }
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1855 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1856 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1857
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1858 /* QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE */
1859 tlvStruct->type = QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE ;
1860 tlvStruct->length = sizeof(tANI_U32);
1861 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1862
1863 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE,
1864 configDataValue ) != eSIR_SUCCESS)
1865 {
1866 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1867 "Failed to get value for WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE");
1868 goto handle_failure;
1869 }
1870 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1871 + sizeof(tHalCfg) + tlvStruct->length) ;
1872
1873 /* QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE */
1874 tlvStruct->type = QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE ;
1875 tlvStruct->length = sizeof(tANI_U32);
1876 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1877
1878 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE,
1879 configDataValue ) != eSIR_SUCCESS)
1880 {
1881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1882 "Failed to get value for WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE");
1883 goto handle_failure;
1884 }
1885 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1886 + sizeof(tHalCfg) + tlvStruct->length) ;
1887
1888 /* QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD */
1889 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD ;
1890 tlvStruct->length = sizeof(tANI_U32);
1891 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1892
1893 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD,
1894 configDataValue ) != eSIR_SUCCESS)
1895 {
1896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1897 "Failed to get value for WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD");
1898 goto handle_failure;
1899 }
1900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1901 + sizeof(tHalCfg) + tlvStruct->length) ;
1902
1903 /* QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD */
1904 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD ;
1905 tlvStruct->length = sizeof(tANI_U32);
1906 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1907
1908 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD,
1909 configDataValue ) != eSIR_SUCCESS)
1910 {
1911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1912 "Failed to get value for WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD");
1913 goto handle_failure;
1914 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1915 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1916 + sizeof(tHalCfg) + tlvStruct->length) ;
1917
Mihir Shetec34258c2014-07-30 17:50:27 +0530[diff] [blame]1918 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP */
1919 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP ;
1920 tlvStruct->length = sizeof(tANI_U32);
1921 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1922
1923 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_SP,
1924 configDataValue ) != eSIR_SUCCESS)
1925 {
1926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1927 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_SP");
1928 goto handle_failure;
1929 }
1930 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1931 + sizeof(tHalCfg) + tlvStruct->length) ;
1932
1933 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT */
1934 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT ;
1935 tlvStruct->length = sizeof(tANI_U32);
1936 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1937
1938 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT,
1939 configDataValue ) != eSIR_SUCCESS)
1940 {
1941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1942 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT");
1943 goto handle_failure;
1944 }
1945 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1946 + sizeof(tHalCfg) + tlvStruct->length) ;
1947
1948 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT */
1949 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT ;
1950 tlvStruct->length = sizeof(tANI_U32);
1951 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1952
1953 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT,
1954 configDataValue ) != eSIR_SUCCESS)
1955 {
1956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1957 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT");
1958 goto handle_failure;
1959 }
1960 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1961 + sizeof(tHalCfg) + tlvStruct->length) ;
1962
1963 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW */
1964 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW ;
1965 tlvStruct->length = sizeof(tANI_U32);
1966 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1967
1968 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW,
1969 configDataValue ) != eSIR_SUCCESS)
1970 {
1971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1972 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW");
1973 goto handle_failure;
1974 }
1975 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1976 + sizeof(tHalCfg) + tlvStruct->length) ;
1977
1978 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW */
1979 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW ;
1980 tlvStruct->length = sizeof(tANI_U32);
1981 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1982
1983 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW,
1984 configDataValue ) != eSIR_SUCCESS)
1985 {
1986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1987 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW");
1988 goto handle_failure;
1989 }
1990 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1991 + sizeof(tHalCfg) + tlvStruct->length) ;
1992
1993 /* QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE */
1994 tlvStruct->type = QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE ;
1995 tlvStruct->length = sizeof(tANI_U32);
1996 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1997
1998 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE,
1999 configDataValue ) != eSIR_SUCCESS)
2000 {
2001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2002 "Failed to get value for WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE");
2003 goto handle_failure;
2004 }
2005 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2006 + sizeof(tHalCfg) + tlvStruct->length) ;
2007
2008 /* QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS */
2009 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS ;
2010 tlvStruct->length = sizeof(tANI_U32);
2011 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2012
2013 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS,
2014 configDataValue ) != eSIR_SUCCESS)
2015 {
2016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2017 "Failed to get value for WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS");
2018 goto handle_failure;
2019 }
2020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2021 + sizeof(tHalCfg) + tlvStruct->length) ;
2022
2023 /* QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS */
2024 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS ;
2025 tlvStruct->length = sizeof(tANI_U32);
2026 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2027
2028 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_DYNAMIC_WMMPS,
2029 configDataValue ) != eSIR_SUCCESS)
2030 {
2031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2032 "Failed to get value for WNI_CFG_ENABLE_DYNAMIC_WMMPS");
2033 goto handle_failure;
2034 }
2035 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2036 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu03d961b2014-09-19 16:45:00 +0530[diff] [blame]2037
2038 /* QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE */
2039 tlvStruct->type = QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE ;
2040 tlvStruct->length = sizeof(tANI_U32);
2041 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2042
2043 if (wlan_cfgGetInt(pMac, WNI_CFG_BURST_MODE_BE_TXOP_VALUE,
2044 configDataValue ) != eSIR_SUCCESS)
2045 {
2046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2047 "Failed to get value for WNI_CFG_BURST_MODE_BE_TXOP_VALUE");
2048 goto handle_failure;
2049 }
2050 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2051 + sizeof(tHalCfg) + tlvStruct->length) ;
2052
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2053 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2054#ifdef WLAN_DEBUG
2055 {
2056 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2057 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2058 "****** Dumping CFG TLV ***** ");
2059 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
2060 {
2061 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2062 "%02x %02x %02x %02x %02x %02x %02x %02x",
2063 tlvStructStart[i],
2064 tlvStructStart[i+1],
2065 tlvStructStart[i+2],
2066 tlvStructStart[i+3],
2067 tlvStructStart[i+4],
2068 tlvStructStart[i+5],
2069 tlvStructStart[i+6],
2070 tlvStructStart[i+7]);
2071 }
2072 /* Dump the bytes in the last line*/
2073 for (; i < wdiStartParams->usConfigBufferLen; i++)
2074 {
2075 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2076 "%02x ",tlvStructStart[i]);
2077 }
2078 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2079 "**************************** ");
2080 }
2081#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2082 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2083handle_failure:
2084 vos_mem_free(configParam);
2085 return VOS_STATUS_E_FAILURE;
2086}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2087/*
2088 * FUNCTION: WDA_wdiCompleteCB
2089 * call the voss call back function
2090 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2091void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2092{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2093 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2094 tWDA_CbContext *wdaContext;
2095
2096 if(NULL == pWdaParams)
2097 {
2098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2099 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2100 VOS_ASSERT(0) ;
2101 return ;
2102 }
2103
2104 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
2105
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2106 if (NULL == wdaContext)
2107 {
2108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2109 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2110 return ;
2111 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2112
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2113 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2114 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2115 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2116 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2117 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2118 vos_mem_free(pWdaParams);
2119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2120 if(WDI_STATUS_SUCCESS != status)
2121 {
2122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2123 "WDI stop callback returned failure" );
2124 VOS_ASSERT(0) ;
2125 }
2126 else
2127 {
2128 wdaContext->wdaState = WDA_STOP_STATE;
2129 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2130
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2131 /* FTM Driver stop procedure should be synced.
2132 * Stop and Close will happen on same context */
2133 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
2134 {
2135 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2136 {
2137 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2138 "%s: FTM Stop Event Set Fail", __func__);
2139 VOS_ASSERT(0);
2140 }
2141 }
2142
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2143 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2144 vos_WDAComplete_cback(wdaContext->pVosContext);
2145
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2146 return ;
2147}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2148/*
2149 * FUNCTION: WDA_stop
2150 * call WDI_stop
2151 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2152VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2153{
2154 WDI_Status wdiStatus;
2155 VOS_STATUS status = VOS_STATUS_SUCCESS;
2156 WDI_StopReqParamsType *wdiStopReq;
2157 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2158 tWDA_ReqParams *pWdaParams ;
2159
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2160 if (NULL == pWDA)
2161 {
2162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2163 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2164 VOS_ASSERT(0);
2165 return VOS_STATUS_E_FAILURE;
2166 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2167 if (pWDA->wdiFailed == true)
2168 {
2169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2170 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2171 return VOS_STATUS_E_ALREADY;
2172 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2173
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2174 /* FTM mode stay START_STATE */
2175 if( (WDA_READY_STATE != pWDA->wdaState) &&
2176 (WDA_INIT_STATE != pWDA->wdaState) &&
2177 (WDA_START_STATE != pWDA->wdaState) )
2178 {
2179 VOS_ASSERT(0);
2180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2181 wdiStopReq = (WDI_StopReqParamsType *)
2182 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2183 if(NULL == wdiStopReq)
2184 {
2185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2186 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2187 VOS_ASSERT(0);
2188 return VOS_STATUS_E_NOMEM;
2189 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2190
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2191 wdiStopReq->wdiStopReason = reason;
2192 wdiStopReq->wdiReqStatusCB = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2193
2194 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2195 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2196 {
2197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2198 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2199 VOS_ASSERT(0);
2200 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2201 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2202 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2203
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2204 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2205 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2206 {
2207 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2208 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2209 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2210
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2211 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2212 pWdaParams->wdaMsgParam = NULL;
2213 pWdaParams->pWdaContext = pWDA;
2214
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2215 /* call WDI stop */
2216 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2217 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2218
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2219 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2220 {
2221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2222 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2223 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2224 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2225 status = VOS_STATUS_E_FAILURE;
2226 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2227
2228 /* FTM Driver stop procedure should be synced.
2229 * Stop and Close will happen on same context */
2230 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2231 {
2232 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2233 WDI_RESPONSE_TIMEOUT);
2234 if (status != VOS_STATUS_SUCCESS)
2235 {
2236 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2237 "%s: FTM Stop Timepoout", __func__);
2238 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2239 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2240 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2241 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2242 return status;
2243}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2244/*
2245 * FUNCTION: WDA_close
2246 * call WDI_close and free the WDA context
2247 */
2248VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2249{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2250 VOS_STATUS status = VOS_STATUS_SUCCESS;
2251 WDI_Status wstatus;
2252 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2253 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2254 if (NULL == wdaContext)
2255 {
2256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2257 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2258 return VOS_STATUS_E_FAILURE;
2259 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2260 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2261 (WDA_STOP_STATE != wdaContext->wdaState))
2262 {
2263 VOS_ASSERT(0);
2264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2265 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2266 wstatus = WDI_Close();
2267 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2268 {
2269 status = VOS_STATUS_E_FAILURE;
2270 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2271 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2272 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2273 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2274 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2275 {
2276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2277 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2278 status = VOS_STATUS_E_FAILURE;
2279 }
2280
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2281 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2282 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2283 {
2284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2285 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2286 status = VOS_STATUS_E_FAILURE;
2287 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2288 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2289 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2290 {
2291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2292 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2293 status = VOS_STATUS_E_FAILURE;
2294 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2295 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2296 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2297 {
2298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2299 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2300 status = VOS_STATUS_E_FAILURE;
2301 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2302 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2303 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2304 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2305 {
2306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2307 "error in WDA close " );
2308 status = VOS_STATUS_E_FAILURE;
2309 }
2310 return status;
2311}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2312/*
2313 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2314 * returns 1 if the compiled version is greater than or equal to the input version
2315 */
2316
2317uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2318{
2319 VOS_STATUS status = VOS_STATUS_SUCCESS;
2320 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2321 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2322 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2323 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2324 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2325 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2326 (compiledVersion.revision >= revision)))
2327 return 1;
2328 else
2329 return 0;
2330}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2331/*
2332 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2333 * returns 1 if the compiled version is greater than or equal to the input version
2334 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2335uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2336{
2337 VOS_STATUS status = VOS_STATUS_SUCCESS;
2338 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2339 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2340 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2341 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2342 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2343 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2344 (reportedVersion.revision >= revision)))
2345 return 1;
2346 else
2347 return 0;
2348}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2349/*
2350 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2351 * Returns the version of the WCNSS WLAN API with which the HOST
2352 * device driver was compiled
2353 */
2354VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2355 tSirVersionType *pVersion)
2356{
2357 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2358 if ((NULL == pvosGCtx) || (NULL == pVersion))
2359 {
2360 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2361 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2362 VOS_ASSERT(0);
2363 return VOS_STATUS_E_FAILURE;
2364 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2365 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2366 if (NULL == pWDA )
2367 {
2368 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2369 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2370 VOS_ASSERT(0);
2371 return VOS_STATUS_E_FAILURE;
2372 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2373 *pVersion = pWDA->wcnssWlanCompiledVersion;
2374 return VOS_STATUS_SUCCESS;
2375}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2376/*
2377 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2378 * Returns the version of the WCNSS WLAN API with which the WCNSS
2379 * device driver was compiled
2380 */
2381VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2382 tSirVersionType *pVersion)
2383{
2384 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2385 if ((NULL == pvosGCtx) || (NULL == pVersion))
2386 {
2387 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2388 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2389 VOS_ASSERT(0);
2390 return VOS_STATUS_E_FAILURE;
2391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2392 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2393 if (NULL == pWDA )
2394 {
2395 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2396 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2397 VOS_ASSERT(0);
2398 return VOS_STATUS_E_FAILURE;
2399 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2400 *pVersion = pWDA->wcnssWlanReportedVersion;
2401 return VOS_STATUS_SUCCESS;
2402}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2403/*
2404 * FUNCTION: WDA_GetWcnssSoftwareVersion
2405 * Returns the WCNSS Software version string
2406 */
2407VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2408 tANI_U8 *pVersion,
2409 tANI_U32 versionBufferSize)
2410{
2411 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2412 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2413 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2414 if ((NULL == pvosGCtx) || (NULL == pVersion))
2415 {
2416 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2417 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2418 VOS_ASSERT(0);
2419 return VOS_STATUS_E_FAILURE;
2420 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2421 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2422 if (NULL == pWDA )
2423 {
2424 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2425 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2426 VOS_ASSERT(0);
2427 return VOS_STATUS_E_FAILURE;
2428 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2429 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2430 return VOS_STATUS_SUCCESS;
2431}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2432/*
2433 * FUNCTION: WDA_GetWcnssHardwareVersion
2434 * Returns the WCNSS Hardware version string
2435 */
2436VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2437 tANI_U8 *pVersion,
2438 tANI_U32 versionBufferSize)
2439{
2440 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2441 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2442 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2443 if ((NULL == pvosGCtx) || (NULL == pVersion))
2444 {
2445 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2446 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2447 VOS_ASSERT(0);
2448 return VOS_STATUS_E_FAILURE;
2449 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2450 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2451 if (NULL == pWDA )
2452 {
2453 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2454 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2455 VOS_ASSERT(0);
2456 return VOS_STATUS_E_FAILURE;
2457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2458 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2459 return VOS_STATUS_SUCCESS;
2460}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2461/*
2462 * FUNCTION: WDA_WniCfgDnld
2463 * Trigger CFG Download
2464 */
2465VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2466{
2467 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2468 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2469
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2470 if (NULL == pMac )
2471 {
2472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2473 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2474 VOS_ASSERT(0);
2475 return VOS_STATUS_E_FAILURE;
2476 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2477 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2478 return vosStatus;
2479}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2480/* -----------------------------------------------------------------
2481 * WDI interface
2482 * -----------------------------------------------------------------
2483 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2484/*
2485 * FUNCTION: WDA_suspendDataTxCallback
2486 * call back function called from TL after suspend Transmission
2487 */
2488VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2489 v_U8_t* ucSTAId,
2490 VOS_STATUS vosStatus)
2491{
2492 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2494 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2495 if (NULL == pWDA )
2496 {
2497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2498 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2499 VOS_ASSERT(0);
2500 return VOS_STATUS_E_FAILURE;
2501 }
2502 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2503 {
2504 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2505 }
2506 else
2507 {
2508 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2509 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2510 /* Trigger the event to bring the WDA TL suspend function to come
2511 * out of wait*/
2512 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2513 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2514 {
2515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2516 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2518 /* If TL suspended had timedout before this callback was called, resume back
2519 * TL.*/
2520 if (pWDA->txSuspendTimedOut)
2521 {
2522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2523 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2524 WDA_ResumeDataTx(pWDA);
2525 pWDA->txSuspendTimedOut = FALSE;
2526 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2527 return VOS_STATUS_SUCCESS;
2528}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2529/*
2530 * FUNCTION: WDA_suspendDataTx
2531 * Update TL to suspend the data Transmission
2532 */
2533VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2534{
2535 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2536 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2537
2538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2539 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2540 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2541 if (pWDA->txSuspendTimedOut)
2542 {
2543 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2544 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2545 return status;
2546 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2547 /* Reset the event to be not signalled */
2548 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2549 if(!VOS_IS_STATUS_SUCCESS(status))
2550 {
2551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2552 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2553 return VOS_STATUS_E_FAILURE;
2554 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2555 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2556 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2557 WDA_SuspendDataTxCallback);
2558 if(status != VOS_STATUS_SUCCESS)
2559 {
2560 return status;
2561 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2562 /* Wait for the event to be set by the TL, to get the response of
2563 * suspending the TX queues, this event should be set by the Callback
2564 * function called by TL*/
2565 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2566 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2567 if(!VOS_IS_STATUS_SUCCESS(status))
2568 {
2569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2570 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2571 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2572 /* Set this flag to true when TL suspend times out, so that when TL
2573 * suspend eventually happens and calls the callback, TL can be resumed
2574 * right away by looking at this flag when true.*/
2575 pWDA->txSuspendTimedOut = TRUE;
2576 }
2577 else
2578 {
2579 pWDA->txSuspendTimedOut = FALSE;
2580 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2581 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2582 {
2583 status = VOS_STATUS_SUCCESS;
2584 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2585 return status;
2586}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2587/*
2588 * FUNCTION: WDA_resumeDataTx
2589 * Update TL to resume the data Transmission
2590 */
2591VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2592{
2593 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2594
2595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2596 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2597
2598 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2599 return status;
2600}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2601/*
2602 * FUNCTION: WDA_InitScanReqCallback
2603 * Trigger Init SCAN callback
2604 */
2605void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2606{
2607 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2608 tWDA_CbContext *pWDA;
2609 tInitScanParams *pWDA_ScanParam ;
2610 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2612 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2613 if(NULL == pWdaParams)
2614 {
2615 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2616 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2617 VOS_ASSERT(0) ;
2618 return ;
2619 }
2620 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2621 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2622 if(NULL == pWDA_ScanParam)
2623 {
2624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2625 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2626 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2627 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2628 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2629 return ;
2630 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2631 if(WDI_STATUS_SUCCESS != wdiStatus)
2632 {
2633 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2634 if(VOS_STATUS_SUCCESS != status)
2635 {
2636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2637 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2638 }
2639 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2640 /* free WDI command buffer */
2641 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2642 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2643
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2644
2645 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2646 /* without converting the Status to Failure or Success Just
2647 pass the same status to lim */
2648 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2649 /* send SCAN RSP message back to PE */
2650 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2651 return ;
2652}
2653
2654/*
2655 * FUNCTION: WDA_ProcessInitScanReq
2656 * Trigger Init SCAN in DAL
2657 */
2658VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2659 tInitScanParams *initScanParams)
2660{
2661 WDI_Status status = WDI_STATUS_SUCCESS ;
2662 WDI_InitScanReqParamsType *wdiInitScanParam =
2663 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2664 sizeof(WDI_InitScanReqParamsType)) ;
2665 tWDA_ReqParams *pWdaParams;
2666 tANI_U8 i = 0;
2667
2668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2669 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2670 if(NULL == wdiInitScanParam)
2671 {
2672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2673 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2674 VOS_ASSERT(0);
2675 return VOS_STATUS_E_NOMEM;
2676 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2677 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2678 if(NULL == pWdaParams)
2679 {
2680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2681 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2682 VOS_ASSERT(0);
2683 vos_mem_free(wdiInitScanParam);
2684 return VOS_STATUS_E_NOMEM;
2685 }
2686
2687 /* Copy init Scan params to WDI structure */
2688 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2689 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2690 sizeof(tSirMacAddr)) ;
2691 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2692 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2693 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2694 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2695 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2696 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2697 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2698 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2699 {
2700 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2701 initScanParams->scanEntry.bssIdx[i] ;
2702 }
2703
2704 /* if Frame length, copy macMgmtHdr or WDI structure */
2705 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2706 {
2707 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2708 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2709 }
2710 wdiInitScanParam->wdiReqStatusCB = NULL ;
2711
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2712 /* Store Init Req pointer, as this will be used for response */
2713 pWdaParams->pWdaContext = pWDA;
2714 pWdaParams->wdaMsgParam = initScanParams;
2715 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2716 /* first try to suspend TX */
2717 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2718 if(WDI_STATUS_SUCCESS != status)
2719 {
2720 goto handleWdiFailure;
2721 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2722 /* call DAL API to pass init scan request to DAL */
2723 status = WDI_InitScanReq(wdiInitScanParam,
2724 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2725 if(IS_WDI_STATUS_FAILURE(status))
2726 {
2727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2728 "error in WDA Init Scan, Resume Tx " );
2729 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2730 VOS_ASSERT(0) ;
2731
2732 goto handleWdiFailure;
2733 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2734 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2735handleWdiFailure:
2736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2737 "Failure in WDI Api, free all the memory " );
2738 /* free WDI command buffer */
2739 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2740 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2741 /* send Failure to PE */
2742 initScanParams->status = eSIR_FAILURE ;
2743 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2744 return CONVERT_WDI2VOS_STATUS(status) ;
2745}
2746
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2747/*
2748 * FUNCTION: WDA_StartScanReqCallback
2749 * send Start SCAN RSP back to PE
2750 */
2751void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2752 void* pUserData)
2753{
2754 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2755 tWDA_CbContext *pWDA;
2756 tStartScanParams *pWDA_ScanParam;
2757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2758 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2759 if(NULL == pWdaParams)
2760 {
2761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2762 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2763 VOS_ASSERT(0) ;
2764 return ;
2765 }
2766 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2767 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2768 if(NULL == pWDA_ScanParam)
2769 {
2770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2771 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2772 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2773 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2774 return ;
2775 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2776 if(NULL == pWdaParams->wdaWdiApiMsgParam)
2777 {
2778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2779 "%s: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2780 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2781 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2782 return ;
2783 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2784 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2785 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2786
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2787
2788 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2789 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2790 /* send SCAN RSP message back to PE */
2791 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2792 return ;
2793}
2794
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2795/*
2796 * FUNCTION: WDA_ProcessStartScanReq
2797 * Trigger start SCAN in WDI
2798 */
2799VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
2800 tStartScanParams *startScanParams)
2801{
2802 WDI_Status status = WDI_STATUS_SUCCESS;
2803 WDI_StartScanReqParamsType *wdiStartScanParams =
2804 (WDI_StartScanReqParamsType *)vos_mem_malloc(
2805 sizeof(WDI_StartScanReqParamsType)) ;
2806 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2808 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2809 if(NULL == wdiStartScanParams)
2810 {
2811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2812 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2813 VOS_ASSERT(0);
2814 return VOS_STATUS_E_NOMEM;
2815 }
2816 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2817 if(NULL == pWdaParams)
2818 {
2819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2820 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2821 VOS_ASSERT(0);
2822 vos_mem_free(wdiStartScanParams);
2823 return VOS_STATUS_E_NOMEM;
2824 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2825 /* Copy init Scan params to WDI structure */
2826 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
2827 wdiStartScanParams->wdiReqStatusCB = NULL ;
2828
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2829 /* Store Init Req pointer, as this will be used for response */
2830 /* store Params pass it to WDI */
2831 pWdaParams->pWdaContext = pWDA;
2832 pWdaParams->wdaMsgParam = startScanParams;
2833 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2834 /* call DAL API to pass init scan request to DAL */
2835 status = WDI_StartScanReq(wdiStartScanParams,
2836 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2837 /* failure returned by WDI API */
2838 if(IS_WDI_STATUS_FAILURE(status))
2839 {
2840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2841 "Failure in Start Scan WDI API, free all the memory "
2842 "It should be due to previous abort scan." );
2843 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2844 vos_mem_free(pWdaParams) ;
2845 startScanParams->status = eSIR_FAILURE ;
2846 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
2847 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2848 return CONVERT_WDI2VOS_STATUS(status) ;
2849}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2850/*
2851 * FUNCTION: WDA_EndScanReqCallback
2852 * END SCAN callback
2853 */
2854void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
2855{
2856 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2857 tWDA_CbContext *pWDA;
2858 tEndScanParams *endScanParam;
2859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2860 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2861 if(NULL == pWdaParams)
2862 {
2863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2864 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2865 VOS_ASSERT(0) ;
2866 return ;
2867 }
2868 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2869 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2870 if(NULL == endScanParam)
2871 {
2872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2873 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2874 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2875 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2876 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2877 return ;
2878 }
2879
2880 /* Free WDI command buffer */
2881 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2882 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2883 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2884 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2885 /* send response back to PE */
2886 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
2887 return ;
2888}
2889
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2890/*
2891 * FUNCTION: WDA_ProcessEndScanReq
2892 * Trigger END SCAN in WDI
2893 */
2894VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
2895 tEndScanParams *endScanParams)
2896{
2897 WDI_Status status = WDI_STATUS_SUCCESS;
2898 WDI_EndScanReqParamsType *wdiEndScanParams =
2899 (WDI_EndScanReqParamsType *)vos_mem_malloc(
2900 sizeof(WDI_EndScanReqParamsType)) ;
2901 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2903 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2904 if(NULL == wdiEndScanParams)
2905 {
2906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2907 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2908 VOS_ASSERT(0);
2909 return VOS_STATUS_E_NOMEM;
2910 }
2911 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2912 if(NULL == pWdaParams)
2913 {
2914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2915 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2916 VOS_ASSERT(0);
2917 vos_mem_free(wdiEndScanParams);
2918 return VOS_STATUS_E_NOMEM;
2919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2920 /* Copy init Scan params to WDI structure */
2921 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
2922 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2923 /* Store Init Req pointer, as this will be used for response */
2924 /* store Params pass it to WDI */
2925 pWdaParams->pWdaContext = pWDA;
2926 pWdaParams->wdaMsgParam = endScanParams;
2927 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2928 /* call DAL API to pass init scan request to DAL */
2929 status = WDI_EndScanReq(wdiEndScanParams,
2930 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2931 if(IS_WDI_STATUS_FAILURE(status))
2932 {
2933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2934 "Failure in End Scan WDI API, free all the memory "
2935 "It should be due to previous abort scan." );
2936 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2937 vos_mem_free(pWdaParams) ;
2938 endScanParams->status = eSIR_FAILURE ;
2939 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
2940 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2941 return CONVERT_WDI2VOS_STATUS(status) ;
2942}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2943/*
2944 * FUNCTION: WDA_FinishScanReqCallback
2945 * Trigger Finish SCAN callback
2946 */
2947void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2948{
2949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2950 tWDA_CbContext *pWDA;
2951 tFinishScanParams *finishScanParam;
2952 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2954 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2955 if(NULL == pWdaParams)
2956 {
2957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2958 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2959 VOS_ASSERT(0) ;
2960 return ;
2961 }
2962
2963 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2964 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2965 if(NULL == finishScanParam)
2966 {
2967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2968 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2969 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2970 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2971 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2972 return ;
2973 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2974 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2975 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2976 /*
2977 * Now Resume TX, if we reached here means, TX is already suspended, we
2978 * have to resume it unconditionaly
2979 */
2980 status = WDA_ResumeDataTx(pWDA) ;
2981
2982 if(VOS_STATUS_SUCCESS != status)
2983 {
2984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2985 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2986 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2987 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2988 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
2989 return ;
2990}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2991/*
2992 * FUNCTION: WDA_ProcessFinshScanReq
2993 * Trigger Finish SCAN in WDI
2994 */
2995VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
2996 tFinishScanParams *finishScanParams)
2997{
2998 WDI_Status status = WDI_STATUS_SUCCESS;
2999 WDI_FinishScanReqParamsType *wdiFinishScanParams =
3000 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
3001 sizeof(WDI_FinishScanReqParamsType)) ;
3002 tWDA_ReqParams *pWdaParams ;
3003 tANI_U8 i = 0;
3004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3005 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3006 if(NULL == wdiFinishScanParams)
3007 {
3008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3009 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3010 VOS_ASSERT(0);
3011 return VOS_STATUS_E_NOMEM;
3012 }
3013 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3014 if(NULL == pWdaParams)
3015 {
3016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3017 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3018 VOS_ASSERT(0);
3019 vos_mem_free(wdiFinishScanParams);
3020 return VOS_STATUS_E_NOMEM;
3021 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3022 /* Copy init Scan params to WDI structure */
3023 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
3024 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
3025 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3026 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
3027 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
3028 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
3029 finishScanParams->frameLength ;
3030 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
3031 finishScanParams->currentOperChannel ;
3032 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
3033 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
3034 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3035 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
3036 {
3037 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
3038 finishScanParams->scanEntry.bssIdx[i] ;
3039 }
3040
3041
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3042 /* if Frame length, copy macMgmtHdr ro WDI structure */
3043 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
3044 {
3045 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
3046 &finishScanParams->macMgmtHdr,
3047 sizeof(WDI_MacMgmtHdr)) ;
3048 }
3049 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3050 /* Store Init Req pointer, as this will be used for response */
3051 /* store Params pass it to WDI */
3052 pWdaParams->pWdaContext = pWDA;
3053 pWdaParams->wdaMsgParam = finishScanParams;
3054 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3055 /* call DAL API to pass init scan request to DAL */
3056 status = WDI_FinishScanReq(wdiFinishScanParams,
3057 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3058
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3059
3060 /*
3061 * WDI API returns failure..
3062 */
3063 if(IS_WDI_STATUS_FAILURE( status))
3064 {
3065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3066 "Failure in Finish Scan WDI API, free all the memory " );
3067 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3068 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3069 finishScanParams->status = eSIR_FAILURE ;
3070 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
3071 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3072 return CONVERT_WDI2VOS_STATUS(status) ;
3073}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3074/*---------------------------------------------------------------------
3075 * ASSOC API's
3076 *---------------------------------------------------------------------
3077 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3078/*
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3079 * FUNCTION: WDA_JoinRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3080 * Trigger Init SCAN callback
3081 */
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3082void WDA_JoinRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3083{
3084 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3085 tWDA_CbContext *pWDA;
3086 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3088 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3089 if(NULL == pWdaParams)
3090 {
3091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3092 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3093 VOS_ASSERT(0) ;
3094 return ;
3095 }
3096 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3097 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3098 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3099 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3100 /* reset macBSSID */
3101 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3102 /* reset macSTASelf */
3103 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3104 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3105 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3106 return ;
3107}
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3108
3109/*
3110 * FUNCTION: WDA_JoinReqCallback
3111 * Free memory and send SWITCH CHANNEL RSP back to PE.
3112 * Invoked when Enter JOIN REQ failed in WDI and no RSP callback is generated.
3113 */
3114void WDA_JoinReqCallback(WDI_Status wdiStatus, void* pUserData)
3115{
3116 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3117 tWDA_CbContext *pWDA;
3118 tSwitchChannelParams *joinReqParam;
3119
3120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3121 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
3122
3123 if(NULL == pWdaParams)
3124 {
3125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3126 "%s: pWdaParams received NULL", __func__);
3127 VOS_ASSERT(0);
3128 return;
3129 }
3130
3131 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3132 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3133 joinReqParam->status = wdiStatus;
3134
3135 if(IS_WDI_STATUS_FAILURE(wdiStatus))
3136 {
3137 /* reset macBSSID */
3138 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
3139 /* reset macSTASelf */
3140 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
3141
3142 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3143 vos_mem_free(pWdaParams);
3144 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
3145 }
3146
3147 return;
3148}
3149
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3150/*
3151 * FUNCTION: WDA_ProcessJoinReq
3152 * Trigger Join REQ in WDI
3153 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3154VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
3155 tSwitchChannelParams* joinReqParam)
3156{
3157 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3158 WDI_JoinReqParamsType *wdiJoinReqParam =
3159 (WDI_JoinReqParamsType *)vos_mem_malloc(
3160 sizeof(WDI_JoinReqParamsType)) ;
3161 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3162 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3163 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3164 if(NULL == wdiJoinReqParam)
3165 {
3166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3167 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3168 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3169 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3170 return VOS_STATUS_E_NOMEM;
3171 }
3172 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3173 if(NULL == pWdaParams)
3174 {
3175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3176 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3177 VOS_ASSERT(0);
3178 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3179 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3180 return VOS_STATUS_E_NOMEM;
3181 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3182
3183 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3184 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3185 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3186 {
3187 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3188 "%s: received join request when BSSID or self-STA is NULL "
3189 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3190 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3191 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3192 VOS_ASSERT(0);
3193 vos_mem_free(wdiJoinReqParam);
3194 vos_mem_free(pWdaParams);
3195 joinReqParam->status = eSIR_FAILURE ;
3196 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3197 return VOS_STATUS_E_INVAL;
3198 }
3199
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3200 /* copy the BSSID for pWDA */
3201 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3202 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3203 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3204 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3205 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3206 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3207#ifdef WLAN_FEATURE_VOWIFI
3208 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3209 joinReqParam->maxTxPower ;
3210#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3211 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3212 joinReqParam->localPowerConstraint ;
3213#endif
3214 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3215 joinReqParam->secondaryChannelOffset ;
3216 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3217
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3218 wdiJoinReqParam->wdiReqStatusCB = WDA_JoinReqCallback;
3219 wdiJoinReqParam->pUserData = pWdaParams;
3220
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3221 /* Store Init Req pointer, as this will be used for response */
3222 /* store Params pass it to WDI */
3223 pWdaParams->pWdaContext = pWDA;
3224 pWdaParams->wdaMsgParam = joinReqParam;
3225 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3226 status = WDI_JoinReq(wdiJoinReqParam,
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3227 (WDI_JoinRspCb )WDA_JoinRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3228 if(IS_WDI_STATUS_FAILURE(status))
3229 {
3230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3231 "Failure in Join WDI API, free all the memory " );
3232 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3233 vos_mem_free(pWdaParams) ;
3234 joinReqParam->status = eSIR_FAILURE ;
3235 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3236 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3237 return CONVERT_WDI2VOS_STATUS(status) ;
3238}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3239/*
3240 * FUNCTION: WDA_SwitchChannelReqCallback
3241 * send Switch channel RSP back to PE
3242 */
3243void WDA_SwitchChannelReqCallback(
3244 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3245{
3246 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3247 tWDA_CbContext *pWDA;
3248 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3250 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3251 if(NULL == pWdaParams)
3252 {
3253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3254 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3255 VOS_ASSERT(0) ;
3256 return ;
3257 }
3258 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3259 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3260
3261#ifdef WLAN_FEATURE_VOWIFI
3262 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3263#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3264 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3265 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3266 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3267 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3268 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3269 return ;
3270}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3271/*
3272 * FUNCTION: WDA_ProcessChannelSwitchReq
3273 * Request to WDI to switch channel REQ params.
3274 */
3275VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3276 tSwitchChannelParams *pSwitchChanParams)
3277{
3278 WDI_Status status = WDI_STATUS_SUCCESS ;
3279 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3280 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3281 sizeof(WDI_SwitchChReqParamsType)) ;
3282 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3283 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3284 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3285 if(NULL == wdiSwitchChanParam)
3286 {
3287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3288 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3289 VOS_ASSERT(0);
3290 return VOS_STATUS_E_NOMEM;
3291 }
3292 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3293 if(NULL == pWdaParams)
3294 {
3295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3296 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3297 VOS_ASSERT(0);
3298 vos_mem_free(wdiSwitchChanParam);
3299 return VOS_STATUS_E_NOMEM;
3300 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3301 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3302#ifndef WLAN_FEATURE_VOWIFI
3303 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3304 pSwitchChanParams->localPowerConstraint;
3305#endif
3306 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3307 pSwitchChanParams->secondaryChannelOffset;
3308 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3309 /* Store req pointer, as this will be used for response */
3310 /* store Params pass it to WDI */
3311 pWdaParams->pWdaContext = pWDA;
3312 pWdaParams->wdaMsgParam = pSwitchChanParams;
3313 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3314#ifdef WLAN_FEATURE_VOWIFI
3315 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3316 = pSwitchChanParams->maxTxPower;
3317 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3318 pSwitchChanParams ->selfStaMacAddr,
3319 sizeof(tSirMacAddr));
3320#endif
3321 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3322 pSwitchChanParams->bssId,
3323 sizeof(tSirMacAddr));
3324
3325 status = WDI_SwitchChReq(wdiSwitchChanParam,
3326 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3327 if(IS_WDI_STATUS_FAILURE(status))
3328 {
3329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3330 "Failure in process channel switch Req WDI API, free all the memory " );
3331 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3332 vos_mem_free(pWdaParams) ;
3333 pSwitchChanParams->status = eSIR_FAILURE ;
3334 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3335 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3336 return CONVERT_WDI2VOS_STATUS(status) ;
3337}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3338
3339/*
3340 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3341 * send Switch channel RSP back to PE
3342 */
3343void WDA_SwitchChannelReqCallback_V1(
3344 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3345 void* pUserData)
3346{
3347 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3348 tWDA_CbContext *pWDA;
3349 tSwitchChannelParams *pSwitchChanParams;
3350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3351 "<------ %s " ,__func__);
3352
3353 if (NULL == pWdaParams)
3354 {
3355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3356 "%s: pWdaParams received NULL", __func__);
3357 VOS_ASSERT(0);
3358 return ;
3359 }
3360 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3361 pSwitchChanParams =
3362 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3363 pSwitchChanParams->channelSwitchSrc =
3364 wdiSwitchChanRsp->channelSwitchSrc;
3365#ifdef WLAN_FEATURE_VOWIFI
3366 pSwitchChanParams->txMgmtPower =
3367 wdiSwitchChanRsp->ucTxMgmtPower;
3368#endif
3369 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3370 vos_mem_free(pWdaParams);
3371 pSwitchChanParams->status =
3372 wdiSwitchChanRsp->wdiStatus ;
3373 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3374 (void *)pSwitchChanParams , 0);
3375 return;
3376}
3377
3378/*
3379 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3380 * Request to WDI to switch channel REQ params.
3381 */
3382VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3383 tSwitchChannelParams *pSwitchChanParams)
3384{
3385 WDI_Status status = WDI_STATUS_SUCCESS ;
3386 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3387 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3388 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3389 tWDA_ReqParams *pWdaParams ;
3390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3391 "------> %s " ,__func__);
3392 if (NULL == wdiSwitchChanParam)
3393 {
3394 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3395 "%s: VOS MEM Alloc Failure", __func__);
3396 VOS_ASSERT(0);
3397 return VOS_STATUS_E_NOMEM;
3398 }
3399 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3400 if (NULL == pWdaParams)
3401 {
3402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3403 "%s: VOS MEM Alloc Failure", __func__);
3404 VOS_ASSERT(0);
3405 vos_mem_free(wdiSwitchChanParam);
3406 return VOS_STATUS_E_NOMEM;
3407 }
3408 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3409 pSwitchChanParams->channelSwitchSrc;
3410
3411 wdiSwitchChanParam->wdiChInfo.ucChannel =
3412 pSwitchChanParams->channelNumber;
3413#ifndef WLAN_FEATURE_VOWIFI
3414 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3415 pSwitchChanParams->localPowerConstraint;
3416#endif
3417 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3418 pSwitchChanParams->secondaryChannelOffset;
3419 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3420 /* Store req pointer, as this will be used for response */
3421 /* store Params pass it to WDI */
3422 pWdaParams->pWdaContext = pWDA;
3423 pWdaParams->wdaMsgParam = pSwitchChanParams;
3424 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3425#ifdef WLAN_FEATURE_VOWIFI
3426 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3427 pSwitchChanParams->maxTxPower;
3428 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3429 pSwitchChanParams ->selfStaMacAddr,
3430 sizeof(tSirMacAddr));
3431#endif
3432 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3433 pSwitchChanParams->bssId,
3434 sizeof(tSirMacAddr));
3435
3436 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3437 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3438 pWdaParams);
3439 if (IS_WDI_STATUS_FAILURE(status))
3440 {
3441 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3442 "Failure in process channel switch Req WDI "
3443 "API, free all the memory " );
3444 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3445 vos_mem_free(pWdaParams) ;
3446 pSwitchChanParams->status = eSIR_FAILURE ;
3447 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3448 (void *)pSwitchChanParams, 0) ;
3449 }
3450 return CONVERT_WDI2VOS_STATUS(status) ;
3451}
3452
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3453/*
3454 * FUNCTION: WDA_ConfigBssReqCallback
3455 * config BSS Req Callback, called by WDI
3456 */
3457void WDA_ConfigBssReqCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
3458 ,void* pUserData)
3459{
3460 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3461 tWDA_CbContext *pWDA;
3462 tAddBssParams *configBssReqParam;
3463 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3465 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3466 if(NULL == pWdaParams)
3467 {
3468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3469 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3470 VOS_ASSERT(0) ;
3471 return ;
3472 }
3473 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3474 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3475 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3476 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3477 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3478 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3479 {
3480 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3481 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3482 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3483 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3484 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3485
3486 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3487 {
3488 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3489 {
3490 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3491 staConfigBssParam->staType = STA_ENTRY_BSSID;
3492 }
3493 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3494 (staConfigBssParam->staType == STA_ENTRY_SELF))
3495 {
3496 /* This is the 1st add BSS Req for the BTAMP STA */
3497 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3498 staConfigBssParam->staType = STA_ENTRY_BSSID;
3499 }
3500 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3501 (staConfigBssParam->staType == STA_ENTRY_PEER))
3502 {
3503 /* This is the 2nd ADD BSS Request that is sent
3504 * on the BTAMP STA side. The Sta type is
3505 * set to STA_ENTRY_PEER here.*/
3506 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3507 }
3508 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3509 (staConfigBssParam->staType == STA_ENTRY_SELF))
3510 {
3511 /* statype is already set by PE.
3512 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3513 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3514 staConfigBssParam->staType = STA_ENTRY_BSSID;
3515 }
3516 else
3517 {
3518 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3519 staConfigBssParam->staType = STA_ENTRY_PEER;
3520 }
3521 }
3522 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3523 {
3524 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3525 staConfigBssParam->staType = STA_ENTRY_SELF;
3526 }
3527 else
3528 {
3529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3530 "Invalid operation mode specified");
3531 VOS_ASSERT(0);
3532 }
3533
3534 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3535 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3536 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3537 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3538 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3539 sizeof(tSirMacAddr));
3540 staConfigBssParam->txChannelWidthSet =
3541 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3542 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3543 staConfigBssParam->htCapable)
3544 {
3545 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3546 wdiConfigBssRsp->ucBSSIdx;
3547 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3548 WDA_VALID_STA_INDEX ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]3549 pWDA->wdaStaInfo[staConfigBssParam->staIdx].currentOperChan =
3550 configBssReqParam->currentOperChannel;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3551 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3552 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3553 wdiConfigBssRsp->ucBSSIdx,
3554 wdiConfigBssRsp->ucSTAIdx))
3555 {
3556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3557 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3558 VOS_ASSERT(0) ;
3559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3560 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3561 {
3562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3563 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3564 VOS_ASSERT(0) ;
3565 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3566#ifdef WLAN_FEATURE_VOWIFI
3567 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3568#endif
3569 }
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame^]3570 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
3571 sizeof(WDI_ConfigBSSReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3572 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3573 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3574 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3575 return ;
3576}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3577/*
3578 * FUNCTION: WDA_UpdateEdcaParamsForAC
3579 * Update WDI EDCA params with PE edca params
3580 */
3581void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3582 WDI_EdcaParamRecord *wdiEdcaParam,
3583 tSirMacEdcaParamRecord *macEdcaParam)
3584{
3585 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3586 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3587 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3588 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3589 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3590 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3591}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3592/*
3593 * FUNCTION: WDA_ProcessConfigBssReq
3594 * Configure BSS before starting Assoc with AP
3595 */
3596VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3597 tAddBssParams* configBssReqParam)
3598{
3599 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3600 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3601 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3603 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3604 if (NULL == configBssReqParam)
3605 {
3606 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3607 "%s: configBssReqParam is NULL", __func__);
3608 return VOS_STATUS_E_INVAL;
3609 }
3610
3611 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3612 sizeof(WDI_ConfigBSSReqParamsType)) ;
3613
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3614 if(NULL == wdiConfigBssReqParam)
3615 {
3616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3617 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3618 VOS_ASSERT(0);
3619 return VOS_STATUS_E_NOMEM;
3620 }
3621 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3622 if(NULL == pWdaParams)
3623 {
3624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3625 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3626 VOS_ASSERT(0);
3627 vos_mem_free(wdiConfigBssReqParam);
3628 return VOS_STATUS_E_NOMEM;
3629 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3630 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3631 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3632 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3633 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3634 configBssReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3635 /* Store Init Req pointer, as this will be used for response */
3636 /* store Params pass it to WDI */
3637 pWdaParams->pWdaContext = pWDA;
3638 pWdaParams->wdaMsgParam = configBssReqParam;
3639 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3640 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
3641 (WDI_ConfigBSSRspCb )WDA_ConfigBssReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3642 if(IS_WDI_STATUS_FAILURE(status))
3643 {
3644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3645 "Failure in Config BSS WDI API, free all the memory " );
3646 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3647 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3648 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3649 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3650 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3651 return CONVERT_WDI2VOS_STATUS(status) ;
3652}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3653#ifdef ENABLE_HAL_COMBINED_MESSAGES
3654/*
3655 * FUNCTION: WDA_PostAssocReqCallback
3656 * Post ASSOC req callback, send RSP back to PE
3657 */
3658void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3659 void* pUserData)
3660{
3661 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3662 tPostAssocParams *postAssocReqParam =
3663 (tPostAssocParams *)pWDA->wdaMsgParam ;
3664 /*STA context within the BSS Params*/
3665 tAddStaParams *staPostAssocParam =
3666 &postAssocReqParam->addBssParams.staContext ;
3667 /*STA Params for self STA*/
3668 tAddStaParams *selfStaPostAssocParam =
3669 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3670 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3671 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3672 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3673 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3674 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3675 {
3676 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3677 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3678 sizeof(tSirMacAddr)) ;
3679 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3680 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3681 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3682 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3683 }
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame^]3684 vos_mem_zero(pWDA->wdaWdiApiMsgParam, sizeof(WDI_PostAssocReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3685 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3686 pWDA->wdaWdiApiMsgParam = NULL;
3687 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3688 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3689 return ;
3690}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3691/*
3692 * FUNCTION: WDA_ProcessPostAssocReq
3693 * Trigger POST ASSOC processing in WDI
3694 */
3695VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3696 tPostAssocParams *postAssocReqParam)
3697{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3698 WDI_Status status = WDI_STATUS_SUCCESS ;
3699
3700 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3701 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3702 sizeof(WDI_PostAssocReqParamsType)) ;
3703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3704 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3705
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3706 if(NULL == wdiPostAssocReqParam)
3707 {
3708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3709 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3710 VOS_ASSERT(0);
3711 return VOS_STATUS_E_NOMEM;
3712 }
3713
3714 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3715 {
3716 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3717 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3718 VOS_ASSERT(0);
3719 return VOS_STATUS_E_FAILURE;
3720 }
3721
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3722 /* update BSS params into WDI structure */
3723 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3724 &postAssocReqParam->addBssParams) ;
3725 /* update STA params into WDI structure */
3726 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3727 &postAssocReqParam->addStaParams) ;
3728
3729 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
3730 postAssocReqParam->addBssParams.highPerformance;
3731 WDA_UpdateEdcaParamsForAC(pWDA,
3732 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
3733 &postAssocReqParam->addBssParams.acbe);
3734 WDA_UpdateEdcaParamsForAC(pWDA,
3735 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
3736 &postAssocReqParam->addBssParams.acbk);
3737 WDA_UpdateEdcaParamsForAC(pWDA,
3738 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
3739 &postAssocReqParam->addBssParams.acvi);
3740 WDA_UpdateEdcaParamsForAC(pWDA,
3741 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
3742 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3743 /* Store Init Req pointer, as this will be used for response */
3744 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3745 /* store Params pass it to WDI */
3746 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3747 status = WDI_PostAssocReq(wdiPostAssocReqParam,
3748 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3749 if(IS_WDI_STATUS_FAILURE(status))
3750 {
3751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3752 "Failure in Post Assoc WDI API, free all the memory " );
3753 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3754 pWDA->wdaWdiApiMsgParam = NULL;
3755 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3756 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3757 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
3758 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3759 return CONVERT_WDI2VOS_STATUS(status) ;
3760}
3761#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3762/*
3763 * FUNCTION: WDA_AddStaReqCallback
3764 * ADD STA req callback, send RSP back to PE
3765 */
3766void WDA_AddStaReqCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
3767 void* pUserData)
3768{
3769 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3770 tWDA_CbContext *pWDA;
3771 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3773 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3774 if(NULL == pWdaParams)
3775 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3776 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]3777 VOS_ASSERT(0) ;
3778 return ;
3779 }
3780 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3781 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3782 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3783 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3784 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
3785 {
3786 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
3787 /*TODO: UMAC structure doesn't have these fields*/
3788 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
3789 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
3790 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
3791 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
3792 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
3793 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3794#ifdef FEATURE_WLAN_TDLS
3795 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
3796 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
3797#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3798 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3799#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3800 {
3801 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
3802 wdiConfigStaRsp->ucBssIdx;
3803 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
3804 WDA_VALID_STA_INDEX ;
Abhishek Singhf08a82b2014-10-07 11:00:42 +0530[diff] [blame]3805 pWDA->wdaStaInfo[addStaReqParam->staIdx].currentOperChan =
3806 addStaReqParam->currentOperChan;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3807 }
3808 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
3809 {
3810 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3811 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3812 VOS_ASSERT(0) ;
3813 return ;
3814 }
3815 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3816 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3817 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3818 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3819 return ;
3820}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3821/*
3822 * FUNCTION: WDA_ConfigStaReq
3823 * Trigger Config STA processing in WDI
3824 */
3825VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
3826 tAddStaParams *addStaReqParam)
3827{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3828 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3829 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
3830 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
3831 sizeof(WDI_ConfigSTAReqParamsType)) ;
3832 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3834 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3835 if(NULL == wdiConfigStaReqParam)
3836 {
3837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3838 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3839 VOS_ASSERT(0);
3840 return VOS_STATUS_E_NOMEM;
3841 }
3842 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3843 if(NULL == pWdaParams)
3844 {
3845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3846 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3847 VOS_ASSERT(0);
3848 vos_mem_free(wdiConfigStaReqParam);
3849 return VOS_STATUS_E_NOMEM;
3850 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3851 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3852 /* update STA params into WDI structure */
3853 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
3854 addStaReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3855 /* Store Init Req pointer, as this will be used for response */
3856 /* store Params pass it to WDI */
3857 pWdaParams->pWdaContext = pWDA;
3858 pWdaParams->wdaMsgParam = addStaReqParam;
3859 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3860 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
3861 (WDI_ConfigSTARspCb )WDA_AddStaReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3862 if(IS_WDI_STATUS_FAILURE(status))
3863 {
3864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3865 "Failure in Config STA WDI API, free all the memory " );
3866 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3867 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3868 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3869 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
3870 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3871 return CONVERT_WDI2VOS_STATUS(status) ;
3872}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3873/*
3874 * FUNCTION: WDA_DelBSSReqCallback
3875 * Dens DEL BSS RSP back to PE
3876 */
3877void WDA_DelBSSReqCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
3878 void* pUserData)
3879{
3880 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3881 tWDA_CbContext *pWDA;
3882 tDeleteBssParams *delBssReqParam;
3883 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3885 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3886 if(NULL == pWdaParams)
3887 {
3888 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3889 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3890 VOS_ASSERT(0) ;
3891 return ;
3892 }
3893 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3894 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3895 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3896 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
3897 {
3898 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
3899 sizeof(tSirMacAddr)) ;
3900 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3901 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
3902 {
3903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3904 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3905 VOS_ASSERT(0) ;
3906 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3907 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
3908 {
3909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3910 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3911 VOS_ASSERT(0) ;
3912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3913 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
3914 {
3915 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3916 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3917 VOS_ASSERT(0) ;
3918 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3919
3920 WLANTL_StartForwarding(staIdx,0,0);
3921
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3922 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3923 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3924 /* reset the the system role*/
3925 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
3926
3927 /* Reset the BA related information */
3928 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
3929 {
3930 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
3931 {
3932 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
3933 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]3934 pWDA->wdaStaInfo[staIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3935 /* Reset framesTxed counters here */
3936 for(tid = 0; tid < STACFG_MAX_TC; tid++)
3937 {
3938 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
3939 }
3940 }
3941 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3942 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3943 return ;
3944}
3945
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3946/*
3947 * FUNCTION: WDA_ProcessDelBssReq
3948 * Init DEL BSS req with WDI
3949 */
3950VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
3951 tDeleteBssParams *delBssParam)
3952{
3953 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3954 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
3955 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
3956 sizeof(WDI_DelBSSReqParamsType)) ;
3957 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3959 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3960 if(NULL == wdiDelBssReqParam)
3961 {
3962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3963 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3964 VOS_ASSERT(0);
3965 return VOS_STATUS_E_NOMEM;
3966 }
3967 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3968 if(NULL == pWdaParams)
3969 {
3970 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3971 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3972 VOS_ASSERT(0);
3973 vos_mem_free(wdiDelBssReqParam);
3974 return VOS_STATUS_E_NOMEM;
3975 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3976 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
3977 wdiDelBssReqParam->wdiReqStatusCB = NULL ;
3978
3979 /* Store Init Req pointer, as this will be used for response */
3980 /* store Params pass it to WDI */
3981 pWdaParams->pWdaContext = pWDA;
3982 pWdaParams->wdaMsgParam = delBssParam;
3983 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3984 status = WDI_DelBSSReq(wdiDelBssReqParam,
3985 (WDI_DelBSSRspCb )WDA_DelBSSReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3986 if(IS_WDI_STATUS_FAILURE(status))
3987 {
3988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3989 "Failure in Del BSS WDI API, free all the memory " );
3990 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3991 vos_mem_free(pWdaParams) ;
3992 delBssParam->status = eSIR_FAILURE ;
3993 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
3994 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3995 return CONVERT_WDI2VOS_STATUS(status) ;
3996}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3997/*
3998 * FUNCTION: WDA_DelSTAReqCallback
3999 * Dens DEL STA RSP back to PE
4000 */
4001void WDA_DelSTAReqCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
4002 void* pUserData)
4003{
4004 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4005 tWDA_CbContext *pWDA;
4006 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4007 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4008 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4009 if(NULL == pWdaParams)
4010 {
4011 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4012 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4013 VOS_ASSERT(0) ;
4014 return ;
4015 }
4016 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4017 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4018 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4019 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
4020 {
4021 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
4022 {
4023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4024 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4025 VOS_ASSERT(0) ;
4026 }
4027 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4028 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4029 }
4030 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4031 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4032 /*Reset the BA information corresponding to this STAIdx */
4033 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
4034 WDA_INVALID_STA_INDEX;
4035 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]4036 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4037 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4038 return ;
4039}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4040/*
4041 * FUNCTION: WDA_ProcessDelStaReq
4042 * Init DEL STA req with WDI
4043 */
4044VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
4045 tDeleteStaParams *delStaParam)
4046{
4047 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4048 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
4049 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
4050 sizeof(WDI_DelSTAReqParamsType)) ;
4051 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4053 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4054 if(NULL == wdiDelStaReqParam)
4055 {
4056 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4057 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4058 VOS_ASSERT(0);
4059 return VOS_STATUS_E_NOMEM;
4060 }
4061 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4062 if(NULL == pWdaParams)
4063 {
4064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4065 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4066 VOS_ASSERT(0);
4067 vos_mem_free(wdiDelStaReqParam);
4068 return VOS_STATUS_E_NOMEM;
4069 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4070 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
4071 wdiDelStaReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4072 /* Store Init Req pointer, as this will be used for response */
4073 /* store Params pass it to WDI */
4074 pWdaParams->pWdaContext = pWDA;
4075 pWdaParams->wdaMsgParam = delStaParam;
4076 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4077 status = WDI_DelSTAReq(wdiDelStaReqParam,
4078 (WDI_DelSTARspCb )WDA_DelSTAReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4079 if(IS_WDI_STATUS_FAILURE(status))
4080 {
4081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4082 "Failure in Del STA WDI API, free all the memory status = %d",
4083 status );
4084 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4085 vos_mem_free(pWdaParams) ;
4086 delStaParam->status = eSIR_FAILURE ;
4087 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
4088 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4089 return CONVERT_WDI2VOS_STATUS(status) ;
4090}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4091void WDA_ProcessAddStaSelfRsp(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
4092{
4093 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4094 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4095 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4097 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4098 if(NULL == pWdaParams)
4099 {
4100 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4101 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4102 VOS_ASSERT(0) ;
4103 return ;
4104 }
4105 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4106 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4107 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4108 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4109 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
4110 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
4111 pwdiAddSTASelfRsp->macSelfSta,
4112 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4113 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
4114 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
4115 if (pAddStaSelfRsp->status == eSIR_FAILURE)
4116 {
4117 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
4118 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
4119 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4120 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4121 return ;
4122}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4123
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4124/*
4125 * FUNCTION: WDA_ProcessAddStaSelfReq
4126 *
4127 */
4128VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
4129{
4130 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4131 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4132 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
4133 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
4134 sizeof(WDI_AddSTASelfReqParamsType)) ;
4135 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4136 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4137 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4138 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4139 if( NULL == wdiAddStaSelfReq )
4140 {
4141 VOS_ASSERT( 0 );
4142 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4143 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4144 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4145 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4146 return( VOS_STATUS_E_NOMEM );
4147 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4148 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4149 if( NULL == pWdaParams )
4150 {
4151 VOS_ASSERT( 0 );
4152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4153 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4154 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4155 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4156 vos_mem_free(wdiAddStaSelfReq) ;
4157 return( VOS_STATUS_E_NOMEM );
4158 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4159 wdiAddStaSelfReq->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4160 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]4161 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4162 /* Store Init Req pointer, as this will be used for response */
4163 /* store Params pass it to WDI */
4164 pWdaParams->pWdaContext = pWDA;
4165 pWdaParams->wdaMsgParam = pAddStaSelfReq;
4166 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4167 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq, WDA_ProcessAddStaSelfRsp, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4168
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4169 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4170 {
4171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4172 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4173 wstatus );
4174 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4175 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4176 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4177 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
4178 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4179 pAddStaSelfReq->status = eSIR_FAILURE ;
4180 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
4181 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4182 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4183}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4184/*
4185 * FUNCTION: WDA_DelSTASelfRespCallback
4186 *
4187 */
4188void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4189 wdiDelStaSelfRspParams , void* pUserData)
4190{
4191 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4192 tWDA_CbContext *pWDA;
4193 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4195 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4196 if (NULL == pWdaParams)
4197 {
4198 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4199 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4200 VOS_ASSERT(0);
4201 return;
4202 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4203 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4204 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4205 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4206 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4207
4208 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4209 vos_mem_free(pWdaParams) ;
4210
4211 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4212 return ;
4213}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4214/*
4215 * FUNCTION: WDA_DelSTASelfReqCallback
4216 *
4217 */
4218void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4219 void* pUserData)
4220{
4221 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4222 tWDA_CbContext *pWDA;
4223 tDelStaSelfParams *delStaSelfParams;
4224
4225 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4226 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4227 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4228
4229 if (NULL == pWdaParams)
4230 {
4231 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4232 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4233 VOS_ASSERT(0);
4234 return;
4235 }
4236
4237 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4238 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4239
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4240 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4241
4242 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4243 {
4244 VOS_ASSERT(0);
4245 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4246 vos_mem_free(pWdaParams) ;
4247 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4248 }
4249
4250 return ;
4251}
4252
4253/*
4254 * FUNCTION: WDA_DelSTASelfReq
4255 * Trigger Config STA processing in WDI
4256 */
4257VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4258 tDelStaSelfParams* pDelStaSelfReqParam)
4259{
4260 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4261 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4262 tWDA_ReqParams *pWdaParams = NULL;
4263 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4264 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4265 sizeof(WDI_DelSTASelfReqParamsType)) ;
4266
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4268 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4269 if( NULL == wdiDelStaSelfReq )
4270 {
4271 VOS_ASSERT( 0 );
4272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4273 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4274 return( VOS_STATUS_E_NOMEM );
4275 }
4276
4277 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4278 if( NULL == pWdaParams )
4279 {
4280 VOS_ASSERT( 0 );
4281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4282 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4283 vos_mem_free(wdiDelStaSelfReq) ;
4284 return( VOS_STATUS_E_NOMEM );
4285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4286 pWdaParams->pWdaContext = pWDA;
4287 /* Store param pointer as passed in by caller */
4288 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4289 /* store Params pass it to WDI */
4290 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4291 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4292 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4293
4294 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4295 wdiDelStaSelfReq->pUserData = pWdaParams;
4296
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4297 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4298 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4299
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4300 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4301 {
4302 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4303 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4304 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4305 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4306 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4307 vos_mem_free(pWdaParams) ;
4308 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4309 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4310 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4311 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4312}
4313
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4314/*
4315 * FUNCTION: WDA_SendMsg
4316 * Send Message back to PE
4317 */
4318void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4319 void *pBodyptr, tANI_U32 bodyVal)
4320{
4321 tSirMsgQ msg = {0} ;
4322 tANI_U32 status = VOS_STATUS_SUCCESS ;
4323 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4324 msg.type = msgType;
4325 msg.bodyval = bodyVal;
4326 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4327 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4328 if (VOS_STATUS_SUCCESS != status)
4329 {
4330 if(NULL != pBodyptr)
4331 {
4332 vos_mem_free(pBodyptr);
4333 }
4334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4335 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4336 VOS_ASSERT(0) ;
4337 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4338 return ;
4339}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4340/*
4341 * FUNCTION: WDA_UpdateBSSParams
4342 * Translated WDA/PE BSS info into WDI BSS info..
4343 */
4344void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4345 WDI_ConfigBSSReqInfoType *wdiBssParams,
4346 tAddBssParams *wdaBssParams)
4347{
4348 v_U8_t keyIndex = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4349 /* copy bssReq Params to WDI structure */
4350 vos_mem_copy(wdiBssParams->macBSSID,
4351 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4352 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4353 sizeof(tSirMacAddr)) ;
4354 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4355 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4356 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4357 wdiBssParams->ucShortSlotTimeSupported =
4358 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4359 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4360 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4361 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4362 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4363 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4364
4365 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4366 wdiBssParams->ucTXOPProtectionFullSupport =
4367 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4368 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4369 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4370 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4371 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4372 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4373 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4374 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4375
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4376 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4377
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4378 /* copy SSID into WDI structure */
4379 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4380 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4381 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4382 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4383 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4384 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4385#ifdef WLAN_FEATURE_VOWIFI
4386 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4387#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4388 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4389 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4390#ifdef WLAN_FEATURE_VOWIFI_11R
4391 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4392 if(wdiBssParams->bExtSetStaKeyParamValid)
4393 {
4394 /* copy set STA key params to WDI structure */
4395 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4396 wdaBssParams->extSetStaKeyParam.staIdx;
4397 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4398 wdaBssParams->extSetStaKeyParam.encType;
4399 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4400 wdaBssParams->extSetStaKeyParam.wepType;
4401 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4402 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4403 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4404 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4405 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4406 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4407 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4408 {
4409 WDA_GetWepKeysFromCfg( pWDA,
4410 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4411 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4412 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4413 }
4414 else
4415 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4416 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4417 keyIndex++)
4418 {
4419 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4420 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4421 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4422 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4423 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4424 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4425 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4426 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4427 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4428 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4429 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4430 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
4431 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4432 wdaBssParams->extSetStaKeyParam.key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4433 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4434 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
4435 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4436 }
4437 }
4438 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4439 }
4440 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4441 {
4442 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4443 sizeof(wdaBssParams->extSetStaKeyParam) );
4444 }
4445#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4446#ifdef WLAN_FEATURE_11AC
4447 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4448 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4449#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4450
4451 return ;
4452}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4453/*
4454 * FUNCTION: WDA_UpdateSTAParams
4455 * Translated WDA/PE BSS info into WDI BSS info..
4456 */
4457void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4458 WDI_ConfigStaReqInfoType *wdiStaParams,
4459 tAddStaParams *wdaStaParams)
4460{
4461 tANI_U8 i = 0;
4462 /* Update STA params */
4463 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4464 sizeof(tSirMacAddr)) ;
4465 wdiStaParams->usAssocId = wdaStaParams->assocId;
4466 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4467 wdiStaParams->staIdx = wdaStaParams->staIdx;
4468
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4469 wdiStaParams->ucShortPreambleSupported =
4470 wdaStaParams->shortPreambleSupported;
4471 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4472 sizeof(tSirMacAddr)) ;
4473 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4474
4475 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4476
4477 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4478 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4479 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4480 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
4481 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
4482 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
4483 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
4484
4485 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
4486 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4487 wdiStaParams->wdiSupportedRates.opRateMode =
4488 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4489 for(i = 0;i < WDI_NUM_11B_RATES;i++)
4490 {
4491 wdiStaParams->wdiSupportedRates.llbRates[i] =
4492 wdaStaParams->supportedRates.llbRates[i];
4493 }
4494 for(i = 0;i < WDI_NUM_11A_RATES;i++)
4495 {
4496 wdiStaParams->wdiSupportedRates.llaRates[i] =
4497 wdaStaParams->supportedRates.llaRates[i];
4498 }
4499 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
4500 {
4501 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
4502 wdaStaParams->supportedRates.aniLegacyRates[i];
4503 }
4504 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
4505 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4506#ifdef WLAN_FEATURE_11AC
4507 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
4508 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
4509 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
4510 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
4511#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4512 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
4513 {
4514 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
4515 wdaStaParams->supportedRates.supportedMCSSet[i];
4516 }
4517 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
4518 wdaStaParams->supportedRates.rxHighestDataRate;
4519
4520 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
4521
4522 wdiStaParams->wdiAction = wdaStaParams->updateSta;
4523
4524 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
4525 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
4526 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
4527
4528 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
4529 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
4530 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
4531 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4532 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4533#ifdef WLAN_FEATURE_11AC
4534 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
4535 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]4536 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]4537 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
4538 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
4539 * must be set by default */
4540 if ( wdiStaParams->vhtTxMUBformeeCapable )
4541 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4542#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]4543 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
4544 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4545 return ;
4546}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4547/*
4548 * -------------------------------------------------------------------------
4549 * CFG update to WDI
4550 * -------------------------------------------------------------------------
4551 */
4552
4553 /*
4554 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
4555 * Convert the WNI CFG ID to HAL CFG ID
4556 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4557static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4558{
4559 switch(wniCfgId)
4560 {
4561 case WNI_CFG_STA_ID:
4562 return QWLAN_HAL_CFG_STA_ID;
4563 case WNI_CFG_CURRENT_TX_ANTENNA:
4564 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
4565 case WNI_CFG_CURRENT_RX_ANTENNA:
4566 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
4567 case WNI_CFG_LOW_GAIN_OVERRIDE:
4568 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
4569 case WNI_CFG_POWER_STATE_PER_CHAIN:
4570 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
4571 case WNI_CFG_CAL_PERIOD:
4572 return QWLAN_HAL_CFG_CAL_PERIOD;
4573 case WNI_CFG_CAL_CONTROL:
4574 return QWLAN_HAL_CFG_CAL_CONTROL;
4575 case WNI_CFG_PROXIMITY:
4576 return QWLAN_HAL_CFG_PROXIMITY;
4577 case WNI_CFG_NETWORK_DENSITY:
4578 return QWLAN_HAL_CFG_NETWORK_DENSITY;
4579 case WNI_CFG_MAX_MEDIUM_TIME:
4580 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
4581 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
4582 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
4583 case WNI_CFG_RTS_THRESHOLD:
4584 return QWLAN_HAL_CFG_RTS_THRESHOLD;
4585 case WNI_CFG_SHORT_RETRY_LIMIT:
4586 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
4587 case WNI_CFG_LONG_RETRY_LIMIT:
4588 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
4589 case WNI_CFG_FRAGMENTATION_THRESHOLD:
4590 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
4591 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
4592 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
4593 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
4594 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
4595 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
4596 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
4597 case WNI_CFG_FIXED_RATE:
4598 return QWLAN_HAL_CFG_FIXED_RATE;
4599 case WNI_CFG_RETRYRATE_POLICY:
4600 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
4601 case WNI_CFG_RETRYRATE_SECONDARY:
4602 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
4603 case WNI_CFG_RETRYRATE_TERTIARY:
4604 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
4605 case WNI_CFG_FORCE_POLICY_PROTECTION:
4606 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
4607 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
4608 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
4609 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
4610 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
4611 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
4612 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
4613 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
4614 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
4615 case WNI_CFG_MAX_BA_SESSIONS:
4616 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
4617 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
4618 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
4619 case WNI_CFG_PS_ENABLE_BCN_FILTER:
4620 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
4621 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
4622 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
4623 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
4624 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
4625 case WNI_CFG_STATS_PERIOD:
4626 return QWLAN_HAL_CFG_STATS_PERIOD;
4627 case WNI_CFG_CFP_MAX_DURATION:
4628 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
4629#if 0 /*This is not part of CFG*/
4630 case WNI_CFG_FRAME_TRANS_ENABLED:
4631 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
4632#endif
4633 case WNI_CFG_DTIM_PERIOD:
4634 return QWLAN_HAL_CFG_DTIM_PERIOD;
4635 case WNI_CFG_EDCA_WME_ACBK:
4636 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
4637 case WNI_CFG_EDCA_WME_ACBE:
4638 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
4639 case WNI_CFG_EDCA_WME_ACVI:
4640 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
4641 case WNI_CFG_EDCA_WME_ACVO:
4642 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
4643#if 0
4644 case WNI_CFG_TELE_BCN_WAKEUP_EN:
4645 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
4646 case WNI_CFG_TELE_BCN_TRANS_LI:
4647 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
4648 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
4649 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
4650 case WNI_CFG_TELE_BCN_MAX_LI:
4651 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
4652 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
4653 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
4654#endif
4655 case WNI_CFG_ENABLE_CLOSE_LOOP:
4656 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]4657 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
4658 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4659 default:
4660 {
4661 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4662 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4663 wniCfgId);
4664 return VOS_STATUS_E_INVAL;
4665 }
4666 }
4667}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4668/*
4669 * FUNCTION: WDA_UpdateCfgCallback
4670 *
4671 */
4672void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
4673{
4674 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4675 WDI_UpdateCfgReqParamsType *wdiCfgParam =
4676 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4677 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4678 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4679 /*
4680 * currently there is no response message is expected between PE and
4681 * WDA, Failure return from WDI is a ASSERT condition
4682 */
4683 if(WDI_STATUS_SUCCESS != wdiStatus)
4684 {
4685 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4686 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4687 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
4688 }
4689
4690 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
4691 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4692 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4693 return ;
4694}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4695/*
4696 * FUNCTION: WDA_UpdateCfg
4697 *
4698 */
4699VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
4700{
4701
4702 WDI_Status status = WDI_STATUS_SUCCESS ;
4703 tANI_U32 val =0;
4704 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
4705 tHalCfg *configData;
4706 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
4707 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4709 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4710 if (NULL == pMac )
4711 {
4712 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4713 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4714 return VOS_STATUS_E_FAILURE;
4715 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4716 if(WDA_START_STATE != pWDA->wdaState)
4717 {
4718 return VOS_STATUS_E_FAILURE;
4719 }
4720
4721 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
4722 {
4723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4724 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4725 VOS_ASSERT(0);
4726 return VOS_STATUS_E_FAILURE;
4727 }
4728
4729 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
4730 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4731 if(NULL == wdiCfgReqParam)
4732 {
4733 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4734 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4735 VOS_ASSERT(0);
4736 return VOS_STATUS_E_NOMEM;
4737 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4738 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
4739 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4740 if(NULL == wdiCfgReqParam->pConfigBuffer)
4741 {
4742 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4743 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4744 vos_mem_free(wdiCfgReqParam);
4745 VOS_ASSERT(0);
4746 return VOS_STATUS_E_NOMEM;
4747 }
4748
4749 /*convert the WNI CFG Id to HAL CFG Id*/
4750 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
4751 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
4752
4753 /*TODO: revisit this for handling string parameters */
4754 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
4755 &val) != eSIR_SUCCESS)
4756 {
4757 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4758 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4759 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
4760 vos_mem_free(wdiCfgReqParam);
4761 return eSIR_FAILURE;
4762 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4763 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
4764 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
4765 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
4766 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
4767 wdiCfgReqParam->wdiReqStatusCB = NULL ;
4768
4769 /* store Params pass it to WDI */
4770 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4771#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
4772 status = WDI_UpdateCfgReq(wdiCfgReqParam,
4773 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4774 if(IS_WDI_STATUS_FAILURE(status))
4775 {
4776 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4777 "Failure in Update CFG WDI API, free all the memory " );
4778 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4779 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4780 pWDA->wdaWdiCfgApiMsgParam = NULL;
4781 /* Failure is not expected */
4782 VOS_ASSERT(0) ;
4783 }
4784#else
4785 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4786 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4787 pWDA->wdaWdiCfgApiMsgParam = NULL;
4788#endif
4789 return CONVERT_WDI2VOS_STATUS(status) ;
4790}
4791
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4792VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
4793 v_U8_t *pDefaultKeyId,
4794 v_U8_t *pNumKeys,
4795 WDI_KeysType *pWdiKeys )
4796{
4797 v_U32_t i, j, defKeyId = 0;
4798 v_U32_t val = SIR_MAC_KEY_LENGTH;
4799 VOS_STATUS status = WDI_STATUS_SUCCESS;
4800 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4801 if (NULL == pMac )
4802 {
4803 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4804 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4805 return VOS_STATUS_E_FAILURE;
4806 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4807 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
4808 &defKeyId ))
4809 {
4810 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4811 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
4812 }
4813
4814 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4815 /* Need to extract ALL of the configured WEP Keys */
4816 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
4817 {
4818 val = SIR_MAC_KEY_LENGTH;
4819 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
4820 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
4821 pWdiKeys[j].key,
4822 &val ))
4823 {
4824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4825 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4826 }
4827 else
4828 {
4829 pWdiKeys[j].keyId = (tANI_U8) i;
4830 /*
4831 * Actually, a DC (Don't Care) because
4832 * this is determined (and set) by PE/MLME
4833 */
4834 pWdiKeys[j].unicast = 0;
4835 /*
4836 * Another DC (Don't Care)
4837 */
4838 pWdiKeys[j].keyDirection = eSIR_TX_RX;
4839 /* Another DC (Don't Care). Unused for WEP */
4840 pWdiKeys[j].paeRole = 0;
4841 /* Determined from wlan_cfgGetStr() above.*/
4842 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4843 j++;
4844 *pNumKeys = (tANI_U8) j;
4845 }
4846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4847 return status;
4848}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4849/*
4850 * FUNCTION: WDA_SetBssKeyReqCallback
4851 * send SET BSS key RSP back to PE
4852 */
4853void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
4854{
4855 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4856 tWDA_CbContext *pWDA;
4857 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4859 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4860 if(NULL == pWdaParams)
4861 {
4862 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4863 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4864 VOS_ASSERT(0) ;
4865 return ;
4866 }
4867 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4868 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame^]4869 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
4870 sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4871 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4872 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4873 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4874 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4875 return ;
4876}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4877/*
4878 * FUNCTION: WDA_ProcessSetBssKeyReq
4879 * Request to WDI for programming the BSS key( key for
4880 * broadcast/multicast frames Encryption)
4881 */
4882VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
4883 tSetBssKeyParams *setBssKeyParams )
4884{
4885 WDI_Status status = WDI_STATUS_SUCCESS ;
4886 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
4887 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
4888 sizeof(WDI_SetBSSKeyReqParamsType)) ;
4889 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4890 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4892 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4893 if(NULL == wdiSetBssKeyParam)
4894 {
4895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4896 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4897 VOS_ASSERT(0);
4898 return VOS_STATUS_E_NOMEM;
4899 }
4900 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4901 if(NULL == pWdaParams)
4902 {
4903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4904 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4905 VOS_ASSERT(0);
4906 vos_mem_free(wdiSetBssKeyParam);
4907 return VOS_STATUS_E_NOMEM;
4908 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4909 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4910 /* copy set BSS params to WDI structure */
4911 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
4912 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
4913 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4914 if(setBssKeyParams->encType != eSIR_ED_NONE)
4915 {
4916 if( setBssKeyParams->numKeys == 0 &&
4917 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
4918 setBssKeyParams->encType == eSIR_ED_WEP104))
4919 {
4920 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4921 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
4922 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
4923 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
4924 }
4925 else
4926 {
4927 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
4928 {
4929 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
4930 setBssKeyParams->key[keyIndex].keyId;
4931 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
4932 setBssKeyParams->key[keyIndex].unicast;
4933 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
4934 setBssKeyParams->key[keyIndex].keyDirection;
4935 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
4936 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4937 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
4938 setBssKeyParams->key[keyIndex].paeRole;
4939 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
4940 setBssKeyParams->key[keyIndex].keyLength;
4941 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
4942 setBssKeyParams->key[keyIndex].key,
4943 SIR_MAC_MAX_KEY_LENGTH);
4944 }
4945 }
4946 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4947 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
4948 setBssKeyParams->singleTidRc;
4949 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4950 /* Store set key pointer, as this will be used for response */
4951 /* store Params pass it to WDI */
4952 pWdaParams->pWdaContext = pWDA;
4953 pWdaParams->wdaMsgParam = setBssKeyParams;
4954 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4955 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
4956 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
4957
4958 if(IS_WDI_STATUS_FAILURE(status))
4959 {
4960 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4961 "Failure in Set BSS Key Req WDI API, free all the memory " );
4962 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4963 vos_mem_free(pWdaParams) ;
4964 setBssKeyParams->status = eSIR_FAILURE ;
4965 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
4966 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4967 return CONVERT_WDI2VOS_STATUS(status) ;
4968}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4969/*
4970 * FUNCTION: WDA_RemoveBssKeyReqCallback
4971 * send SET BSS key RSP back to PE
4972 */
4973void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
4974{
4975 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4976 tWDA_CbContext *pWDA;
4977 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4978 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4979 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4980 if(NULL == pWdaParams)
4981 {
4982 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4983 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4984 VOS_ASSERT(0) ;
4985 return ;
4986 }
4987 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4988 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4989 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4990 vos_mem_free(pWdaParams) ;
4991
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4992 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4993 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4994 return ;
4995}
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]4996
4997/*
4998 * FUNCTION: WDA_SpoofMacAddrRspCallback
4999 * recieves spoof mac addr response from FW
5000 */
5001void WDA_SpoofMacAddrRspCallback(WDI_SpoofMacAddrRspParamType* wdiRsp, void* pUserData)
5002{
5003 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5004 tWDA_CbContext *pWDA;
5005 tSirSpoofMacAddrReq *spoofMacAddrReq;
5006 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5007 "<------ %s " ,__func__);
5008 if(NULL == pWdaParams)
5009 {
5010 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5011 "%s: pWdaParams received NULL", __func__);
5012 VOS_ASSERT(0) ;
5013 return ;
5014 }
5015
5016 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5017 spoofMacAddrReq = (tSirSpoofMacAddrReq *)pWdaParams->wdaMsgParam ;
5018
5019 if(wdiRsp->wdiStatus != WDI_STATUS_SUCCESS )
5020 {
5021 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5022 "%s: Unable to set Random Mac Addr in FW", __func__);
5023 }
5024
5025 vos_mem_free(spoofMacAddrReq);
5026 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5027 vos_mem_free(pWdaParams);
5028 return ;
5029}
5030
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5031/*
5032 * FUNCTION: WDA_ProcessRemoveBssKeyReq
5033 * Request to WDI to remove the BSS key( key for broadcast/multicast
5034 * frames Encryption)
5035 */
5036VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
5037 tRemoveBssKeyParams *removeBssKeyParams )
5038{
5039 WDI_Status status = WDI_STATUS_SUCCESS ;
5040 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
5041 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
5042 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
5043 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5045 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5046 if(NULL == wdiRemoveBssKeyParam)
5047 {
5048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5049 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5050 VOS_ASSERT(0);
5051 return VOS_STATUS_E_NOMEM;
5052 }
5053 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5054 if(NULL == pWdaParams)
5055 {
5056 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5057 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5058 VOS_ASSERT(0);
5059 vos_mem_free(wdiRemoveBssKeyParam);
5060 return VOS_STATUS_E_NOMEM;
5061 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5062 /* copy Remove BSS key params to WDI structure*/
5063 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
5064 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
5065 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
5066 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
5067 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5068 /* Store remove key pointer, as this will be used for response */
5069 /* store Params pass it to WDI */
5070 pWdaParams->pWdaContext = pWDA;
5071 pWdaParams->wdaMsgParam = removeBssKeyParams;
5072 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5073 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
5074 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5075 if(IS_WDI_STATUS_FAILURE(status))
5076 {
5077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5078 "Failure in Remove BSS Key Req WDI API, free all the memory " );
5079 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5080 vos_mem_free(pWdaParams) ;
5081 removeBssKeyParams->status = eSIR_FAILURE ;
5082 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
5083 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5084 return CONVERT_WDI2VOS_STATUS(status) ;
5085}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5086/*
5087 * FUNCTION: WDA_SetBssKeyReqCallback
5088 * send SET BSS key RSP back to PE
5089 */
5090void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
5091{
5092 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5093 tWDA_CbContext *pWDA;
5094 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5096 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5097 if(NULL == pWdaParams)
5098 {
5099 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5100 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5101 VOS_ASSERT(0) ;
5102 return ;
5103 }
5104 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5105 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame^]5106 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
5107 sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5108 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5109 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5110 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5111 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5112 return ;
5113}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5114/*
5115 * FUNCTION: WDA_ProcessSetStaKeyReq
5116 * Request to WDI for programming the STA key( key for Unicast frames
5117 * Encryption)
5118 */
5119VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
5120 tSetStaKeyParams *setStaKeyParams )
5121{
5122 WDI_Status status = WDI_STATUS_SUCCESS ;
5123 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5124 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5125 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5126 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5127 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5129 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5130 if(NULL == wdiSetStaKeyParam)
5131 {
5132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5133 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5134 VOS_ASSERT(0);
5135 return VOS_STATUS_E_NOMEM;
5136 }
5137 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5138 if(NULL == pWdaParams)
5139 {
5140 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5141 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5142 VOS_ASSERT(0);
5143 vos_mem_free(wdiSetStaKeyParam);
5144 return VOS_STATUS_E_NOMEM;
5145 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5146 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5147 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5148 /* copy set STA key params to WDI structure */
5149 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5150 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5151 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5152 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5153 if(setStaKeyParams->encType != eSIR_ED_NONE)
5154 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5155 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5156 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
5157 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
5158 {
5159 WDA_GetWepKeysFromCfg( pWDA,
5160 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
5161 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
5162 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
5163 }
5164 else
5165 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5166 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5167 keyIndex++)
5168 {
5169 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5170 setStaKeyParams->key[keyIndex].keyId;
5171 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5172 setStaKeyParams->key[keyIndex].unicast;
5173 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5174 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5175 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5176 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5177 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5178 setStaKeyParams->key[keyIndex].paeRole;
5179 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5180 setStaKeyParams->key[keyIndex].keyLength;
5181 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5182 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5183 /* set default index to index which have key direction as WDI_TX_DEFAULT */
5184 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
5185 {
5186 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
5187 }
5188 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5189 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5190 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5191 }
5192 }
5193 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
5194 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5195 /* Store set key pointer, as this will be used for response */
5196 /* store Params pass it to WDI */
5197 pWdaParams->pWdaContext = pWDA;
5198 pWdaParams->wdaMsgParam = setStaKeyParams;
5199 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5200 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
5201 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5202 if(IS_WDI_STATUS_FAILURE(status))
5203 {
5204 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5205 "Failure in set STA Key Req WDI API, free all the memory " );
5206 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5207 vos_mem_free(pWdaParams) ;
5208 setStaKeyParams->status = eSIR_FAILURE ;
5209 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
5210 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5211 return CONVERT_WDI2VOS_STATUS(status) ;
5212}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5213/*
5214 * FUNCTION: WDA_SetBcastStaKeyReqCallback
5215 * send SET Bcast STA key RSP back to PE
5216 */
5217void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
5218{
5219 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5220 tWDA_CbContext *pWDA;
5221 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5223 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5224 if(NULL == pWdaParams)
5225 {
5226 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5227 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5228 VOS_ASSERT(0) ;
5229 return ;
5230 }
5231 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5232 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5233 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5234 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5235 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5236 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5237 return ;
5238}
5239
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5240/*
5241 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5242 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5243 * Encryption)
5244 */
5245VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5246 tSetStaKeyParams *setStaKeyParams )
5247{
5248 WDI_Status status = WDI_STATUS_SUCCESS ;
5249 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5250 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5251 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5252 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5253 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5254 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5255 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5256 if(NULL == wdiSetStaKeyParam)
5257 {
5258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5259 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5260 VOS_ASSERT(0);
5261 return VOS_STATUS_E_NOMEM;
5262 }
5263 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5264 if(NULL == pWdaParams)
5265 {
5266 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5267 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5268 VOS_ASSERT(0);
5269 vos_mem_free(wdiSetStaKeyParam);
5270 return VOS_STATUS_E_NOMEM;
5271 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5272 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5273 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5274 /* copy set STA key params to WDI structure */
5275 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5276 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5277 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5278 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5279 if(setStaKeyParams->encType != eSIR_ED_NONE)
5280 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5281 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5282 keyIndex++)
5283 {
5284 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5285 setStaKeyParams->key[keyIndex].keyId;
5286 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5287 setStaKeyParams->key[keyIndex].unicast;
5288 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5289 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5290 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5291 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5292 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5293 setStaKeyParams->key[keyIndex].paeRole;
5294 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5295 setStaKeyParams->key[keyIndex].keyLength;
5296 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5297 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5298 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5299 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5300 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5301 }
5302 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5303 /* Store set key pointer, as this will be used for response */
5304 /* store Params pass it to WDI */
5305 pWdaParams->pWdaContext = pWDA;
5306 pWdaParams->wdaMsgParam = setStaKeyParams;
5307 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5308 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5309 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5310 if(IS_WDI_STATUS_FAILURE(status))
5311 {
5312 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5313 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5314 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5315 vos_mem_free(pWdaParams) ;
5316 setStaKeyParams->status = eSIR_FAILURE ;
5317 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5318 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5319 return CONVERT_WDI2VOS_STATUS(status) ;
5320}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5321/*
5322 * FUNCTION: WDA_RemoveStaKeyReqCallback
5323 * send SET BSS key RSP back to PE
5324 */
5325void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5326{
5327 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5328 tWDA_CbContext *pWDA;
5329 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5331 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5332 if(NULL == pWdaParams)
5333 {
5334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5335 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5336 VOS_ASSERT(0) ;
5337 return ;
5338 }
5339 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5340 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5341 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5342 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5343 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5344 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5345 return ;
5346}
5347
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5348/*
5349 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5350 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5351 */
5352VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5353 tRemoveStaKeyParams *removeStaKeyParams )
5354{
5355 WDI_Status status = WDI_STATUS_SUCCESS ;
5356 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
5357 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
5358 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
5359 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5360 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5361 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5362 if(NULL == wdiRemoveStaKeyParam)
5363 {
5364 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5365 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5366 VOS_ASSERT(0);
5367 return VOS_STATUS_E_NOMEM;
5368 }
5369 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5370 if(NULL == pWdaParams)
5371 {
5372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5373 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5374 VOS_ASSERT(0);
5375 vos_mem_free(wdiRemoveStaKeyParam);
5376 return VOS_STATUS_E_NOMEM;
5377 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5378 /* copy remove STA key params to WDI structure*/
5379 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
5380 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
5381 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
5382 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
5383 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5384 /* Store remove key pointer, as this will be used for response */
5385 /* store Params pass it to WDI */
5386 pWdaParams->pWdaContext = pWDA;
5387 pWdaParams->wdaMsgParam = removeStaKeyParams;
5388 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5389 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
5390 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5391 if(IS_WDI_STATUS_FAILURE(status))
5392 {
5393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5394 "Failure in remove STA Key Req WDI API, free all the memory " );
5395 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5396 vos_mem_free(pWdaParams) ;
5397 removeStaKeyParams->status = eSIR_FAILURE ;
5398 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
5399 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5400 return CONVERT_WDI2VOS_STATUS(status) ;
5401}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5402/*
5403 * FUNCTION: WDA_IsHandleSetLinkStateReq
5404 * Update the WDA state and return the status to handle this message or not
5405 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5406WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
5407 tWDA_CbContext *pWDA,
5408 tLinkStateParams *linkStateParams)
5409{
5410 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5411 switch(linkStateParams->state)
5412 {
5413 case eSIR_LINK_PREASSOC_STATE:
5414 case eSIR_LINK_BTAMP_PREASSOC_STATE:
5415 /*
5416 * set the WDA state to PRE ASSOC
5417 * copy the BSSID into pWDA to use it in join request and return,
5418 * No need to handle these messages.
5419 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5420 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
5421 {
5422 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5423 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5424 }
5425 else
5426 {
5427 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5428 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5429 VOS_ASSERT(0);
5430 }
5431
5432 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
5433 {
5434 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5435 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5436 }
5437 else
5438 {
5439 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5440 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5441 VOS_ASSERT(0);
5442 }
5443
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5444 /* UMAC is issuing the setlink state with PREASSOC twice (before set
5445 *channel and after ) so reset the WDA state to ready when the second
5446 * time UMAC issue the link state with PREASSOC
5447 */
5448 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
5449 {
5450 /* RESET WDA state back to WDA_READY_STATE */
5451 pWDA->wdaState = WDA_READY_STATE;
5452 }
5453 else
5454 {
5455 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
5456 }
5457 //populate linkState info in WDACbCtxt
5458 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5459 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5460 default:
5461 if(pWDA->wdaState != WDA_READY_STATE)
5462 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5463 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
5464 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
5465 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
5466 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
5467 *the ASSERT in WDA_Stop during module unload.*/
5468 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
5469 {
5470 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5471 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5472 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5473 else
5474 {
5475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5476 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5477 status = WDA_IGNORE_SET_LINK_STATE;
5478 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5479 }
5480 break;
5481 }
5482
5483 return status;
5484}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5485/*
5486 * FUNCTION: WDA_SetLinkStateCallback
5487 * call back function for set link state from WDI
5488 */
5489void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
5490{
5491 tWDA_CbContext *pWDA;
5492 tLinkStateParams *linkStateParams;
5493 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5494 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5495 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5496 if(NULL == pWdaParams)
5497 {
5498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5499 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5500 VOS_ASSERT(0) ;
5501 return ;
5502 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5503 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5504 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5505 /*
5506 * In STA mode start the BA activity check timer after association
5507 * and in AP mode start BA activity check timer after BSS start */
5508 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
5509 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]5510 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
5511 ((status == WDI_STATUS_SUCCESS) &&
5512 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5513 {
5514 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5515 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5516 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5517 /*
5518 * No respone required for WDA_SET_LINK_STATE so free the request
5519 * param here
5520 */
5521 if( pWdaParams != NULL )
5522 {
5523 if( pWdaParams->wdaWdiApiMsgParam != NULL )
5524 {
5525 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5526 }
5527 vos_mem_free(pWdaParams);
5528 }
5529 return ;
5530}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5531/*
5532 * FUNCTION: WDA_ProcessSetLinkState
5533 * Request to WDI to set the link status.
5534 */
5535VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
5536 tLinkStateParams *linkStateParams)
5537{
5538 WDI_Status status = WDI_STATUS_SUCCESS ;
5539 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
5540 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
5541 sizeof(WDI_SetLinkReqParamsType)) ;
5542 tWDA_ReqParams *pWdaParams ;
5543 tpAniSirGlobal pMac;
5544 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
5545
5546 if(NULL == pMac)
5547 {
5548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5549 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5550 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5551 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5552 return VOS_STATUS_E_FAILURE;
5553 }
5554
5555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5556 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5557 if(NULL == wdiSetLinkStateParam)
5558 {
5559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5560 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5561 VOS_ASSERT(0);
5562 return VOS_STATUS_E_NOMEM;
5563 }
5564 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5565 if(NULL == pWdaParams)
5566 {
5567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5568 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5569 VOS_ASSERT(0);
5570 vos_mem_free(wdiSetLinkStateParam);
5571 return VOS_STATUS_E_NOMEM;
5572 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5573 if(WDA_IGNORE_SET_LINK_STATE ==
5574 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
5575 {
5576 status = WDI_STATUS_E_FAILURE;
5577 }
5578 else
5579 {
5580 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
5581 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5582 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
5583 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5584 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
5585 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5586 pWdaParams->pWdaContext = pWDA;
5587 /* Store remove key pointer, as this will be used for response */
5588 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5589 /* store Params pass it to WDI */
5590 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
5591 /* Stop Timer only other than GO role and concurrent session */
5592 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]5593 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5594 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
5595 {
5596 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5597 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5598 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
5599 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5600 if(IS_WDI_STATUS_FAILURE(status))
5601 {
5602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5603 "Failure in set link state Req WDI API, free all the memory " );
5604 }
5605 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5606 if(IS_WDI_STATUS_FAILURE(status))
5607 {
5608 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5609 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5610 vos_mem_free(pWdaParams);
5611 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5612 return CONVERT_WDI2VOS_STATUS(status) ;
5613}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5614/*
5615 * FUNCTION: WDA_GetStatsReqParamsCallback
5616 * send the response to PE with Stats received from WDI
5617 */
5618void WDA_GetStatsReqParamsCallback(
5619 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
5620 void* pUserData)
5621{
5622 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5623 tAniGetPEStatsRsp *pGetPEStatsRspParams;
5624
5625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5626 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5627 pGetPEStatsRspParams =
5628 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
5629 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
5630
5631 if(NULL == pGetPEStatsRspParams)
5632 {
5633 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5634 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5635 VOS_ASSERT(0);
5636 return;
5637 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5638 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
5639 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
5640 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
5641 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5642
5643 //Fill the Session Id Properly in PE
5644 pGetPEStatsRspParams->sessionId = 0;
5645 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5646 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5647 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
5648 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5649 vos_mem_copy( pGetPEStatsRspParams + 1,
5650 wdiGetStatsRsp + 1,
5651 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5652 /* send response to UMAC*/
5653 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
5654
5655 return;
5656}
5657
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5658/*
5659 * FUNCTION: WDA_ProcessGetStatsReq
5660 * Request to WDI to get the statistics
5661 */
5662VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
5663 tAniGetPEStatsReq *pGetStatsParams)
5664{
5665 WDI_Status status = WDI_STATUS_SUCCESS ;
5666 WDI_GetStatsReqParamsType wdiGetStatsParam;
5667 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5669 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5670 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
5671 pGetStatsParams->staId;
5672 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
5673 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5674 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5675 status = WDI_GetStatsReq(&wdiGetStatsParam,
5676 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5677 if(IS_WDI_STATUS_FAILURE(status))
5678 {
5679 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5680 "Failure in Get Stats Req WDI API, free all the memory " );
5681 pGetPEStatsRspParams =
5682 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
5683 if(NULL == pGetPEStatsRspParams)
5684 {
5685 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5686 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5687 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5688 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5689 return VOS_STATUS_E_NOMEM;
5690 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5691 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
5692 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
5693 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
5694 pGetPEStatsRspParams->rc = eSIR_FAILURE;
5695 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
5696 (void *)pGetPEStatsRspParams, 0) ;
5697 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5698 /* Free the request message */
5699 vos_mem_free(pGetStatsParams);
5700 return CONVERT_WDI2VOS_STATUS(status);
5701}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5702
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]5703#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5704/*
5705 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
5706 * send the response to PE with roam Rssi received from WDI
5707 */
5708void WDA_GetRoamRssiReqParamsCallback(
5709 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
5710 void* pUserData)
5711{
5712 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5713 tWDA_CbContext *pWDA = NULL;
5714 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5715 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
5716 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5717 "<------ %s " ,__func__);
5718 if(NULL == pWdaParams)
5719 {
5720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5721 "%s: pWdaParams received NULL", __func__);
5722 VOS_ASSERT(0) ;
5723 return ;
5724 }
5725 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5726 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
5727
5728 if(NULL == pGetRoamRssiReqParams)
5729 {
5730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5731 "%s: pGetRoamRssiReqParams received NULL", __func__);
5732 VOS_ASSERT(0);
5733 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5734 vos_mem_free(pWdaParams);
5735 return ;
5736 }
5737 pGetRoamRssiRspParams =
5738 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5739
5740 if(NULL == pGetRoamRssiRspParams)
5741 {
5742 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5743 "%s: VOS MEM Alloc Failure", __func__);
5744 VOS_ASSERT(0);
5745 return;
5746 }
5747 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
5748 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5749 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5750 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
5751 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
5752
5753 /* Assign get roam rssi req (backup) in to the response */
5754 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
5755
5756 /* free WDI command buffer */
5757 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5758 vos_mem_free(pWdaParams) ;
5759
5760 /* send response to UMAC*/
5761 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
5762
5763 return;
5764}
5765
5766
5767
5768/*
5769 * FUNCTION: WDA_ProcessGetRoamRssiReq
5770 * Request to WDI to get the statistics
5771 */
5772VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
5773 tAniGetRssiReq *pGetRoamRssiParams)
5774{
5775 WDI_Status status = WDI_STATUS_SUCCESS ;
5776 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
5777 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5778 tWDA_ReqParams *pWdaParams = NULL;
5779
5780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5781 "------> %s " ,__func__);
5782 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
5783 pGetRoamRssiParams->staId;
5784 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
5785
5786 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5787 if(NULL == pWdaParams)
5788 {
5789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5790 "%s: VOS MEM Alloc Failure", __func__);
5791 VOS_ASSERT(0);
5792 return VOS_STATUS_E_NOMEM;
5793 }
5794
5795 /* Store Init Req pointer, as this will be used for response */
5796 pWdaParams->pWdaContext = pWDA;
5797
5798 /* Take Get roam Rssi req backup as it stores the callback to be called after
5799 receiving the response */
5800 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
5801 pWdaParams->wdaWdiApiMsgParam = NULL;
5802
5803 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
5804 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
5805 if(IS_WDI_STATUS_FAILURE(status))
5806 {
5807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5808 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
5809 pGetRoamRssiRspParams =
5810 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5811 if(NULL == pGetRoamRssiRspParams)
5812 {
5813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5814 "%s: VOS MEM Alloc Failure", __func__);
5815 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]5816 vos_mem_free(pGetRoamRssiParams);
5817 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5818 return VOS_STATUS_E_NOMEM;
5819 }
5820 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
5821 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
5822 pGetRoamRssiRspParams->rssi = 0;
5823 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
5824 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
5825 (void *)pGetRoamRssiRspParams, 0) ;
5826 }
5827 return CONVERT_WDI2VOS_STATUS(status);
5828}
5829#endif
5830
5831
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5832/*
5833 * FUNCTION: WDA_UpdateEDCAParamCallback
5834 * call back function for Update EDCA params from WDI
5835 */
5836void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
5837{
5838 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5839 tEdcaParams *pEdcaParams;
5840
5841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5842 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5843 if(NULL == pWdaParams)
5844 {
5845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5846 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5847 VOS_ASSERT(0) ;
5848 return ;
5849 }
5850 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5851 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5852 vos_mem_free(pWdaParams);
5853 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5854 return ;
5855}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5856/*
5857 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
5858 * Request to WDI to Update the EDCA params.
5859 */
5860VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
5861 tEdcaParams *pEdcaParams)
5862{
5863 WDI_Status status = WDI_STATUS_SUCCESS ;
5864 WDI_UpdateEDCAParamsType *wdiEdcaParam =
5865 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
5866 sizeof(WDI_UpdateEDCAParamsType)) ;
5867 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5869 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5870 if(NULL == wdiEdcaParam)
5871 {
5872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5873 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5874 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5875 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5876 return VOS_STATUS_E_NOMEM;
5877 }
5878 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5879 if(NULL == pWdaParams)
5880 {
5881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5882 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5883 VOS_ASSERT(0);
5884 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5885 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5886 return VOS_STATUS_E_NOMEM;
5887 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5888 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]5889 /*
5890 Since firmware is not using highperformance flag, we have removed
5891 this flag from wdiEDCAInfo structure to match sizeof the structure
5892 between host and firmware.In future if we are planning to use
5893 highperformance flag then Please define this flag in wdiEDCAInfo
5894 structure, update it here and send it to firmware. i.e.
5895 Following is the original line which we removed as part of the fix
5896 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
5897 pEdcaParams->highPerformance;
5898 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5899 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
5900 &pEdcaParams->acbe);
5901 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
5902 &pEdcaParams->acbk);
5903 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
5904 &pEdcaParams->acvi);
5905 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
5906 &pEdcaParams->acvo);
5907 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5908 pWdaParams->pWdaContext = pWDA;
5909 /* Store remove key pointer, as this will be used for response */
5910 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5911 /* store Params pass it to WDI */
5912 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5913 status = WDI_UpdateEDCAParams(wdiEdcaParam,
5914 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5915 if(IS_WDI_STATUS_FAILURE(status))
5916 {
5917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5918 "Failure in Update EDCA Params WDI API, free all the memory " );
5919 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5920 vos_mem_free(pWdaParams);
5921 vos_mem_free(pEdcaParams);
5922 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5923 return CONVERT_WDI2VOS_STATUS(status) ;
5924}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5925/*
5926 * FUNCTION: WDA_AddBAReqCallback
5927 * send ADD BA RSP back to PE
5928 */
5929void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
5930 void* pUserData)
5931{
5932 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5933 tWDA_CbContext *pWDA;
5934 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5936 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5937 if(NULL == pWdaParams)
5938 {
5939 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5940 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5941 VOS_ASSERT(0) ;
5942 return ;
5943 }
5944 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5945 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5946 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5947 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5948 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5949 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5950 return ;
5951}
5952
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5953/*
5954 * FUNCTION: WDA_ProcessAddBAReq
5955 * Request to WDI to Update the ADDBA REQ params.
5956 */
5957VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
5958 tANI_U16 baSessionID, tANI_U8 staIdx, tAddBAParams *pAddBAReqParams)
5959{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5960 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5961 WDI_AddBAReqParamsType *wdiAddBAReqParam =
5962 (WDI_AddBAReqParamsType *)vos_mem_malloc(
5963 sizeof(WDI_AddBAReqParamsType)) ;
5964 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5966 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5967 if(NULL == wdiAddBAReqParam)
5968 {
5969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5970 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5971 VOS_ASSERT(0);
5972 return VOS_STATUS_E_NOMEM;
5973 }
5974 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5975 if(NULL == pWdaParams)
5976 {
5977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5978 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5979 VOS_ASSERT(0);
5980 vos_mem_free(wdiAddBAReqParam);
5981 return VOS_STATUS_E_NOMEM;
5982 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5983 do
5984 {
5985 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5986 wdiAddBaInfo->ucSTAIdx = staIdx ;
5987 wdiAddBaInfo->ucBaSessionID = baSessionID ;
5988 wdiAddBaInfo->ucWinSize = WDA_BA_MAX_WINSIZE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5989 } while(0) ;
5990 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5991 pWdaParams->pWdaContext = pWDA;
5992 /* store Params pass it to WDI */
5993 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
5994 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5995 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
5996 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5997
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5998 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5999 {
6000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6001 "Failure in ADD BA REQ Params WDI API, free all the memory" );
6002 status = CONVERT_WDI2VOS_STATUS(wstatus);
6003 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6004 vos_mem_free(pWdaParams);
6005 pAddBAReqParams->status = eSIR_FAILURE;
6006 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6007 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6008 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6009}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6010/*
6011 * FUNCTION: WDA_AddBASessionReqCallback
6012 * send ADD BA SESSION RSP back to PE/(or TL)
6013 */
6014void WDA_AddBASessionReqCallback(
6015 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
6016{
6017 VOS_STATUS status = VOS_STATUS_SUCCESS ;
6018 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6019 tWDA_CbContext *pWDA;
6020 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6021 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6022 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6023 if(NULL == pWdaParams)
6024 {
6025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6026 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6027 VOS_ASSERT(0) ;
6028 return ;
6029 }
6030 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6031 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6032 if( NULL == pAddBAReqParams )
6033 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6035 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6036 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6037 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6038 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6039 return ;
6040 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6041 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6042 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6043 /*
6044 * if WDA in update TL state, update TL with BA session parama and send
6045 * another request to HAL(/WDI) (ADD_BA_REQ)
6046 */
6047
6048 if((VOS_STATUS_SUCCESS ==
6049 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
6050 (WDA_BA_UPDATE_TL_STATE == pWDA->wdaState))
6051 {
6052 /* Update TL with BA info received from HAL/WDI */
6053 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
6054 wdiAddBaSession->usBaSessionID,
6055 wdiAddBaSession->ucSTAIdx,
6056 wdiAddBaSession->ucBaTID,
6057 wdiAddBaSession->ucBaBufferSize,
6058 wdiAddBaSession->ucWinSize,
6059 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6060 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
6061 wdiAddBaSession->ucSTAIdx, pAddBAReqParams) ;
6062 }
6063 else
6064 {
6065 pAddBAReqParams->status =
6066 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
6067
6068 /* Setting Flag to indicate that Set BA is success */
6069 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
6070 {
6071 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
6072 tANI_U8 tid = wdiAddBaSession->ucBaTID;
6073 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
6074 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6075 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6076 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6077 /*Reset the WDA state to READY */
6078 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6079 return ;
6080}
6081
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6082/*
6083 * FUNCTION: WDA_ProcessAddBASessionReq
6084 * Request to WDI to Update the ADDBA REQ params.
6085 */
6086VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
6087 tAddBAParams *pAddBAReqParams)
6088{
6089 WDI_Status status = WDI_STATUS_SUCCESS ;
6090 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
6091 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
6092 sizeof(WDI_AddBASessionReqParamsType)) ;
6093 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6094 WLANTL_STAStateType tlSTAState = 0;
6095
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6097 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6098 if(NULL == wdiAddBASessionReqParam)
6099 {
6100 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6101 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6102 VOS_ASSERT(0);
6103 return VOS_STATUS_E_NOMEM;
6104 }
6105 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6106 if(NULL == pWdaParams)
6107 {
6108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6109 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6110 VOS_ASSERT(0);
6111 vos_mem_free(wdiAddBASessionReqParam);
6112 return VOS_STATUS_E_NOMEM;
6113 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6114 /*
6115 * Populate ADD BA parameters and pass these paarmeters to WDI.
6116 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
6117 * the state to track if these is BA recipient case or BA initiator
6118 * case.
6119 */
6120 do
6121 {
6122 WDI_AddBASessionReqinfoType *wdiBAInfoType =
6123 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
6124 /* vos_mem_copy(wdiBAInfoType->macBSSID,
6125 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
6126 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
6127 vos_mem_copy(wdiBAInfoType->macPeerAddr,
6128 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6129 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6130 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
6131 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
6132 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
6133 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
6134 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6135 /* check the BA direction and update state accordingly */
6136 (eBA_RECIPIENT == wdiBAInfoType->ucBaDirection)
6137 ? (pWDA->wdaState = WDA_BA_UPDATE_TL_STATE)
6138 : (pWDA->wdaState = WDA_BA_UPDATE_LIM_STATE);
6139
6140 }while(0) ;
6141 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6142 pWdaParams->pWdaContext = pWDA;
6143 /* Store ADD BA pointer, as this will be used for response */
6144 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
6145 /* store Params pass it to WDI */
6146 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6147
6148 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
6149 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
6150 */
6151 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
6152 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
6153 {
6154 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6155 "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]6156 status = WDI_STATUS_E_NOT_ALLOWED;
6157 pAddBAReqParams->status =
6158 CONVERT_WDI2SIR_STATUS(status) ;
6159 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6160 /*Reset the WDA state to READY */
6161 pWDA->wdaState = WDA_READY_STATE;
6162 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6163 vos_mem_free(pWdaParams);
6164
6165 return CONVERT_WDI2VOS_STATUS(status) ;
6166 }
6167
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6168 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
6169 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6170 if(IS_WDI_STATUS_FAILURE(status))
6171 {
6172 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6173 "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]6174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]6175 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]6176 pAddBAReqParams->status =
6177 CONVERT_WDI2SIR_STATUS(status) ;
6178 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6179 /*Reset the WDA state to READY */
6180 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6181 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6182 vos_mem_free(pWdaParams);
6183 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6184 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6185}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6186/*
6187 * FUNCTION: WDA_DelBANotifyTL
6188 * send DEL BA IND to TL
6189 */
6190void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
6191 tDelBAParams *pDelBAReqParams)
6192{
6193 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
6194 //tSirMsgQ msg;
6195 vos_msg_t vosMsg;
6196 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6197 if(NULL == pDelBAInd)
6198 {
6199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6200 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6201 VOS_ASSERT(0) ;
6202 return;
6203 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6204 pDelBAInd->mesgType = WDA_DELETEBA_IND;
6205 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
6206 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
6207 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6208
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6209
6210 vosMsg.type = WDA_DELETEBA_IND;
6211 vosMsg.bodyptr = pDelBAInd;
6212 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
6213 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
6214 {
6215 vosStatus = VOS_STATUS_E_BADMSG;
6216 }
6217}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6218/*
6219 * FUNCTION: WDA_DelBAReqCallback
6220 * send DEL BA RSP back to PE
6221 */
6222void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
6223{
6224 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6225 tWDA_CbContext *pWDA;
6226 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6227 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6228 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6229 if(NULL == pWdaParams)
6230 {
6231 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6232 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6233 VOS_ASSERT(0) ;
6234 return ;
6235 }
6236 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6237 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6238 /* Notify TL about DEL BA in case of recipinet */
6239 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6240 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6241 {
6242 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6243 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6244 /*
6245 * No respone required for WDA_DELBA_IND so just free the request
6246 * param here
6247 */
6248 vos_mem_free(pDelBAReqParams);
6249 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6250 vos_mem_free(pWdaParams);
6251 return ;
6252}
6253
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6254/*
6255 * FUNCTION: WDA_ProcessDelBAReq
6256 * Request to WDI to Update the DELBA REQ params.
6257 */
6258VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6259 tDelBAParams *pDelBAReqParams)
6260{
6261 WDI_Status status = WDI_STATUS_SUCCESS ;
6262 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6263 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6264 sizeof(WDI_DelBAReqParamsType)) ;
6265 tWDA_ReqParams *pWdaParams ;
6266 tANI_U16 staIdx = 0;
6267 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6269 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6270 if(NULL == wdiDelBAReqParam)
6271 {
6272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6273 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6274 VOS_ASSERT(0);
6275 return VOS_STATUS_E_NOMEM;
6276 }
6277 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6278 if(NULL == pWdaParams)
6279 {
6280 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6281 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6282 VOS_ASSERT(0);
6283 vos_mem_free(wdiDelBAReqParam);
6284 return VOS_STATUS_E_NOMEM;
6285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6286 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6287 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6288 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6289 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6290 pWdaParams->pWdaContext = pWDA;
6291 /* Store DEL BA pointer, as this will be used for response */
6292 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6293 /* store Params pass it to WDI */
6294 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6295 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6296 * maintained in WDA, so that WDA can retry for another BA session
6297 */
6298 staIdx = pDelBAReqParams->staIdx;
6299 tid = pDelBAReqParams->baTID;
6300 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6301 status = WDI_DelBAReq(wdiDelBAReqParam,
6302 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6303 if(IS_WDI_STATUS_FAILURE(status))
6304 {
6305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6306 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6307 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6308 vos_mem_free(pWdaParams->wdaMsgParam);
6309 vos_mem_free(pWdaParams);
6310 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6311 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6312}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6313
6314/*
6315 * FUNCTION: WDA_UpdateChReqCallback
6316 *
6317 */
6318void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6319{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6320 tWDA_ReqParams *pWdaParams;
6321 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6322 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6323 WDI_UpdateChannelReqinfoType *pChanInfoType;
6324 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6325
6326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6327 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6328 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6329 {
6330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6331 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6332 VOS_ASSERT(0);
6333 return;
6334 }
6335
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6336 pWdaParams = (tWDA_ReqParams *)pUserData;
6337 pwdiUpdateChReqParam =
6338 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
6339 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6340 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
6341 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6342 /*
6343 * currently there is no response message is expected between PE and
6344 * WDA, Failure return from WDI is a ASSERT condition
6345 */
6346 vos_mem_free(pChanInfoType);
6347 vos_mem_free(pChanList);
6348 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6349 vos_mem_free(pWdaParams);
6350
6351 return;
6352}
6353
6354/*
6355 * FUNCTION: WDA_ProcessUpdateChannelList
6356 * Request to WDI to Update the ChannelList params.
6357 */
6358VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
6359 tSirUpdateChanList *pChanList)
6360{
6361 WDI_Status status = WDI_STATUS_SUCCESS;
6362 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6363 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6364 WDI_UpdateChannelReqinfoType *pChanInfoType;
6365 tWDA_ReqParams *pWdaParams;
6366 wpt_uint8 i;
6367
6368 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6369 "------> %s " ,__func__);
6370 if(NULL == pChanList)
6371 {
6372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6373 "%s: NULL pChanList", __func__);
6374 VOS_ASSERT(0);
6375 return VOS_STATUS_E_INVAL;
6376 }
6377
6378 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
6379 {
6380 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6381 "Update channel list capability Not Supported");
6382 vos_mem_free(pChanList);
6383 return VOS_STATUS_E_INVAL;
6384 }
6385
6386 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
6387 sizeof(WDI_UpdateChReqParamsType));
6388 if(NULL == pwdiUpdateChReqParam)
6389 {
6390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6391 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
6392 __func__);
6393 VOS_ASSERT(0);
6394 vos_mem_free(pChanList);
6395 return VOS_STATUS_E_NOMEM;
6396 }
6397 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6398 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
6399 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
6400 pChanList->numChan);
6401 if(NULL == pChanInfoType)
6402 {
6403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6404 "%s: VOS MEM Alloc Failure", __func__);
6405 VOS_ASSERT(0);
6406 vos_mem_free(pChanList);
6407 vos_mem_free(pwdiUpdateChReqParam);
6408 return VOS_STATUS_E_NOMEM;
6409 }
6410 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
6411 * pChanList->numChan);
6412 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
6413
6414 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6415 if(NULL == pWdaParams)
6416 {
6417 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6418 "%s: VOS MEM Alloc Failure", __func__);
6419 VOS_ASSERT(0);
6420 vos_mem_free(pChanList);
6421 vos_mem_free(pChanInfoType);
6422 vos_mem_free(pwdiUpdateChReqParam);
6423 return VOS_STATUS_E_NOMEM;
6424 }
6425 pwdiUpdateChanReqType->numchan = pChanList->numChan;
6426
6427 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
6428 {
6429 pChanInfoType->mhz =
6430 vos_chan_to_freq(pChanList->chanParam[i].chanId);
6431
6432 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
6433 pChanInfoType->band_center_freq2 = 0;
6434
6435 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6436 "chan[%d] = %u", i, pChanInfoType->mhz);
6437 if (pChanList->chanParam[i].dfsSet)
6438 {
6439 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
6440 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6441 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
6442 pChanList->chanParam[i].dfsSet);
6443 }
6444
6445 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
6446 {
6447 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
6448 }
6449 else
6450 {
6451 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
6452 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
6453 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
6454 }
6455
6456 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6457 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6458
6459 pChanInfoType++;
6460 }
6461
6462 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
6463 pWdaParams->pWdaContext = pWDA;
6464 pWdaParams->wdaMsgParam = (void *)pChanList;
6465 /* store Params pass it to WDI */
6466 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
6467 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
6468 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
6469 if(IS_WDI_STATUS_FAILURE(status))
6470 {
6471 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6472 "Failure in Update Channel REQ Params WDI API, free all the memory");
6473 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
6474 vos_mem_free(pwdiUpdateChReqParam);
6475 vos_mem_free(pWdaParams->wdaMsgParam);
6476 vos_mem_free(pWdaParams);
6477 }
6478 return CONVERT_WDI2VOS_STATUS(status);
6479}
6480
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6481/*
6482 * FUNCTION: WDA_AddTSReqCallback
6483 * send ADD TS RSP back to PE
6484 */
6485void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
6486{
6487 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6488 tWDA_CbContext *pWDA;
6489 tAddTsParams *pAddTsReqParams;
6490
6491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6492 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6493 if(NULL == pWdaParams)
6494 {
6495 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6496 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6497 VOS_ASSERT(0) ;
6498 return ;
6499 }
6500 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6501 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
6502 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6503 vos_mem_free(pWdaParams);
6504
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6505 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6506 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6507 return ;
6508}
6509
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6510/*
6511 * FUNCTION: WDA_ProcessAddTSReq
6512 * Request to WDI to Update the ADD TS REQ params.
6513 */
6514VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
6515 tAddTsParams *pAddTsReqParams)
6516{
6517 WDI_Status status = WDI_STATUS_SUCCESS ;
6518 WDI_AddTSReqParamsType *wdiAddTSReqParam =
6519 (WDI_AddTSReqParamsType *)vos_mem_malloc(
6520 sizeof(WDI_AddTSReqParamsType)) ;
6521 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6523 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6524 if(NULL == wdiAddTSReqParam)
6525 {
6526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6527 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6528 VOS_ASSERT(0);
6529 return VOS_STATUS_E_NOMEM;
6530 }
6531 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6532 if(NULL == pWdaParams)
6533 {
6534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6535 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6536 VOS_ASSERT(0);
6537 vos_mem_free(wdiAddTSReqParam);
6538 return VOS_STATUS_E_NOMEM;
6539 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6540 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
6541 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6542 //TS IE
6543 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
6544 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
6545 pAddTsReqParams->tspec.length;
6546
6547 //TS IE : TS INFO : TRAFFIC
6548 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
6549 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
6550 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
6551 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
6552 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
6553 pAddTsReqParams->tspec.tsinfo.traffic.psb;
6554 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
6555 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
6556 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
6557 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
6558 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
6559 pAddTsReqParams->tspec.tsinfo.traffic.direction;
6560 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
6561 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
6562 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
6563 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
6564
6565 //TS IE : TS INFO : SCHEDULE
6566 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
6567 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
6568 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
6569 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6570 //TS IE
6571 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
6572 pAddTsReqParams->tspec.nomMsduSz;
6573 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
6574 pAddTsReqParams->tspec.maxMsduSz;
6575 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
6576 pAddTsReqParams->tspec.minSvcInterval;
6577 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
6578 pAddTsReqParams->tspec.maxSvcInterval;
6579 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
6580 pAddTsReqParams->tspec.inactInterval;
6581 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
6582 pAddTsReqParams->tspec.suspendInterval;
6583 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
6584 pAddTsReqParams->tspec.svcStartTime;
6585 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
6586 pAddTsReqParams->tspec.minDataRate;
6587 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
6588 pAddTsReqParams->tspec.meanDataRate;
6589 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
6590 pAddTsReqParams->tspec.peakDataRate;
6591 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
6592 pAddTsReqParams->tspec.maxBurstSz;
6593 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
6594 pAddTsReqParams->tspec.delayBound;
6595 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
6596 pAddTsReqParams->tspec.minPhyRate;
6597 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
6598 pAddTsReqParams->tspec.surplusBw;
6599 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
6600 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6601 /* TODO: tAddTsParams doesn't have the following fields */
6602#if 0
6603 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
6604 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
6605 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
6606 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
6607#endif
6608 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
6609
6610 pWdaParams->pWdaContext = pWDA;
6611 /* Store ADD TS pointer, as this will be used for response */
6612 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6613 /* store Params pass it to WDI */
6614 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6615 status = WDI_AddTSReq(wdiAddTSReqParam,
6616 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6617 if(IS_WDI_STATUS_FAILURE(status))
6618 {
6619 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6620 "Failure in ADD TS REQ Params WDI API, free all the memory " );
6621 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6622 vos_mem_free(pWdaParams);
6623 pAddTsReqParams->status = eSIR_FAILURE ;
6624 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
6625 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6626 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6627}
6628
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6629/*
6630 * FUNCTION: WDA_DelTSReqCallback
6631 * send DEL TS RSP back to PE
6632 */
6633void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
6634{
6635 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6637 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6638 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6639 vos_mem_free(pWdaParams->wdaMsgParam) ;
6640 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6641 /*
6642 * No respone required for WDA_DEL_TS_REQ so just free the request
6643 * param here
6644 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6645 return ;
6646}
6647
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6648/*
6649 * FUNCTION: WDA_ProcessDelTSReq
6650 * Request to WDI to Update the DELTS REQ params.
6651 */
6652VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
6653 tDelTsParams *pDelTSReqParams)
6654{
6655 WDI_Status status = WDI_STATUS_SUCCESS ;
6656 WDI_DelTSReqParamsType *wdiDelTSReqParam =
6657 (WDI_DelTSReqParamsType *)vos_mem_malloc(
6658 sizeof(WDI_DelTSReqParamsType)) ;
6659 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6661 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6662 if(NULL == wdiDelTSReqParam)
6663 {
6664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6665 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6666 VOS_ASSERT(0);
6667 return VOS_STATUS_E_NOMEM;
6668 }
6669 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6670 if(NULL == pWdaParams)
6671 {
6672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6673 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6674 VOS_ASSERT(0);
6675 vos_mem_free(wdiDelTSReqParam);
6676 return VOS_STATUS_E_NOMEM;
6677 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6678 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
6679 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
6680 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
6681 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
6682 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6683 pWdaParams->pWdaContext = pWDA;
6684 /* Store DEL TS pointer, as this will be used for response */
6685 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6686 /* store Params pass it to WDI */
6687 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6688 status = WDI_DelTSReq(wdiDelTSReqParam,
6689 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6690 if(IS_WDI_STATUS_FAILURE(status))
6691 {
6692 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6693 "Failure in DEL TS REQ Params WDI API, free all the memory " );
6694 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6695 vos_mem_free(pWdaParams->wdaMsgParam);
6696 vos_mem_free(pWdaParams);
6697 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6698 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6699}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6700/*
6701 * FUNCTION: WDA_UpdateBeaconParamsCallback
6702 * Free the memory. No need to send any response to PE in this case
6703 */
6704void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
6705{
6706 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6707 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6708 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6709 if(NULL == pWdaParams)
6710 {
6711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6712 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6713 VOS_ASSERT(0) ;
6714 return ;
6715 }
6716 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6717 vos_mem_free(pWdaParams->wdaMsgParam) ;
6718 vos_mem_free(pWdaParams);
6719 /*
6720 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
6721 * param here
6722 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6723 return ;
6724}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6725/*
6726 * FUNCTION: WDA_ProcessUpdateBeaconParams
6727 * Request to WDI to send the beacon parameters to HAL to update the Hardware
6728 */
6729VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
6730 tUpdateBeaconParams *pUpdateBeaconParams)
6731{
6732 WDI_Status status = WDI_STATUS_SUCCESS ;
6733 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
6734 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
6735 sizeof(WDI_UpdateBeaconParamsType)) ;
6736 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6738 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6739 if(NULL == wdiUpdateBeaconParams)
6740 {
6741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6742 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6743 VOS_ASSERT(0);
6744 return VOS_STATUS_E_NOMEM;
6745 }
6746 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6747 if(NULL == pWdaParams)
6748 {
6749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6750 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6751 VOS_ASSERT(0);
6752 vos_mem_free(wdiUpdateBeaconParams);
6753 return VOS_STATUS_E_NOMEM;
6754 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6755 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
6756 pUpdateBeaconParams->bssIdx;
6757 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
6758 pUpdateBeaconParams->fShortPreamble;
6759 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
6760 pUpdateBeaconParams->fShortSlotTime;
6761 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
6762 pUpdateBeaconParams->beaconInterval;
6763 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
6764 pUpdateBeaconParams->llaCoexist;
6765 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
6766 pUpdateBeaconParams->llbCoexist;
6767 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
6768 pUpdateBeaconParams->llgCoexist;
6769 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
6770 pUpdateBeaconParams->ht20MhzCoexist;
6771 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
6772 pUpdateBeaconParams->llnNonGFCoexist;
6773 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
6774 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
6775 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
6776 pUpdateBeaconParams->fRIFSMode;
6777 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
6778 pUpdateBeaconParams->paramChangeBitmap;
6779 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
6780
6781 pWdaParams->pWdaContext = pWDA;
6782 /* Store UpdateBeacon Req pointer, as this will be used for response */
6783 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6784 /* store Params pass it to WDI */
6785 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6786 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
6787 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
6788 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6789 if(IS_WDI_STATUS_FAILURE(status))
6790 {
6791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6792 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
6793 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6794 vos_mem_free(pWdaParams->wdaMsgParam);
6795 vos_mem_free(pWdaParams);
6796 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6797 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6798}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6799#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6800/*
6801 * FUNCTION: WDA_TSMStatsReqCallback
6802 * send TSM Stats RSP back to PE
6803 */
6804void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
6805{
6806 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6807 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6808 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
6809 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6810
6811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6812 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6813 if(NULL == pWdaParams)
6814 {
6815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6816 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6817 VOS_ASSERT(0) ;
6818 return ;
6819 }
6820 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6821 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
6822
6823 if(NULL == pGetTsmStatsReqParams)
6824 {
6825 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6826 "%s: pGetTsmStatsReqParams received NULL", __func__);
6827 VOS_ASSERT(0);
6828 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6829 vos_mem_free(pWdaParams);
6830 return;
6831 }
6832
6833 pTsmRspParams =
6834 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6835 if( NULL == pTsmRspParams )
6836 {
6837 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6838 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6839 VOS_ASSERT( 0 );
6840 return ;
6841 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6842 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
6843 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
6844 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
6845
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6846 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
6847 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
6848 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
6849 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
6850 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
6851 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
6852 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
6853 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
6854 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
6855 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6856
6857 /* Assign get tsm stats req req (backup) in to the response */
6858 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
6859
6860 /* free WDI command buffer */
6861 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6862 vos_mem_free(pWdaParams);
6863
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6864 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6865 return ;
6866}
6867
6868
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6869/*
6870 * FUNCTION: WDA_ProcessTsmStatsReq
6871 * Request to WDI to get the TSM Stats params.
6872 */
6873VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6874 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6875{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6876 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6877 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6878 tWDA_ReqParams *pWdaParams = NULL;
6879 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
6880
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6882 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6883 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
6884 sizeof(WDI_TSMStatsReqParamsType));
6885 if(NULL == wdiTSMReqParam)
6886 {
6887 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6888 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6889 VOS_ASSERT(0);
6890 return VOS_STATUS_E_NOMEM;
6891 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6892 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6893 if(NULL == pWdaParams)
6894 {
6895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6896 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6897 VOS_ASSERT(0);
6898 vos_mem_free(wdiTSMReqParam);
6899 return VOS_STATUS_E_NOMEM;
6900 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6901 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
6902 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
6903 pTsmStats->bssId,
6904 sizeof(wpt_macAddr));
6905 wdiTSMReqParam->wdiReqStatusCB = NULL ;
6906
6907 pWdaParams->pWdaContext = pWDA;
6908 /* Store TSM Stats pointer, as this will be used for response */
6909 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6910 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6911 status = WDI_TSMStatsReq(wdiTSMReqParam,
6912 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6913 if(IS_WDI_STATUS_FAILURE(status))
6914 {
6915 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6916 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6917 vos_mem_free(pWdaParams);
6918
6919 pGetTsmStatsRspParams =
6920 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
6921 if(NULL == pGetTsmStatsRspParams)
6922 {
6923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6924 "%s: VOS MEM Alloc Failure", __func__);
6925 VOS_ASSERT(0);
6926 vos_mem_free(pTsmStats);
6927 return VOS_STATUS_E_NOMEM;
6928 }
6929 pGetTsmStatsRspParams->staId = pTsmStats->staId;
6930 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
6931 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
6932
6933 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6934 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6935 return CONVERT_WDI2VOS_STATUS(status) ;
6936}
6937#endif
6938/*
6939 * FUNCTION: WDA_SendBeaconParamsCallback
6940 * No need to send any response to PE in this case
6941 */
6942void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
6943{
6944
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6945 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6946 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6947 return ;
6948}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6949/*
6950 * FUNCTION: WDA_ProcessSendBeacon
6951 * Request to WDI to send the beacon template to HAL to update the TPE memory and
6952 * start beacon trasmission
6953 */
6954VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
6955 tSendbeaconParams *pSendbeaconParams)
6956{
6957 WDI_Status status = WDI_STATUS_SUCCESS ;
6958 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6960 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6961 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
6962 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
6963 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
6964 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6965 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
6966 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]6967 /* p2pIeOffset should be atleast greater than timIeOffset */
6968 if ((pSendbeaconParams->p2pIeOffset != 0) &&
6969 (pSendbeaconParams->p2pIeOffset <
6970 pSendbeaconParams->timIeOffset))
6971 {
6972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6973 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
6974 VOS_ASSERT( 0 );
6975 return WDI_STATUS_E_FAILURE;
6976 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6977 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
6978 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6979 /* Copy the beacon template to local buffer */
6980 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
6981 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
6982 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
6983
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6984 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
6985 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6986 if(IS_WDI_STATUS_FAILURE(status))
6987 {
6988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6989 "Failure in SEND BEACON REQ Params WDI API" );
6990 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6991 vos_mem_free(pSendbeaconParams);
6992 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6993}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6994/*
6995 * FUNCTION: WDA_UpdateProbeRspParamsCallback
6996 * No need to send any response to PE in this case
6997 */
6998void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
6999{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7001 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7002 return ;
7003}
7004
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7005/*
7006 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
7007 * Request to WDI to send the probe response template to HAL to update the TPE memory and
7008 * send probe response
7009 */
7010VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
7011 tSendProbeRespParams *pSendProbeRspParams)
7012{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7013 WDI_Status status = WDI_STATUS_SUCCESS;
7014 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
7015 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7017 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7018
7019 if (!wdiSendProbeRspParam)
7020 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
7021
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7022 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7023 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7024 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7025 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7026 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7027 /* Copy the Probe Response template to local buffer */
7028 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7029 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7030 pSendProbeRspParams->pProbeRespTemplate,
7031 pSendProbeRspParams->probeRespTemplateLen);
7032 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7033 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7034 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
7035 WDI_PROBE_REQ_BITMAP_IE_LEN);
7036
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7037 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7038
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7039 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7040 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7041 if(IS_WDI_STATUS_FAILURE(status))
7042 {
7043 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7044 "Failure in SEND Probe RSP Params WDI API" );
7045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7046 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7047 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7048 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7049}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7050#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7051/*
7052 * FUNCTION: WDA_SetMaxTxPowerCallBack
7053 * send the response to PE with power value received from WDI
7054 */
7055void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7056 void* pUserData)
7057{
7058 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7059 tWDA_CbContext *pWDA = NULL;
7060 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
7061
7062 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7063 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7064 if(NULL == pWdaParams)
7065 {
7066 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7067 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7068 VOS_ASSERT(0) ;
7069 return ;
7070 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7071 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7072 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7073 if( NULL == pMaxTxPowerParams )
7074 {
7075 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7076 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7077 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]7078 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7079 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7080 return ;
7081 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7082
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7083
7084 /*need to free memory for the pointers used in the
7085 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7086 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7087 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7088 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7089
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7090
7091 /* send response to UMAC*/
7092 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
7093
7094 return;
7095}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7096/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7097 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7098 * Request to WDI to send set Max Tx Power Request
7099 */
7100 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
7101 tMaxTxPowerParams *MaxTxPowerParams)
7102{
7103 WDI_Status status = WDI_STATUS_SUCCESS;
7104 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
7105 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7106
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7108 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7109
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7110 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
7111 sizeof(WDI_SetMaxTxPowerParamsType));
7112 if(NULL == wdiSetMaxTxPowerParams)
7113 {
7114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7115 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7116 VOS_ASSERT(0);
7117 return VOS_STATUS_E_NOMEM;
7118 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7119 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7120 if(NULL == pWdaParams)
7121 {
7122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7123 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7124 vos_mem_free(wdiSetMaxTxPowerParams);
7125 VOS_ASSERT(0);
7126 return VOS_STATUS_E_NOMEM;
7127 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7128 /* Copy.Max.Tx.Power Params to WDI structure */
7129 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
7130 MaxTxPowerParams->bssId,
7131 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7132 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
7133 MaxTxPowerParams->selfStaMacAddr,
7134 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7135 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
7136 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7137 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7138 pWdaParams->pWdaContext = pWDA;
7139 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7140 /* store Params pass it to WDI */
7141 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7142 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
7143 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7144 if(IS_WDI_STATUS_FAILURE(status))
7145 {
7146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7147 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
7148 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7149 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7150 /* send response to UMAC*/
7151 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7152 }
7153 return CONVERT_WDI2VOS_STATUS(status);
7154
7155}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7156#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7157
7158/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]7159 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
7160 * send the response to PE with power value received from WDI
7161 */
7162void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
7163 *pwdiSetMaxTxPowerPerBandRsp,
7164 void* pUserData)
7165{
7166 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7167 tWDA_CbContext *pWDA = NULL;
7168 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
7169
7170 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7171 "<------ %s ", __func__);
7172 if (NULL == pWdaParams)
7173 {
7174 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7175 "%s: pWdaParams received NULL", __func__);
7176 VOS_ASSERT(0);
7177 return ;
7178 }
7179 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7180 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
7181 if ( NULL == pMxTxPwrPerBandParams )
7182 {
7183 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7184 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
7185 VOS_ASSERT(0);
7186 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7187 vos_mem_free(pWdaParams);
7188 return;
7189 }
7190
7191 /*need to free memory for the pointers used in the
7192 WDA Process.Set Max Tx Power Req function*/
7193 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7194 vos_mem_free(pWdaParams);
7195 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
7196
7197 /* send response to UMAC*/
7198 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7199 pMxTxPwrPerBandParams, 0);
7200
7201 return;
7202}
7203
7204/*
7205 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
7206 * Request to WDI to send set Max Tx Power Per band Request
7207 */
7208 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
7209 tMaxTxPowerPerBandParams
7210 *MaxTxPowerPerBandParams)
7211{
7212 WDI_Status status = WDI_STATUS_SUCCESS;
7213 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
7214 tWDA_ReqParams *pWdaParams = NULL;
7215
7216 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7217 "------> %s ", __func__);
7218
7219 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
7220 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
7221
7222 if (NULL == wdiSetMxTxPwrPerBandParams)
7223 {
7224 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7225 "%s: VOS MEM Alloc Failure", __func__);
7226 VOS_ASSERT(0);
7227 return VOS_STATUS_E_NOMEM;
7228 }
7229 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7230 if (NULL == pWdaParams)
7231 {
7232 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7233 "%s: VOS MEM Alloc Failure", __func__);
7234 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7235 VOS_ASSERT(0);
7236 return VOS_STATUS_E_NOMEM;
7237 }
7238 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7239 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7240 MaxTxPowerPerBandParams->bandInfo;
7241 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7242 MaxTxPowerPerBandParams->power;
7243 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7244 pWdaParams->pWdaContext = pWDA;
7245 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7246 /* store Params pass it to WDI */
7247 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7248 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7249 WDA_SetMaxTxPowerPerBandCallBack,
7250 pWdaParams);
7251 if (IS_WDI_STATUS_FAILURE(status))
7252 {
7253 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7254 "Failure in SET MAX TX Power REQ Params WDI API,"
7255 " free all the memory");
7256 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7257 vos_mem_free(pWdaParams);
7258 /* send response to UMAC*/
7259 WDA_SendMsg(pWDA,
7260 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7261 MaxTxPowerPerBandParams, 0);
7262 }
7263 return CONVERT_WDI2VOS_STATUS(status);
7264}
7265
7266/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7267 * FUNCTION: WDA_SetTxPowerCallBack
7268 * send the response to PE with power value received from WDI
7269 */
7270void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7271 void* pUserData)
7272{
7273 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7274 tWDA_CbContext *pWDA = NULL;
7275 tSirSetTxPowerReq *pTxPowerParams = NULL;
7276
7277 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7278 "<------ %s ", __func__);
7279 if(NULL == pWdaParams)
7280 {
7281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7282 "%s: pWdaParams received NULL", __func__);
7283 VOS_ASSERT(0) ;
7284 return ;
7285 }
7286 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7287 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
7288 if(NULL == pTxPowerParams)
7289 {
7290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7291 "%s: pTxPowerParams received NULL " ,__func__);
7292 VOS_ASSERT(0);
7293 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7294 vos_mem_free(pWdaParams);
7295 return ;
7296 }
7297
7298 /*need to free memory for the pointers used in the
7299 WDA Process.Set Max Tx Power Req function*/
7300 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7301 vos_mem_free(pWdaParams);
7302
7303 /* send response to UMAC*/
7304 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
7305 return;
7306}
7307
7308/*
7309 * FUNCTION: WDA_ProcessSetTxPowerReq
7310 * Request to WDI to send set Tx Power Request
7311 */
7312 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
7313 tSirSetTxPowerReq *txPowerParams)
7314{
7315 WDI_Status status = WDI_STATUS_SUCCESS;
7316 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
7317 tWDA_ReqParams *pWdaParams = NULL;
7318
7319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7320 "------> %s ", __func__);
7321
7322 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
7323 sizeof(WDI_SetTxPowerParamsType));
7324 if(NULL == wdiSetTxPowerParams)
7325 {
7326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7327 "%s: VOS MEM Alloc Failure", __func__);
7328 VOS_ASSERT(0);
7329 return VOS_STATUS_E_NOMEM;
7330 }
7331 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7332 if(NULL == pWdaParams)
7333 {
7334 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7335 "%s: VOS MEM Alloc Failure", __func__);
7336 vos_mem_free(wdiSetTxPowerParams);
7337 VOS_ASSERT(0);
7338 return VOS_STATUS_E_NOMEM;
7339 }
7340 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
7341 txPowerParams->bssIdx;
7342 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
7343 txPowerParams->mwPower;
7344 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
7345 pWdaParams->pWdaContext = pWDA;
7346 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
7347 /* store Params pass it to WDI */
7348 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
7349 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
7350 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
7351 if(IS_WDI_STATUS_FAILURE(status))
7352 {
7353 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7354 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
7355 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7356 vos_mem_free(pWdaParams);
7357 /* send response to UMAC*/
7358 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
7359 }
7360 return CONVERT_WDI2VOS_STATUS(status);
7361}
7362
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7363/*
7364 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7365 * Free the memory. No need to send any response to PE in this case
7366 */
7367void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
7368{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7369 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7370
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7371 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7372 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7373
7374 if(NULL == pWdaParams)
7375 {
7376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7377 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7378 VOS_ASSERT(0) ;
7379 return ;
7380 }
7381
7382 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7383 vos_mem_free(pWdaParams->wdaMsgParam) ;
7384 vos_mem_free(pWdaParams);
7385
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7386 /*
7387 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
7388 * so just free the request param here
7389 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7390 return ;
7391}
7392
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7393/*
7394 * FUNCTION: WDA_ProcessSetP2PGONOAReq
7395 * Request to WDI to set the P2P Group Owner Notice of Absence Req
7396 */
7397VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
7398 tP2pPsParams *pP2pPsConfigParams)
7399{
7400 WDI_Status status = WDI_STATUS_SUCCESS ;
7401 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
7402 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
7403 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7404 tWDA_ReqParams *pWdaParams = NULL;
7405
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7406 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7407 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7408 if(NULL == wdiSetP2PGONOAReqParam)
7409 {
7410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7411 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7412 VOS_ASSERT(0);
7413 return VOS_STATUS_E_NOMEM;
7414 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7415
7416 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7417 if(NULL == pWdaParams)
7418 {
7419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7420 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7421 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7422 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7423 VOS_ASSERT(0);
7424 return VOS_STATUS_E_NOMEM;
7425 }
7426
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7427 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
7428 pP2pPsConfigParams->opp_ps;
7429 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
7430 pP2pPsConfigParams->ctWindow;
7431 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
7432 pP2pPsConfigParams->count;
7433 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
7434 pP2pPsConfigParams->duration;
7435 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
7436 pP2pPsConfigParams->interval;
7437 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
7438 pP2pPsConfigParams->single_noa_duration;
7439 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
7440 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7441
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7442 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
7443 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7444 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
7445
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7446 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7447 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
7448 pWdaParams->pWdaContext = pWDA;
7449
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7450 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7451 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
7452
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7453 if(IS_WDI_STATUS_FAILURE(status))
7454 {
7455 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7456 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7457 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7458 vos_mem_free(pWdaParams->wdaMsgParam);
7459 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7460 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7461 return CONVERT_WDI2VOS_STATUS(status);
7462
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7463}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7464
7465#ifdef FEATURE_WLAN_TDLS
7466/*
7467 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7468 * Free the memory. No need to send any response to PE in this case
7469 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7470void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
7471 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7472{
7473 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7474 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7475 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7476
7477
7478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7479 "<------ %s " ,__func__);
7480 if(NULL == pWdaParams)
7481 {
7482 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7483 "%s: pWdaParams received NULL", __func__);
7484 VOS_ASSERT(0) ;
7485 return ;
7486 }
7487 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7488
7489 if(NULL == pWdaParams)
7490 {
7491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7492 "%s: pWdaParams received NULL", __func__);
7493 VOS_ASSERT(0) ;
7494 return ;
7495 }
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7496 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
7497 if( NULL == pTdlsLinkEstablishParams )
7498 {
7499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7500 "%s: pTdlsLinkEstablishParams "
7501 "received NULL " ,__func__);
7502 VOS_ASSERT(0);
7503 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7504 vos_mem_free(pWdaParams);
7505 return ;
7506 }
7507 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
7508 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7509 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7510 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7511 /* send response to UMAC*/
7512 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
7513
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7514 return ;
7515}
7516
7517VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
7518 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
7519{
7520 WDI_Status status = WDI_STATUS_SUCCESS ;
7521 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
7522 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
7523 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
7524 tWDA_ReqParams *pWdaParams = NULL;
7525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7526 "------> %s " ,__func__);
7527 if(NULL == wdiSetTDLSLinkEstablishReqParam)
7528 {
7529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7530 "%s: VOS MEM Alloc Failure", __func__);
7531 VOS_ASSERT(0);
7532 return VOS_STATUS_E_NOMEM;
7533 }
7534 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7535 if(NULL == pWdaParams)
7536 {
7537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7538 "%s: VOS MEM Alloc Failure", __func__);
7539 vos_mem_free(pTdlsLinkEstablishParams);
7540 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
7541 VOS_ASSERT(0);
7542 return VOS_STATUS_E_NOMEM;
7543 }
7544 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7545 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7546 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7547 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7548 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7549 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7550 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7551 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7552 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7553 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]7554 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
7555 pTdlsLinkEstablishParams->isOffChannelSupported;
7556
7557 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
7558 pTdlsLinkEstablishParams->validChannels,
7559 pTdlsLinkEstablishParams->validChannelsLen);
7560
7561 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
7562 pTdlsLinkEstablishParams->validChannelsLen;
7563
7564 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
7565 pTdlsLinkEstablishParams->validOperClasses,
7566 pTdlsLinkEstablishParams->validOperClassesLen);
7567 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
7568 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7569
7570 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
7571 /* Store msg pointer from PE, as this will be used for response */
7572 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
7573 /* store Params pass it to WDI */
7574 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
7575 pWdaParams->pWdaContext = pWDA;
7576
7577 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
7578 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
7579 WDA_SetTDLSLinkEstablishReqParamsCallback,
7580 pWdaParams);
7581 if(IS_WDI_STATUS_FAILURE(status))
7582 {
7583 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7584 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
7585 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7586 vos_mem_free(pWdaParams->wdaMsgParam);
7587 vos_mem_free(pWdaParams);
7588 }
7589 return CONVERT_WDI2VOS_STATUS(status);
7590}
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7591
7592// tdlsoffchan
7593void WDA_SetTDLSChanSwitchReqParamsCallback(WDI_SetTdlsChanSwitchReqResp *wdiSetTdlsChanSwitchReqRsp,
7594 void* pUserData)
7595{
7596 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7597 tWDA_CbContext *pWDA = NULL;
7598 tTdlsChanSwitchParams *pTdlsChanSwitchParams;
7599
7600
7601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7602 "<------ %s " ,__func__);
7603 if(NULL == pWdaParams)
7604 {
7605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7606 "%s: pWdaParams received NULL", __func__);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7607 VOS_ASSERT(0) ;
7608 return ;
7609 }
7610 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7611
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7612 if(NULL == pWdaParams)
7613 {
7614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7615 "%s: pWdaParams received NULL", __func__);
7616 VOS_ASSERT(0) ;
7617 return ;
7618 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7619 pTdlsChanSwitchParams = (tTdlsChanSwitchParams *)pWdaParams->wdaMsgParam ;
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7620 if( NULL == pTdlsChanSwitchParams )
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7621 {
7622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7623 "%s: pTdlsChanSwitchParams "
7624 "received NULL " ,__func__);
7625 VOS_ASSERT(0);
7626 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7627 vos_mem_free(pWdaParams);
7628 return ;
7629 }
7630 pTdlsChanSwitchParams->status = CONVERT_WDI2SIR_STATUS(
7631 wdiSetTdlsChanSwitchReqRsp->wdiStatus);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7632 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7633 vos_mem_free(pWdaParams);
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]7634 /* send response to UMAC*/
7635 WDA_SendMsg(pWDA, WDA_SET_TDLS_CHAN_SWITCH_REQ_RSP, pTdlsChanSwitchParams, 0) ;
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]7636
7637 return ;
7638}
7639VOS_STATUS WDA_ProcessSetTdlsChanSwitchReq(tWDA_CbContext *pWDA,
7640 tTdlsChanSwitchParams *pTdlsChanSwitchParams)
7641{
7642 WDI_Status status = WDI_STATUS_SUCCESS ;
7643 WDI_SetTDLSChanSwitchReqParamsType *wdiSetTDLSChanSwitchReqParam =
7644 (WDI_SetTDLSChanSwitchReqParamsType *)vos_mem_malloc(
7645 sizeof(WDI_SetTDLSChanSwitchReqParamsType));
7646 tWDA_ReqParams *pWdaParams = NULL;
7647
7648 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7649 "Enter: %s ",__func__);
7650 if(NULL == wdiSetTDLSChanSwitchReqParam)
7651 {
7652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7653 "%s: VOS MEM Alloc Failure", __func__);
7654 VOS_ASSERT(0);
7655 return VOS_STATUS_E_NOMEM;
7656 }
7657
7658 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7659 if(NULL == pWdaParams)
7660 {
7661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7662 "%s: VOS MEM Alloc Failure", __func__);
7663 vos_mem_free(pTdlsChanSwitchParams);
7664 vos_mem_free(wdiSetTDLSChanSwitchReqParam);
7665 VOS_ASSERT(0);
7666 return VOS_STATUS_E_NOMEM;
7667 }
7668 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.staIdx =
7669 pTdlsChanSwitchParams->staIdx;
7670 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.isOffchannelInitiator =
7671 pTdlsChanSwitchParams->tdlsSwMode;
7672 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetOperClass =
7673 pTdlsChanSwitchParams->operClass;
7674 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetChannel =
7675 pTdlsChanSwitchParams->tdlsOffCh;
7676 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.secondaryChannelOffset =
7677 pTdlsChanSwitchParams->tdlsOffChBwOffset;
7678
7679
7680 /* Store msg pointer from PE, as this will be used for response */
7681 pWdaParams->wdaMsgParam = (void *)pTdlsChanSwitchParams ;
7682 /* store Params pass it to WDI */
7683 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSChanSwitchReqParam ;
7684 pWdaParams->pWdaContext = pWDA;
7685 status = WDI_SetTDLSChanSwitchReq(wdiSetTDLSChanSwitchReqParam,
7686 (WDI_SetTDLSChanSwitchReqParamsRspCb)
7687 WDA_SetTDLSChanSwitchReqParamsCallback,
7688 pWdaParams);
7689 if(IS_WDI_STATUS_FAILURE(status))
7690 {
7691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7692 "Failure in TDLS Channel Switch Req WDI API, free all the memory" );
7693 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7694 vos_mem_free(pWdaParams->wdaMsgParam);
7695 vos_mem_free(pWdaParams);
7696 }
7697 return CONVERT_WDI2VOS_STATUS(status);
7698}
7699#endif /*FEATURE_WLAN_TDLS*/
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7700
7701
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7702#ifdef WLAN_FEATURE_VOWIFI_11R
7703/*
7704 * FUNCTION: WDA_AggrAddTSReqCallback
7705 * send ADD AGGREGATED TS RSP back to PE
7706 */
7707void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
7708{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7709 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7710 tWDA_CbContext *pWDA;
7711 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7712 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7714 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7715 if(NULL == pWdaParams)
7716 {
7717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7718 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7719 VOS_ASSERT(0) ;
7720 return ;
7721 }
7722
7723 pWDA = pWdaParams->pWdaContext;
7724 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7725
7726 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7727 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7728 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7729 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7730 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7731
7732 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7733 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7734 return ;
7735}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7736/*
7737 * FUNCTION: WDA_ProcessAddTSReq
7738 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
7739 */
7740VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
7741 tAggrAddTsParams *pAggrAddTsReqParams)
7742{
7743 WDI_Status status = WDI_STATUS_SUCCESS ;
7744 int i;
7745 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7746 tWDA_ReqParams *pWdaParams = NULL;
7747
7748
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7750 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7751 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
7752 sizeof(WDI_AggrAddTSReqParamsType)) ;
7753 if(NULL == wdiAggrAddTSReqParam)
7754 {
7755 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7756 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7757 VOS_ASSERT(0);
7758 return VOS_STATUS_E_NOMEM;
7759 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7760
7761
7762 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7763 if(NULL == pWdaParams)
7764 {
7765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7766 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7767 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7768 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7769 VOS_ASSERT(0);
7770 return VOS_STATUS_E_NOMEM;
7771 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7772 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
7773 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
7774 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7775 for( i = 0; i < WDI_MAX_NO_AC; i++ )
7776 {
7777 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
7778 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
7779 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7780 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
7781 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
7782 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
7783 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
7784 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
7785 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
7786 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
7787 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
7788 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
7789 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
7790 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
7791 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
7792 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
7793 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
7794 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
7795 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7796 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
7797 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7798 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
7799 pAggrAddTsReqParams->tspec[i].nomMsduSz;
7800 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
7801 pAggrAddTsReqParams->tspec[i].maxMsduSz;
7802 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
7803 pAggrAddTsReqParams->tspec[i].minSvcInterval;
7804 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
7805 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
7806 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
7807 pAggrAddTsReqParams->tspec[i].inactInterval;
7808 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
7809 pAggrAddTsReqParams->tspec[i].suspendInterval;
7810 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
7811 pAggrAddTsReqParams->tspec[i].svcStartTime;
7812 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
7813 pAggrAddTsReqParams->tspec[i].minDataRate;
7814 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
7815 pAggrAddTsReqParams->tspec[i].meanDataRate;
7816 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
7817 pAggrAddTsReqParams->tspec[i].peakDataRate;
7818 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
7819 pAggrAddTsReqParams->tspec[i].maxBurstSz;
7820 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
7821 pAggrAddTsReqParams->tspec[i].delayBound;
7822 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
7823 pAggrAddTsReqParams->tspec[i].minPhyRate;
7824 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
7825 pAggrAddTsReqParams->tspec[i].surplusBw;
7826 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
7827 pAggrAddTsReqParams->tspec[i].mediumTime;
7828 }
7829
7830 /* TODO: tAggrAddTsParams doesn't have the following fields */
7831#if 0
7832 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7833 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
7834 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7835 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7836#endif
7837 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
7838
7839 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7840 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7841 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7842 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
7843
7844 pWdaParams->pWdaContext = pWDA;
7845
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7846 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7847 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
7848
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7849 if(IS_WDI_STATUS_FAILURE(status))
7850 {
7851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7852 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7853 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7854 vos_mem_free(pWdaParams);
7855
7856 /* send the failure response back to PE*/
7857 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7858 {
7859 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
7860 }
7861
7862 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
7863 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7864 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7865 return CONVERT_WDI2VOS_STATUS(status) ;
7866}
7867#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7868/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7869 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7870 * send Enter IMPS RSP back to PE
7871 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7872void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7873{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7874 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7875 tWDA_CbContext *pWDA;
7876
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7878 "<------ %s status=%d" ,__func__,status);
7879 if(NULL == pWdaParams)
7880 {
7881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7882 "%s: pWdaParams received NULL", __func__);
7883 VOS_ASSERT(0);
7884 return;
7885 }
7886
7887 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7888
7889 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7890 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7891 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7892 return ;
7893}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7894
7895
7896/*
7897 * FUNCTION: WDA_EnterImpsReqCallback
7898 * Free memory and send Enter IMPS RSP back to PE.
7899 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
7900 */
7901void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7902{
7903 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7904 tWDA_CbContext *pWDA;
7905
7906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7907 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7908
7909 if(NULL == pWdaParams)
7910 {
7911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7912 "%s: pWdaParams received NULL", __func__);
7913 VOS_ASSERT(0);
7914 return;
7915 }
7916
7917 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7918
7919 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7920 {
7921 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7922 vos_mem_free(pWdaParams);
7923 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7924 CONVERT_WDI2SIR_STATUS(wdiStatus));
7925 }
7926
7927 return;
7928}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7929/*
7930 * FUNCTION: WDA_ProcessEnterImpsReq
7931 * Request to WDI to Enter IMPS power state.
7932 */
7933VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
7934{
7935 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7936 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
7937 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7939 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7940
7941
7942 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
7943 if (NULL == wdiEnterImpsReqParams)
7944 {
7945 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7946 "%s: VOS MEM Alloc Failure", __func__);
7947 VOS_ASSERT(0);
7948 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7949 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7950 return VOS_STATUS_E_NOMEM;
7951 }
7952
7953 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7954 if (NULL == pWdaParams)
7955 {
7956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7957 "%s: VOS MEM Alloc Failure", __func__);
7958 VOS_ASSERT(0);
7959 vos_mem_free(wdiEnterImpsReqParams);
7960 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
7961 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7962 return VOS_STATUS_E_NOMEM;
7963 }
7964
7965 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
7966 wdiEnterImpsReqParams->pUserData = pWdaParams;
7967
7968 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
7969 pWdaParams->wdaMsgParam = NULL;
7970 pWdaParams->pWdaContext = pWDA;
7971
7972 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
7973 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
7974 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7975 if(IS_WDI_STATUS_FAILURE(status))
7976 {
7977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7978 "Failure in Enter IMPS REQ WDI API, free all the memory " );
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7979 vos_mem_free(wdiEnterImpsReqParams);
7980 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7981 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7982 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7983 return CONVERT_WDI2VOS_STATUS(status) ;
7984}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7985/*
7986 * FUNCTION: WDA_ExitImpsReqCallback
7987 * send Exit IMPS RSP back to PE
7988 */
7989void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
7990{
7991 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7993 "<------ %s " ,__func__);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7994 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7995 return ;
7996}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7997/*
7998 * FUNCTION: WDA_ProcessExitImpsReq
7999 * Request to WDI to Exit IMPS power state.
8000 */
8001VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
8002{
8003 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8005 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8006 status = WDI_ExitImpsReq((WDI_ExitImpsRspCb)WDA_ExitImpsReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8007 if(IS_WDI_STATUS_FAILURE(status))
8008 {
8009 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8010 "Failure in Exit IMPS REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8011 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8012 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8013 return CONVERT_WDI2VOS_STATUS(status) ;
8014}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8015/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8016 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8017 * send Enter BMPS RSP back to PE
8018 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8019void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8020{
8021 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8022 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8023 tEnterBmpsParams *pEnterBmpsRspParams;
8024
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8026 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8027 if(NULL == pWdaParams)
8028 {
8029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8030 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8031 VOS_ASSERT(0) ;
8032 return ;
8033 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8034
8035 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8036 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8037
8038 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8039 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8040
8041 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8042 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8043 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
8044
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8045 return ;
8046}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8047/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8048 * FUNCTION: WDA_EnterBmpsReqCallback
8049 * Free memory and send Enter BMPS RSP back to PE.
8050 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
8051 */
8052void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8053{
8054 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8055 tWDA_CbContext *pWDA;
8056 tEnterBmpsParams *pEnterBmpsRspParams;
8057
8058 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8059 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8060
8061 if(NULL == pWdaParams)
8062 {
8063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8064 "%s: pWdaParams received NULL", __func__);
8065 VOS_ASSERT(0);
8066 return;
8067 }
8068
8069 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8070 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
8071 pEnterBmpsRspParams->status = wdiStatus;
8072
8073 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8074 {
8075 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8076 vos_mem_free(pWdaParams);
8077 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
8078 }
8079
8080 return;
8081}
8082/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8083 * FUNCTION: WDA_ProcessEnterBmpsReq
8084 * Request to WDI to Enter BMPS power state.
8085 */
8086VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
8087 tEnterBmpsParams *pEnterBmpsReqParams)
8088{
8089 WDI_Status status = WDI_STATUS_SUCCESS;
8090 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
8091 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8092 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8093 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8094 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
8095 {
8096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8097 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8098 VOS_ASSERT(0);
8099 return VOS_STATUS_E_FAILURE;
8100 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8101 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
8102 if (NULL == wdiEnterBmpsReqParams)
8103 {
8104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8105 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8106 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8107 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8108 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8109 return VOS_STATUS_E_NOMEM;
8110 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8111 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8112 if (NULL == pWdaParams)
8113 {
8114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8115 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8116 VOS_ASSERT(0);
8117 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8118 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
8119 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8120 return VOS_STATUS_E_NOMEM;
8121 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8122 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
8123 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
8124 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
8125 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]8126 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8127 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
8128 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
8129 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8130 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
8131 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8132
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8133 /* Store param pointer as passed in by caller */
8134 /* store Params pass it to WDI */
8135 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8136 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8137 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8138 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8139 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8140 if (IS_WDI_STATUS_FAILURE(status))
8141 {
8142 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8143 "Failure in Enter BMPS REQ WDI API, free all the memory" );
8144 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8145 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8146 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8147 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8148 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8149 return CONVERT_WDI2VOS_STATUS(status);
8150}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8151
8152
8153static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
8154 WDI_Status wdiStatus,
8155 tExitBmpsParams *pExitBmpsReqParams)
8156{
8157 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
8158
8159 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
8160}
8161
8162
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8163/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8164 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8165 * send Exit BMPS RSP back to PE
8166 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8167void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8168{
8169 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8170 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8171 tExitBmpsParams *pExitBmpsRspParams;
8172
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8173 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8174 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8175 if(NULL == pWdaParams)
8176 {
8177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8178 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8179 VOS_ASSERT(0) ;
8180 return ;
8181 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8182
8183 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8184 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8185
8186 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8187 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8188
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8189 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8190 vos_mem_free(pWdaParams) ;
8191
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8192 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8193 return ;
8194}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8195/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8196 * FUNCTION: WDA_ExitBmpsReqCallback
8197 * Free memory and send Exit BMPS RSP back to PE.
8198 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
8199 */
8200void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8201{
8202 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8203 tWDA_CbContext *pWDA;
8204 tExitBmpsParams *pExitBmpsRspParams;
8205
8206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8207 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8208
8209 if(NULL == pWdaParams)
8210 {
8211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8212 "%s: pWdaParams received NULL", __func__);
8213 VOS_ASSERT(0);
8214 return;
8215 }
8216
8217 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8218 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
8219 pExitBmpsRspParams->status = wdiStatus;
8220
8221 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8222 {
8223 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8224 vos_mem_free(pWdaParams);
8225 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
8226 }
8227
8228 return;
8229}
8230/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8231 * FUNCTION: WDA_ProcessExitBmpsReq
8232 * Request to WDI to Exit BMPS power state.
8233 */
8234VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
8235 tExitBmpsParams *pExitBmpsReqParams)
8236{
8237 WDI_Status status = WDI_STATUS_SUCCESS ;
8238 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
8239 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
8240 sizeof(WDI_ExitBmpsReqParamsType)) ;
8241 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8242 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8243 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8244 if(NULL == wdiExitBmpsReqParams)
8245 {
8246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8247 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8248 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8249 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8250 return VOS_STATUS_E_NOMEM;
8251 }
8252 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8253 if(NULL == pWdaParams)
8254 {
8255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8256 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8257 VOS_ASSERT(0);
8258 vos_mem_free(wdiExitBmpsReqParams);
8259 return VOS_STATUS_E_NOMEM;
8260 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8261 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8262
8263 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
8264
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8265 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
8266 wdiExitBmpsReqParams->pUserData = pWdaParams;
8267
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8268 /* Store param pointer as passed in by caller */
8269 /* store Params pass it to WDI */
8270 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
8271 pWdaParams->pWdaContext = pWDA;
8272 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8273 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8274 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8275 if(IS_WDI_STATUS_FAILURE(status))
8276 {
8277 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8278 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8279 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8280 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]8281 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8282 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8283 return CONVERT_WDI2VOS_STATUS(status) ;
8284}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8285/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8286 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8287 * send Enter UAPSD RSP back to PE
8288 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8289void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8290{
8291 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8292 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8293 tUapsdParams *pEnterUapsdRsqParams;
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 == pWdaParams)
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: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8300 VOS_ASSERT(0) ;
8301 return ;
8302 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8303
8304 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8305 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8306
8307 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8308 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8309
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8310 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8311 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8312 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8313 return ;
8314}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8315/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8316 * FUNCTION: WDA_EnterUapsdReqCallback
8317 * Free memory and send Enter UAPSD RSP back to PE.
8318 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
8319 */
8320void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8321{
8322 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8323 tWDA_CbContext *pWDA;
8324 tUapsdParams *pEnterUapsdRsqParams;
8325
8326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8327 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8328
8329 if(NULL == pWdaParams)
8330 {
8331 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8332 "%s: pWdaParams received NULL", __func__);
8333 VOS_ASSERT(0);
8334 return;
8335 }
8336
8337 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8338 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8339 pEnterUapsdRsqParams->status = wdiStatus;
8340
8341 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8342 {
8343 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8344 vos_mem_free(pWdaParams);
8345 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
8346 }
8347
8348 return;
8349}
8350/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8351 * FUNCTION: WDA_ProcessEnterUapsdReq
8352 * Request to WDI to Enter UAPSD power state.
8353 */
8354VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
8355 tUapsdParams *pEnterUapsdReqParams)
8356{
8357 WDI_Status status = WDI_STATUS_SUCCESS ;
8358 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
8359 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
8360 sizeof(WDI_EnterUapsdReqParamsType)) ;
8361 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8363 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8364 if(NULL == wdiEnterUapsdReqParams)
8365 {
8366 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8367 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8368 VOS_ASSERT(0);
8369 return VOS_STATUS_E_NOMEM;
8370 }
8371 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8372 if(NULL == pWdaParams)
8373 {
8374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8375 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8376 VOS_ASSERT(0);
8377 vos_mem_free(wdiEnterUapsdReqParams);
8378 return VOS_STATUS_E_NOMEM;
8379 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8380 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
8381 pEnterUapsdReqParams->beDeliveryEnabled;
8382 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
8383 pEnterUapsdReqParams->beTriggerEnabled;
8384 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
8385 pEnterUapsdReqParams->bkDeliveryEnabled;
8386 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
8387 pEnterUapsdReqParams->bkTriggerEnabled;
8388 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
8389 pEnterUapsdReqParams->viDeliveryEnabled;
8390 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
8391 pEnterUapsdReqParams->viTriggerEnabled;
8392 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
8393 pEnterUapsdReqParams->voDeliveryEnabled;
8394 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
8395 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8396 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8397
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8398 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
8399 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8400
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8401 /* Store param pointer as passed in by caller */
8402 /* store Params pass it to WDI */
8403 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
8404 pWdaParams->pWdaContext = pWDA;
8405 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8406 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8407 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8408 if(IS_WDI_STATUS_FAILURE(status))
8409 {
8410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8411 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
8412 vos_mem_free(pWdaParams->wdaMsgParam) ;
8413 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8414 vos_mem_free(pWdaParams) ;
8415 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8416 return CONVERT_WDI2VOS_STATUS(status) ;
8417}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8418/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8419 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8420 * send Exit UAPSD RSP back to PE
8421 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8422void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8423{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8424
8425 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8426 tWDA_CbContext *pWDA;
8427 tExitUapsdParams *pExitUapsdRspParams;
8428
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8430 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8431 if(NULL == pWdaParams)
8432 {
8433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8434 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8435 VOS_ASSERT(0);
8436 return;
8437 }
8438
8439 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8440 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8441
8442 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8443 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8444
8445 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8446 vos_mem_free(pWdaParams) ;
8447
8448 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8449 return ;
8450}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8451/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8452 * FUNCTION: WDA_ExitUapsdReqCallback
8453 * Free memory and send Exit UAPSD RSP back to PE.
8454 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
8455 */
8456void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8457{
8458 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8459 tWDA_CbContext *pWDA;
8460 tExitUapsdParams *pExitUapsdRspParams;
8461
8462 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8463 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8464
8465 if(NULL == pWdaParams)
8466 {
8467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8468 "%s: pWdaParams received NULL", __func__);
8469 VOS_ASSERT(0);
8470 return;
8471 }
8472
8473 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8474 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8475 pExitUapsdRspParams->status = wdiStatus;
8476
8477 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8478 {
8479 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8480 vos_mem_free(pWdaParams);
8481 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
8482 }
8483
8484 return;
8485}
8486/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8487 * FUNCTION: WDA_ProcessExitUapsdReq
8488 * Request to WDI to Exit UAPSD power state.
8489 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8490VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
8491 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8492{
8493 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8494 tWDA_ReqParams *pWdaParams ;
8495 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
8496 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
8497 sizeof(WDI_ExitUapsdReqParamsType)) ;
8498
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8499 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8500 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8501
8502 if(NULL == wdiExitUapsdReqParams)
8503 {
8504 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8505 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8506 VOS_ASSERT(0);
8507 return VOS_STATUS_E_NOMEM;
8508 }
8509 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8510 if(NULL == pWdaParams)
8511 {
8512 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8513 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8514 VOS_ASSERT(0);
8515 vos_mem_free(wdiExitUapsdReqParams);
8516 return VOS_STATUS_E_NOMEM;
8517 }
8518
8519 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8520 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
8521 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8522
8523 /* Store param pointer as passed in by caller */
8524 /* store Params pass it to WDI */
8525 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
8526 pWdaParams->pWdaContext = pWDA;
8527 pWdaParams->wdaMsgParam = pExitUapsdParams;
8528
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8529 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8530 if(IS_WDI_STATUS_FAILURE(status))
8531 {
8532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8533 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8534 vos_mem_free(pWdaParams->wdaMsgParam) ;
8535 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8536 vos_mem_free(pWdaParams) ;
8537
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8538 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8539 return CONVERT_WDI2VOS_STATUS(status) ;
8540}
8541
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8542/*
8543 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
8544 *
8545 */
8546void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
8547{
8548 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8549 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8550 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8551 if(NULL == pWdaParams)
8552 {
8553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8554 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8555 VOS_ASSERT(0) ;
8556 return ;
8557 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8558 if( pWdaParams != NULL )
8559 {
8560 if( pWdaParams->wdaWdiApiMsgParam != NULL )
8561 {
8562 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8563 }
8564 if( pWdaParams->wdaMsgParam != NULL )
8565 {
8566 vos_mem_free(pWdaParams->wdaMsgParam) ;
8567 }
8568 vos_mem_free(pWdaParams) ;
8569 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8570 return ;
8571}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8572/*
8573 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
8574 * Request to WDI to set the power save params at start.
8575 */
8576VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
8577 tSirPowerSaveCfg *pPowerSaveCfg)
8578{
8579 WDI_Status status = WDI_STATUS_SUCCESS ;
8580 tHalCfg *tlvStruct = NULL ;
8581 tANI_U8 *tlvStructStart = NULL ;
8582 v_PVOID_t *configParam;
8583 tANI_U32 configParamSize;
8584 tANI_U32 *configDataValue;
8585 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
8586 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8588 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8589 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
8590 {
8591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8592 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8593 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8594 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8595 return VOS_STATUS_E_FAILURE;
8596 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8597 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
8598 if (NULL == wdiPowerSaveCfg)
8599 {
8600 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8601 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8602 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8603 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8604 return VOS_STATUS_E_NOMEM;
8605 }
8606 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8607 if(NULL == pWdaParams)
8608 {
8609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8610 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8611 VOS_ASSERT(0);
8612 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8613 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8614 return VOS_STATUS_E_NOMEM;
8615 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8616 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
8617 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8618 if(NULL == configParam)
8619 {
8620 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8621 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8622 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8623 vos_mem_free(pWdaParams);
8624 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8625 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8626 return VOS_STATUS_E_NOMEM;
8627 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8628 vos_mem_set(configParam, configParamSize, 0);
8629 wdiPowerSaveCfg->pConfigBuffer = configParam;
8630 tlvStruct = (tHalCfg *)configParam;
8631 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8632 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
8633 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
8634 tlvStruct->length = sizeof(tANI_U32);
8635 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8636 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8637 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8638 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8639 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
8640 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
8641 tlvStruct->length = sizeof(tANI_U32);
8642 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8643 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8644 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8645 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8646 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
8647 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
8648 tlvStruct->length = sizeof(tANI_U32);
8649 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8650 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8651 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8652 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8653 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
8654 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
8655 tlvStruct->length = sizeof(tANI_U32);
8656 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8657 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8658 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8659 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8660 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
8661 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
8662 tlvStruct->length = sizeof(tANI_U32);
8663 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8664 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8665 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8666 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8667 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
8668 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
8669 tlvStruct->length = sizeof(tANI_U32);
8670 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8671 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8672 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8673 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8674 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
8675 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
8676 tlvStruct->length = sizeof(tANI_U32);
8677 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8678 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8679 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8680 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8681 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
8682 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
8683 tlvStruct->length = sizeof(tANI_U32);
8684 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8685 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
8686 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8687 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8688 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
8689 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
8690 tlvStruct->length = sizeof(tANI_U32);
8691 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8692 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
8693 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8694 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8695 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
8696 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
8697 tlvStruct->length = sizeof(tANI_U32);
8698 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8699 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8700 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8701 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8702 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
8703 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
8704 tlvStruct->length = sizeof(tANI_U32);
8705 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8706 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8707 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8708 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8709 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8710 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8711 /* store Params pass it to WDI */
8712 pWdaParams->wdaMsgParam = configParam;
8713 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
8714 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8715 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
8716 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8717 if(IS_WDI_STATUS_FAILURE(status))
8718 {
8719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8720 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
8721 vos_mem_free(pWdaParams->wdaMsgParam);
8722 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8723 vos_mem_free(pWdaParams);
8724 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8725 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8726 return CONVERT_WDI2VOS_STATUS(status);
8727}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8728/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8729 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8730 *
8731 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8732void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8733{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8734 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8735
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8737 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8738
8739 if(NULL == pWdaParams)
8740 {
8741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8742 "%s: pWdaParams received NULL", __func__);
8743 VOS_ASSERT(0);
8744 return ;
8745 }
8746
8747 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8748 vos_mem_free(pWdaParams);
8749
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8750 return ;
8751}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8752/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8753 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
8754 * Free memory.
8755 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
8756 */
8757void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8758{
8759 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8760
8761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8762 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8763
8764 if(NULL == pWdaParams)
8765 {
8766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8767 "%s: pWdaParams received NULL", __func__);
8768 VOS_ASSERT(0);
8769 return;
8770 }
8771
8772 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8773 {
8774 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8775 vos_mem_free(pWdaParams);
8776 }
8777
8778 return;
8779}
8780/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8781 * FUNCTION: WDA_SetUapsdAcParamsReq
8782 * Request to WDI to set the UAPSD params for an ac (sta mode).
8783 */
8784VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
8785 tUapsdInfo *pUapsdInfo)
8786{
8787 WDI_Status status = WDI_STATUS_SUCCESS;
8788 tWDA_CbContext *pWDA = NULL ;
8789 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
8790 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
8791 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
8792 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8794 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8795 if(NULL == wdiUapsdParams)
8796 {
8797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8798 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8799 VOS_ASSERT(0);
8800 return VOS_STATUS_E_NOMEM;
8801 }
8802 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8803 if(NULL == pWdaParams)
8804 {
8805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8806 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8807 VOS_ASSERT(0);
8808 vos_mem_free(wdiUapsdParams);
8809 return VOS_STATUS_E_NOMEM;
8810 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8811 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
8812 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
8813 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
8814 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
8815 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
8816 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8817 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
8818 wdiUapsdParams->pUserData = pWdaParams;
8819
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8820 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8821 pWdaParams->pWdaContext = pWDA;
8822 /* Store param pointer as passed in by caller */
8823 pWdaParams->wdaMsgParam = pUapsdInfo;
8824 /* store Params pass it to WDI */
8825 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8826 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8827 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8828 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8829 if(IS_WDI_STATUS_FAILURE(status))
8830 {
8831 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8832 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
8833 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8834 vos_mem_free(pWdaParams);
8835 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8836 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
8837 return VOS_STATUS_SUCCESS;
8838 else
8839 return VOS_STATUS_E_FAILURE;
8840
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8841}
8842/*
8843 * FUNCTION: WDA_ClearUapsdAcParamsReq
8844 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
8845 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
8846 * and again enter the UPASD with the modified params. Hence the disable
8847 * function was kept empty.
8848 *
8849 */
8850VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
8851{
8852 /* do nothing */
8853 return VOS_STATUS_SUCCESS;
8854}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8855/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8856 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8857 *
8858 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8859void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8860{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8861 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8862
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8864 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8865
8866 if(NULL == pWdaParams)
8867 {
8868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8869 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8870 VOS_ASSERT(0) ;
8871 return ;
8872 }
8873
8874 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8875 vos_mem_free(pWdaParams->wdaMsgParam);
8876 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8877
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8878 //print a msg, nothing else to do
8879 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8880 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8881 return ;
8882}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8883/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8884 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
8885 * Free memory.
8886 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
8887 */
8888void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8889{
8890 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8891
8892 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8893 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8894
8895 if(NULL == pWdaParams)
8896 {
8897 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8898 "%s: pWdaParams received NULL", __func__);
8899 VOS_ASSERT(0);
8900 return;
8901 }
8902
8903 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8904 {
8905 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8906 vos_mem_free(pWdaParams->wdaMsgParam);
8907 vos_mem_free(pWdaParams);
8908 }
8909
8910 return;
8911}
8912/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8913 * FUNCTION: WDA_UpdateUapsdParamsReq
8914 * Request to WDI to update UAPSD params (in softAP mode) for a station.
8915 */
8916VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
8917 tUpdateUapsdParams* pUpdateUapsdInfo)
8918{
8919 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8920 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8921 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
8922 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
8923 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8924 tWDA_ReqParams *pWdaParams = NULL;
8925
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8927 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8928 if(NULL == wdiUpdateUapsdParams)
8929 {
8930 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8931 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8932 VOS_ASSERT(0);
8933 return VOS_STATUS_E_NOMEM;
8934 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8935 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
8936 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
8937 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8938 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
8939 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8940
8941 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8942 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8943 {
8944 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8945 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8946 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8947 vos_mem_free(pUpdateUapsdInfo);
8948 vos_mem_free(wdiUpdateUapsdParams);
8949 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8950 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8951 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8952 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8953 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8954 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
8955 pWdaParams->pWdaContext = pWDA;
8956
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8957 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8958 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8959 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8960
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8961 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8962 {
8963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8964 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8965 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
8966 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8967 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8968 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8969 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8970 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8971}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8972/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8973 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8974 *
8975 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8976void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8977{
8978 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8980 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8981 if(WDI_STATUS_SUCCESS != wdiStatus)
8982 {
8983 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8984 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8985 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8986 if(NULL == pWdaParams)
8987 {
8988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8989 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8990 VOS_ASSERT(0) ;
8991 return ;
8992 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8993 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8994 vos_mem_free(pWdaParams->wdaMsgParam);
8995 vos_mem_free(pWdaParams);
8996 return ;
8997}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8998/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8999 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
9000 * Free memory.
9001 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
9002 */
9003void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9004{
9005 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9006
9007 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9008 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9009
9010 if(NULL == pWdaParams)
9011 {
9012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9013 "%s: pWdaParams received NULL", __func__);
9014 VOS_ASSERT(0);
9015 return;
9016 }
9017
9018 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9019 {
9020 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9021 vos_mem_free(pWdaParams->wdaMsgParam);
9022 vos_mem_free(pWdaParams);
9023 }
9024
9025 return;
9026}
9027/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9028 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
9029 *
9030 */
9031VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
9032 tSirWlanSetRxpFilters *pWlanSuspendParam)
9033{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9034 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9035 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]9036 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9037 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]9038 /* Sanity Check
9039 * This is very unlikely and add assert to collect more info next time */
9040 if(NULL == pWlanSuspendParam)
9041 {
9042 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9043 "%s: pWlanSuspendParam received NULL", __func__);
9044 VOS_ASSERT(0) ;
9045 return VOS_STATUS_E_FAULT;
9046 }
9047 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
9048 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9050 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9051 if(NULL == wdiRxpFilterParams)
9052 {
9053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9054 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9055 VOS_ASSERT(0);
9056 vos_mem_free(pWlanSuspendParam);
9057 return VOS_STATUS_E_NOMEM;
9058 }
9059 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9060 if(NULL == pWdaParams)
9061 {
9062 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9063 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9064 VOS_ASSERT(0);
9065 vos_mem_free(wdiRxpFilterParams);
9066 vos_mem_free(pWlanSuspendParam);
9067 return VOS_STATUS_E_NOMEM;
9068 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9069 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
9070 pWlanSuspendParam->setMcstBcstFilter;
9071 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
9072 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9073
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9074 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
9075 wdiRxpFilterParams->pUserData = pWdaParams;
9076
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9077 pWdaParams->pWdaContext = pWDA;
9078 pWdaParams->wdaMsgParam = pWlanSuspendParam;
9079 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9080 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9081 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9082 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9083 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9084 {
9085 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9086 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9087 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9088 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9089 vos_mem_free(pWdaParams->wdaMsgParam);
9090 vos_mem_free(pWdaParams);
9091 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9092 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9093}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9094/*
9095 * FUNCTION: WDA_WdiIndicationCallback
9096 *
9097 */
9098void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
9099 void* pUserData)
9100{
9101 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9102 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9103}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9104/*
9105 * FUNCTION: WDA_ProcessWlanSuspendInd
9106 *
9107 */
9108VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
9109 tSirWlanSuspendParam *pWlanSuspendParam)
9110{
9111 WDI_Status wdiStatus;
9112 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9113 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9114 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9115 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
9116 pWlanSuspendParam->configuredMcstBcstFilterSetting;
9117 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
9118 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9119 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]9120 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
9121 if(WDI_STATUS_PENDING == wdiStatus)
9122 {
9123 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9124 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9125 }
9126 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9127 {
9128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9129 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9130 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9131 vos_mem_free(pWlanSuspendParam);
9132 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9133}
9134
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]9135#ifdef WLAN_FEATURE_11W
9136/*
9137 * FUNCTION: WDA_ProcessExcludeUnecryptInd
9138 *
9139 */
9140VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
9141 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
9142{
9143 WDI_Status wdiStatus;
9144 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
9145 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9146 "------> %s ", __func__);
9147
9148 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
9149 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
9150 sizeof(tSirMacAddr));
9151
9152 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
9153 wdiExclUnencryptParams.pUserData = pWDA;
9154
9155 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
9156 if(WDI_STATUS_PENDING == wdiStatus)
9157 {
9158 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9159 "Pending received for %s:%d ", __func__, __LINE__ );
9160 }
9161 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
9162 {
9163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9164 "Failure in %s:%d ", __func__, __LINE__ );
9165 }
9166 vos_mem_free(pExclUnencryptParam);
9167 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9168}
9169#endif
9170
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9171/*
9172 * FUNCTION: WDA_ProcessWlanResumeCallback
9173 *
9174 */
9175void WDA_ProcessWlanResumeCallback(
9176 WDI_SuspendResumeRspParamsType *resumeRspParams,
9177 void* pUserData)
9178{
9179 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9180 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9181 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9182 if(NULL == pWdaParams)
9183 {
9184 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9185 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9186 VOS_ASSERT(0) ;
9187 return ;
9188 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9189 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
9190 {
9191 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]9192 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9193 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9194 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9195 vos_mem_free(pWdaParams->wdaMsgParam);
9196 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9197 return ;
9198}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9199/*
9200 * FUNCTION: WDA_ProcessWlanResumeReq
9201 *
9202 */
9203VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
9204 tSirWlanResumeParam *pWlanResumeParam)
9205{
9206 WDI_Status wdiStatus;
9207 WDI_ResumeParamsType *wdiResumeParams =
9208 (WDI_ResumeParamsType *)vos_mem_malloc(
9209 sizeof(WDI_ResumeParamsType) ) ;
9210 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9212 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9213 if(NULL == wdiResumeParams)
9214 {
9215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9216 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9217 VOS_ASSERT(0);
9218 return VOS_STATUS_E_NOMEM;
9219 }
9220 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9221 if(NULL == pWdaParams)
9222 {
9223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9224 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9225 VOS_ASSERT(0);
9226 vos_mem_free(wdiResumeParams);
9227 return VOS_STATUS_E_NOMEM;
9228 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9229 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
9230 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9231 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]9232 wdiResumeParams->wdiReqStatusCB = NULL;
9233 pWdaParams->wdaMsgParam = pWlanResumeParam;
9234 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
9235 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9236 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
9237 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
9238 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9239 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9240 {
9241 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9242 "Failure in Host Resume REQ WDI API, free all the memory " );
9243 VOS_ASSERT(0);
9244 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9245 vos_mem_free(pWdaParams->wdaMsgParam);
9246 vos_mem_free(pWdaParams);
9247 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9248 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
9249}
9250
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9251/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9252 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9253 *
9254 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9255void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9256{
9257 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9259 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9260 if(NULL == pWdaParams)
9261 {
9262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9263 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9264 VOS_ASSERT(0) ;
9265 return ;
9266 }
9267
9268 vos_mem_free(pWdaParams->wdaMsgParam) ;
9269 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9270 vos_mem_free(pWdaParams) ;
9271 /*
9272 * No respone required for SetBeaconFilter req so just free the request
9273 * param here
9274 */
9275
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9276 return ;
9277}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9278/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9279 * FUNCTION: WDA_SetBeaconFilterReqCallback
9280 * Free memory.
9281 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
9282 */
9283void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9284{
9285 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9286
9287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9288 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9289
9290 if(NULL == pWdaParams)
9291 {
9292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9293 "%s: pWdaParams received NULL", __func__);
9294 VOS_ASSERT(0);
9295 return;
9296 }
9297
9298 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9299 {
9300 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9301 vos_mem_free(pWdaParams->wdaMsgParam);
9302 vos_mem_free(pWdaParams);
9303 }
9304
9305 return;
9306}
9307/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9308 * FUNCTION: WDA_SetBeaconFilterReq
9309 * Request to WDI to send the beacon filtering related information.
9310 */
9311VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
9312 tBeaconFilterMsg* pBeaconFilterInfo)
9313{
9314 WDI_Status status = WDI_STATUS_SUCCESS;
9315 tANI_U8 *dstPtr, *srcPtr;
9316 tANI_U8 filterLength;
9317 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
9318 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
9319 sizeof(WDI_BeaconFilterReqParamsType) ) ;
9320 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9321 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9322 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9323 if(NULL == wdiBeaconFilterInfo)
9324 {
9325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9326 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9327 VOS_ASSERT(0);
9328 return VOS_STATUS_E_NOMEM;
9329 }
9330 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9331 if(NULL == pWdaParams)
9332 {
9333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9334 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9335 VOS_ASSERT(0);
9336 vos_mem_free(wdiBeaconFilterInfo);
9337 return VOS_STATUS_E_NOMEM;
9338 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9339 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
9340 pBeaconFilterInfo->beaconInterval;
9341 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
9342 pBeaconFilterInfo->capabilityInfo;
9343 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
9344 pBeaconFilterInfo->capabilityMask;
9345 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]9346
9347 //Fill the BssIdx
9348 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
9349
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9350 //Fill structure with info contained in the beaconFilterTable
9351 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
9352 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
9353 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
9354 if(WDI_BEACON_FILTER_LEN < filterLength)
9355 {
9356 filterLength = WDI_BEACON_FILTER_LEN;
9357 }
9358 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9359 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
9360 wdiBeaconFilterInfo->pUserData = pWdaParams;
9361
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9362 /* Store param pointer as passed in by caller */
9363 /* store Params pass it to WDI */
9364 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
9365 pWdaParams->pWdaContext = pWDA;
9366 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
9367
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9368 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9369 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9370 if(IS_WDI_STATUS_FAILURE(status))
9371 {
9372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9373 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
9374 vos_mem_free(pWdaParams->wdaMsgParam) ;
9375 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9376 vos_mem_free(pWdaParams) ;
9377 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9378 return CONVERT_WDI2VOS_STATUS(status) ;
9379}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9380/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9381 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9382 *
9383 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9384void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9385{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9386 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9387
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9388 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9389 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9390
9391 if(NULL == pWdaParams)
9392 {
9393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9394 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9395 VOS_ASSERT(0) ;
9396 return ;
9397 }
9398
9399 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9400 vos_mem_free(pWdaParams->wdaMsgParam);
9401 vos_mem_free(pWdaParams);
9402
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9403 //print a msg, nothing else to do
9404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9405 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9406 return ;
9407}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9408/*
9409 * FUNCTION: WDA_RemBeaconFilterReqCallback
9410 * Free memory.
9411 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
9412 */
9413void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9414{
9415 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9416
9417 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9418 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9419
9420 if(NULL == pWdaParams)
9421 {
9422 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9423 "%s: pWdaParams received NULL", __func__);
9424 VOS_ASSERT(0);
9425 return;
9426 }
9427
9428 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9429 {
9430 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9431 vos_mem_free(pWdaParams->wdaMsgParam);
9432 vos_mem_free(pWdaParams);
9433 }
9434
9435 return;
9436}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9437 // TODO: PE does not have this feature for now implemented,
9438 // but the support for removing beacon filter exists between
9439 // HAL and FW. This function can be called whenever PE defines
9440 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9441/*
9442 * FUNCTION: WDA_RemBeaconFilterReq
9443 * Request to WDI to send the removal of beacon filtering related information.
9444 */
9445VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
9446 tRemBeaconFilterMsg* pBeaconFilterInfo)
9447{
9448 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9449 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9450 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
9451 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
9452 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9453 tWDA_ReqParams *pWdaParams ;
9454
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9455 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9456 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9457 if(NULL == wdiBeaconFilterInfo)
9458 {
9459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9460 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9461 VOS_ASSERT(0);
9462 return VOS_STATUS_E_NOMEM;
9463 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9464 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9465 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9466 {
9467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9468 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9469 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9470 vos_mem_free(wdiBeaconFilterInfo);
9471 vos_mem_free(pBeaconFilterInfo);
9472 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9473 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9474
9475 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
9476 pBeaconFilterInfo->ucIeCount;
9477 //Fill structure with info contained in the ucRemIeId
9478 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
9479 pBeaconFilterInfo->ucRemIeId,
9480 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
9481 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
9482 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9483
9484 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9485 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9486 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9487 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
9488
9489 pWdaParams->pWdaContext = pWDA;
9490
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9491 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9492 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9493 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9494 {
9495 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9496 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9497 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9498 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9499 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9500 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9501 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9502 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9503}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9504/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9505 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9506 *
9507 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9508void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9509{
9510 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9512 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9513 if(NULL == pWdaParams)
9514 {
9515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9516 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9517 VOS_ASSERT(0) ;
9518 return ;
9519 }
9520
9521 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9522 vos_mem_free(pWdaParams) ;
9523
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9524 return ;
9525}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9526/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9527 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
9528 * Free memory.
9529 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
9530 */
9531void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
9532{
9533 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9534
9535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9536 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9537
9538 if(NULL == pWdaParams)
9539 {
9540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9541 "%s: pWdaParams received NULL", __func__);
9542 VOS_ASSERT(0);
9543 return;
9544 }
9545
9546 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9547 {
9548 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9549 vos_mem_free(pWdaParams);
9550 }
9551
9552 return;
9553}
9554/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9555 * FUNCTION: WDA_SetRSSIThresholdsReq
9556 * Request to WDI to set the RSSI thresholds (sta mode).
9557 */
9558VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
9559{
9560 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9561 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9562 tWDA_CbContext *pWDA = NULL ;
9563 v_PVOID_t pVosContext = NULL;
9564 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
9565 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
9566 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
9567 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9569 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9570 if(NULL == wdiRSSIThresholdsInfo)
9571 {
9572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9573 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9574 VOS_ASSERT(0);
9575 return VOS_STATUS_E_NOMEM;
9576 }
9577 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9578 if(NULL == pWdaParams)
9579 {
9580 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9581 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9582 VOS_ASSERT(0);
9583 vos_mem_free(wdiRSSIThresholdsInfo);
9584 return VOS_STATUS_E_NOMEM;
9585 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9586 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9587 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
9588 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
9589 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9590 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
9591 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
9592 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9593 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
9594 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
9595 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9596 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
9597 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9598 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
9599 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
9600
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9601 /* Store param pointer as passed in by caller */
9602 /* store Params pass it to WDI */
9603 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
9604 pWdaParams->pWdaContext = pWDA;
9605 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9606 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9607 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9608 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9609 {
9610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9611 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9612 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9613 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9614 vos_mem_free(pWdaParams) ;
9615 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9616 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9617
9618}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9619/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9620 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9621 *
9622 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9623void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9624{
9625 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9626
9627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9628 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9629 if(NULL == pWdaParams)
9630 {
9631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9632 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9633 VOS_ASSERT(0) ;
9634 return ;
9635 }
9636
9637 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9638 vos_mem_free(pWdaParams->wdaMsgParam);
9639 vos_mem_free(pWdaParams) ;
9640
9641 //print a msg, nothing else to do
9642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9643 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9644 return ;
9645}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9646/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9647 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9648 * Free memory.
9649 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9650 */
9651void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
9652{
9653 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9654
9655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9656 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9657
9658 if(NULL == pWdaParams)
9659 {
9660 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9661 "%s: Invalid pWdaParams pointer", __func__);
9662 VOS_ASSERT(0);
9663 return;
9664 }
9665
9666 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9667 {
9668 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9669 vos_mem_free(pWdaParams->wdaMsgParam);
9670 vos_mem_free(pWdaParams);
9671 }
9672
9673 return;
9674}
9675/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9676 * FUNCTION: WDA_ProcessHostOffloadReq
9677 * Request to WDI to set the filter to minimize unnecessary host wakeup due
9678 * to broadcast traffic (sta mode).
9679 */
9680VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
9681 tSirHostOffloadReq *pHostOffloadParams)
9682{
9683 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9684 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9685 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
9686 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
9687 sizeof(WDI_HostOffloadReqParamsType)) ;
9688 tWDA_ReqParams *pWdaParams ;
9689
9690 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9691 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9692
9693 if(NULL == wdiHostOffloadInfo)
9694 {
9695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9696 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9697 VOS_ASSERT(0);
9698 return VOS_STATUS_E_NOMEM;
9699 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9700 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9701 if(NULL == pWdaParams)
9702 {
9703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9704 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9705 VOS_ASSERT(0);
9706 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9707 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9708 return VOS_STATUS_E_NOMEM;
9709 }
9710
9711 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
9712 pHostOffloadParams->offloadType;
9713 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
9714 pHostOffloadParams->enableOrDisable;
9715
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9716 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
9717 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
9718
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9719 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
9720 {
9721 case SIR_IPV4_ARP_REPLY_OFFLOAD:
9722 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
9723 pHostOffloadParams->params.hostIpv4Addr,
9724 4);
9725 break;
9726 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
9727 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9728 pHostOffloadParams->params.hostIpv6Addr,
9729 16);
9730 break;
9731 case SIR_IPV6_NS_OFFLOAD:
9732 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9733 pHostOffloadParams->params.hostIpv6Addr,
9734 16);
9735
9736#ifdef WLAN_NS_OFFLOAD
9737 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
9738 {
9739 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
9740 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
9741 16);
9742 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
9743 }
9744 else
9745 {
9746 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
9747 }
9748
9749 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
9750 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
9751 16);
9752 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
9753 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
9754 6);
9755
9756 //Only two are supported so let's go through them without a loop
9757 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
9758 {
9759 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
9760 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
9761 16);
9762 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
9763 }
9764 else
9765 {
9766 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
9767 }
9768
9769 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
9770 {
9771 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
9772 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
9773 16);
9774 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
9775 }
9776 else
9777 {
9778 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
9779 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]9780 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
9781 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9782 break;
9783#endif //WLAN_NS_OFFLOAD
9784 default:
9785 {
9786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9787 "No Handling for Offload Type %x in WDA "
9788 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
9789 //WDA_VOS_ASSERT(0) ;
9790 }
9791 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9792 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
9793 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9794
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9795 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9796 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9797 /* store Params pass it to WDI */
9798 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
9799 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9800
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9801
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9802 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9803 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9804
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9805 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9806 {
9807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9808 "Failure in host offload REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9809 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9810 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9811 vos_mem_free(pWdaParams->wdaMsgParam);
9812 vos_mem_free(pWdaParams) ;
9813 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9814 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9815
9816}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9817/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9818 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9819 *
9820 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9821void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9822{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9823 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9824
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9825 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9826 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9827
9828 if(NULL == pWdaParams)
9829 {
9830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9831 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9832 VOS_ASSERT(0) ;
9833 return ;
9834 }
9835
9836 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9837 vos_mem_free(pWdaParams->wdaMsgParam);
9838 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9839
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9840 //print a msg, nothing else to do
9841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9842 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9843 return ;
9844}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9845/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9846 * FUNCTION: WDA_KeepAliveReqCallback
9847 * Free memory.
9848 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
9849 */
9850void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
9851{
9852 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9853
9854 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9855 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9856
9857 if(NULL == pWdaParams)
9858 {
9859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9860 "%s: pWdaParams received NULL", __func__);
9861 VOS_ASSERT(0);
9862 return;
9863 }
9864
9865 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9866 {
9867 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9868 vos_mem_free(pWdaParams->wdaMsgParam);
9869 vos_mem_free(pWdaParams);
9870 }
9871
9872 return;
9873}
9874/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9875 * FUNCTION: WDA_ProcessKeepAliveReq
9876 * Request to WDI to send Keep Alive packets to minimize unnecessary host
9877 * wakeup due to broadcast traffic (sta mode).
9878 */
9879VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
9880 tSirKeepAliveReq *pKeepAliveParams)
9881{
9882 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9883 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9884 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
9885 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
9886 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9887 tWDA_ReqParams *pWdaParams;
9888
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9890 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9891 if(NULL == wdiKeepAliveInfo)
9892 {
9893 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9894 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9895 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9896 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9897 return VOS_STATUS_E_NOMEM;
9898 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9899
9900 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9901 if(NULL == pWdaParams)
9902 {
9903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9904 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9905 VOS_ASSERT(0);
9906 vos_mem_free(wdiKeepAliveInfo);
9907 vos_mem_free(pKeepAliveParams);
9908 return VOS_STATUS_E_NOMEM;
9909 }
9910
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9911 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
9912 pKeepAliveParams->packetType;
9913 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
9914 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9915
9916 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
9917 pKeepAliveParams->bssId,
9918 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9919
9920 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
9921 {
9922 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9923 pKeepAliveParams->hostIpv4Addr,
9924 SIR_IPV4_ADDR_LEN);
9925 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9926 pKeepAliveParams->destIpv4Addr,
9927 SIR_IPV4_ADDR_LEN);
9928 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9929 pKeepAliveParams->destMacAddr,
9930 SIR_MAC_ADDR_LEN);
9931 }
9932 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
9933 {
9934 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9935 SIR_IPV4_ADDR_LEN,
9936 0);
9937 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9938 SIR_IPV4_ADDR_LEN,
9939 0);
9940 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9941 SIR_MAC_ADDR_LEN,
9942 0);
9943 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9944 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
9945 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9946
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9947 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9948 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9949 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9950 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
9951 pWdaParams->pWdaContext = pWDA;
9952
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
9954 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
9955 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
9956 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
9957 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
9958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
9959 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
9960 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
9961 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
9962 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
9963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9964 "WDA DMAC : %d:%d:%d:%d:%d:%d",
9965 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
9966 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
9967 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
9968 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
9969 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
9970 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
9971 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9972 "TimePeriod %d PacketType %d",
9973 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
9974 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9975 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9976 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9977
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9978 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9979 {
9980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9981 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9982 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9983 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9984 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9985 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9986 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9987 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9988
9989}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9990/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9991 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9992 *
9993 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9994void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9995 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
9996 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9997{
9998 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10000 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10001 if(NULL == pWdaParams)
10002 {
10003 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10004 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10005 VOS_ASSERT(0) ;
10006 return ;
10007 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10008 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10009 vos_mem_free(pWdaParams->wdaMsgParam);
10010 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10011 return ;
10012}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10013/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10014 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
10015 * Free memory.
10016 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
10017 */
10018void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
10019{
10020 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10021
10022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10023 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10024
10025 if(NULL == pWdaParams)
10026 {
10027 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10028 "%s: pWdaParams received NULL", __func__);
10029 VOS_ASSERT(0);
10030 return;
10031 }
10032
10033 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10034 {
10035 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10036 vos_mem_free(pWdaParams->wdaMsgParam);
10037 vos_mem_free(pWdaParams);
10038 }
10039
10040 return;
10041}
10042
10043/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10044 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
10045 * Request to WDI to add WOWL Bcast pattern
10046 */
10047VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
10048 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
10049{
10050 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10051 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10052 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
10053 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
10054 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
10055 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10056 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10057 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10058 if(NULL == wdiWowlAddBcPtrnInfo)
10059 {
10060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10061 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10062 VOS_ASSERT(0);
10063 return VOS_STATUS_E_NOMEM;
10064 }
10065 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10066 if(NULL == pWdaParams)
10067 {
10068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10069 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10070 VOS_ASSERT(0);
10071 vos_mem_free(wdiWowlAddBcPtrnInfo);
10072 return VOS_STATUS_E_NOMEM;
10073 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10074 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
10075 pWowlAddBcPtrnParams->ucPatternId;
10076 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
10077 pWowlAddBcPtrnParams->ucPatternByteOffset;
10078 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
10079 pWowlAddBcPtrnParams->ucPatternMaskSize;
10080 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
10081 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10082 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
10083 {
10084 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10085 pWowlAddBcPtrnParams->ucPattern,
10086 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
10087 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10088 pWowlAddBcPtrnParams->ucPatternMask,
10089 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
10090 }
10091 else
10092 {
10093 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
10094 pWowlAddBcPtrnParams->ucPattern,
10095 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10096 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
10097 pWowlAddBcPtrnParams->ucPatternMask,
10098 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10099
10100 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
10101 pWowlAddBcPtrnParams->ucPatternExt,
10102 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10103 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
10104 pWowlAddBcPtrnParams->ucPatternMaskExt,
10105 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
10106 }
10107
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10108 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
10109 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
10110
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10111 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
10112 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10113 /* Store param pointer as passed in by caller */
10114 /* store Params pass it to WDI */
10115 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
10116 pWdaParams->pWdaContext = pWDA;
10117 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10118 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10119 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10120 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10121 {
10122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10123 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10124 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10125 vos_mem_free(pWdaParams->wdaMsgParam) ;
10126 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10127 vos_mem_free(pWdaParams) ;
10128 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10129 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10130
10131}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10132/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10133 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10134 *
10135 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10136void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10137 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
10138 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10139{
10140 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10142 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10143 if(NULL == pWdaParams)
10144 {
10145 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10146 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10147 VOS_ASSERT(0) ;
10148 return ;
10149 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10150 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10151 vos_mem_free(pWdaParams->wdaMsgParam);
10152 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10153 return ;
10154}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10155/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10156 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
10157 * Free memory.
10158 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
10159 */
10160void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
10161{
10162 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10163
10164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10165 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10166
10167 if(NULL == pWdaParams)
10168 {
10169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10170 "%s: pWdaParams received NULL", __func__);
10171 VOS_ASSERT(0);
10172 return;
10173 }
10174
10175 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10176 {
10177 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10178 vos_mem_free(pWdaParams->wdaMsgParam);
10179 vos_mem_free(pWdaParams);
10180 }
10181
10182 return;
10183}
10184/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10185 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
10186 * Request to WDI to delete WOWL Bcast pattern
10187 */
10188VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
10189 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
10190{
10191 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10192 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10193 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
10194 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
10195 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
10196 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10198 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10199 if(NULL == wdiWowlDelBcPtrnInfo)
10200 {
10201 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10202 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10203 VOS_ASSERT(0);
10204 return VOS_STATUS_E_NOMEM;
10205 }
10206 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10207 if(NULL == pWdaParams)
10208 {
10209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10210 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10211 VOS_ASSERT(0);
10212 vos_mem_free(wdiWowlDelBcPtrnInfo);
10213 return VOS_STATUS_E_NOMEM;
10214 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10215 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
10216 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10217
10218 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
10219 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
10220
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10221 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
10222 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10223 /* Store param pointer as passed in by caller */
10224 /* store Params pass it to WDI */
10225 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
10226 pWdaParams->pWdaContext = pWDA;
10227 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10228 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10229 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10230 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10231 {
10232 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10233 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10234 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10235 vos_mem_free(pWdaParams->wdaMsgParam) ;
10236 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10237 vos_mem_free(pWdaParams) ;
10238 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10239 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10240
10241}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10242/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10243 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10244 *
10245 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10246void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10247{
10248 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10249 tWDA_CbContext *pWDA;
10250 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10252 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10253 if(NULL == pWdaParams)
10254 {
10255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10256 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10257 VOS_ASSERT(0) ;
10258 return ;
10259 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10260 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10261 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
10262
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10263 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
10264
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10265 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10266 vos_mem_free(pWdaParams) ;
10267
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10268 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10269 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10270 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10271 return ;
10272}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10273/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10274 * FUNCTION: WDA_WowlEnterReqCallback
10275 * Free memory and send WOWL Enter RSP back to PE.
10276 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
10277 */
10278void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
10279{
10280 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10281 tWDA_CbContext *pWDA;
10282 tSirHalWowlEnterParams *pWowlEnterParams;
10283
10284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10285 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10286
10287 if(NULL == pWdaParams)
10288 {
10289 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10290 "%s: pWdaParams received NULL", __func__);
10291 VOS_ASSERT(0);
10292 return;
10293 }
10294
10295 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10296 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
10297 pWowlEnterParams->status = wdiStatus;
10298
10299 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10300 {
10301 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10302 vos_mem_free(pWdaParams);
10303 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
10304 }
10305
10306 return;
10307}
10308/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10309 * FUNCTION: WDA_ProcessWowlEnterReq
10310 * Request to WDI to enter WOWL
10311 */
10312VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
10313 tSirHalWowlEnterParams *pWowlEnterParams)
10314{
10315 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10316 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10317 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
10318 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
10319 sizeof(WDI_WowlEnterReqParamsType)) ;
10320 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10321 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10322 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10323 if(NULL == wdiWowlEnterInfo)
10324 {
10325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10326 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10327 VOS_ASSERT(0);
10328 return VOS_STATUS_E_NOMEM;
10329 }
10330 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10331 if(NULL == pWdaParams)
10332 {
10333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10334 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10335 VOS_ASSERT(0);
10336 vos_mem_free(wdiWowlEnterInfo);
10337 return VOS_STATUS_E_NOMEM;
10338 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]10339
10340 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
10341
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10342 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
10343 pWowlEnterParams->magicPtrn,
10344 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10345 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
10346 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10347 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
10348 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10349 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
10350 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10351 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
10352 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10353 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
10354 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10355 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
10356 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10357 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
10358 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10359 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
10360 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10361#ifdef WLAN_WAKEUP_EVENTS
10362 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
10363 pWowlEnterParams->ucWoWEAPIDRequestEnable;
10364
10365 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
10366 pWowlEnterParams->ucWoWEAPOL4WayEnable;
10367
10368 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
10369 pWowlEnterParams->ucWowNetScanOffloadMatch;
10370
10371 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
10372 pWowlEnterParams->ucWowGTKRekeyError;
10373
10374 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
10375 pWowlEnterParams->ucWoWBSSConnLoss;
10376#endif // WLAN_WAKEUP_EVENTS
10377
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10378 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
10379 pWowlEnterParams->bssIdx;
10380
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10381 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
10382 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10383 /* Store param pointer as passed in by caller */
10384 /* store Params pass it to WDI */
10385 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
10386 pWdaParams->pWdaContext = pWDA;
10387 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10388 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10389 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10390 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10391 {
10392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10393 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10394 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10395 vos_mem_free(pWdaParams->wdaMsgParam) ;
10396 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10397 vos_mem_free(pWdaParams) ;
10398 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10399 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10400
10401}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10402/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10403 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10404 *
10405 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10406void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10407{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10408 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10409 tWDA_CbContext *pWDA;
10410 tSirHalWowlExitParams *pWowlExitParams;
10411 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10412 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10413 if(NULL == pWdaParams)
10414 {
10415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10416 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10417 VOS_ASSERT(0) ;
10418 return ;
10419 }
10420 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10421 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
10422
10423 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10424 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10425
10426 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10427 vos_mem_free(pWdaParams) ;
10428
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10430 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10431 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10432 return ;
10433}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10434/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10435 * FUNCTION: WDA_WowlExitReqCallback
10436 * Free memory and send WOWL Exit RSP back to PE.
10437 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
10438 */
10439void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
10440{
10441 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10442 tWDA_CbContext *pWDA;
10443 tSirHalWowlExitParams *pWowlExitParams;
10444
10445 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10446 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10447
10448 if(NULL == pWdaParams)
10449 {
10450 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10451 "%s: pWdaParams received NULL", __func__);
10452 VOS_ASSERT(0);
10453 return;
10454 }
10455
10456 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10457 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
10458 pWowlExitParams->status = wdiStatus;
10459
10460 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10461 {
10462 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10463 vos_mem_free(pWdaParams);
10464 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
10465 }
10466
10467 return;
10468}
10469/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10470 * FUNCTION: WDA_ProcessWowlExitReq
10471 * Request to WDI to add WOWL Bcast pattern
10472 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10473VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
10474 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10475{
10476 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10477 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10478 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
10479 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
10480 sizeof(WDI_WowlExitReqParamsType)) ;
10481 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10482 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10483 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10484 if(NULL == wdiWowlExitInfo)
10485 {
10486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10487 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10488 VOS_ASSERT(0);
10489 return VOS_STATUS_E_NOMEM;
10490 }
10491 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10492 if(NULL == pWdaParams)
10493 {
10494 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10495 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10496 VOS_ASSERT(0);
10497 vos_mem_free(wdiWowlExitInfo);
10498 return VOS_STATUS_E_NOMEM;
10499 }
10500
10501 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
10502 pWowlExitParams->bssIdx;
10503
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10504 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
10505 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10506
10507 /* Store param pointer as passed in by caller */
10508 /* store Params pass it to WDI */
10509 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
10510 pWdaParams->pWdaContext = pWDA;
10511 pWdaParams->wdaMsgParam = pWowlExitParams;
10512
10513 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10514 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10515
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10516 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10517 {
10518 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10519 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10520 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10521 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10522 vos_mem_free(pWdaParams->wdaMsgParam);
10523 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10524 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10525 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10526}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10527/*
10528 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
10529 * Request to WDI to determine whether a given station is capable of
10530 * using HW-based frame translation
10531 */
10532v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
10533 tANI_U8 staIdx)
10534{
10535 return WDI_IsHwFrameTxTranslationCapable(staIdx);
10536}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10537
10538/*
10539 * FUNCTION: WDA_IsSelfSTA
10540 * Request to WDI to determine whether a given STAID is self station
10541 * index.
10542 */
10543v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
10544{
10545
10546 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10547
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]10548 if (NULL != pWDA)
10549 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
10550 else
10551 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10552}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10553/*
10554 * FUNCTION: WDA_NvDownloadReqCallback
10555 * send NV Download RSP back to PE
10556 */
10557void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
10558 void* pUserData)
10559{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10560
10561 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
10562 tWDA_CbContext *pWDA;
10563
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10565 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10566
10567 if(NULL == pWdaParams)
10568 {
10569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10570 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10571 VOS_ASSERT(0) ;
10572 return ;
10573 }
10574
10575 pWDA = pWdaParams->pWdaContext;
10576
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10577 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10578 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10579 vos_mem_free(pWdaParams);
10580
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10581 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10582 return ;
10583}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10584/*
10585 * FUNCTION: WDA_ProcessNvDownloadReq
10586 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
10587 */
10588VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
10589{
10590 /* Initialize the local Variables*/
10591 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10592 v_VOID_t *pNvBuffer=NULL;
10593 v_SIZE_t bufferSize = 0;
10594 WDI_Status status = WDI_STATUS_E_FAILURE;
10595 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10596 tWDA_ReqParams *pWdaParams ;
10597
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10599 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10600 if(NULL == pWDA)
10601 {
10602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10603 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10604 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10605 return VOS_STATUS_E_FAILURE;
10606 }
10607
10608 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]10609 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
10610
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10611 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
10612 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10613 if(NULL == wdiNvDownloadReqParam)
10614 {
10615 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10616 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10617 VOS_ASSERT(0);
10618 return VOS_STATUS_E_NOMEM;
10619 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10620 /* Copy Params to wdiNvDownloadReqParam*/
10621 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
10622 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10623
10624 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10625 if(NULL == pWdaParams)
10626 {
10627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10628 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10629 VOS_ASSERT(0);
10630 vos_mem_free(wdiNvDownloadReqParam);
10631 return VOS_STATUS_E_NOMEM;
10632 }
10633
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10634 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10635 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
10636 pWdaParams->wdaMsgParam = NULL;
10637 pWdaParams->pWdaContext = pWDA;
10638
10639
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10640 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10641
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10642 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10643 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
10644
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10645 if(IS_WDI_STATUS_FAILURE(status))
10646 {
10647 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10648 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10649 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10650 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10651 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10652 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10653}
10654/*
10655 * FUNCTION: WDA_FlushAcReqCallback
10656 * send Flush AC RSP back to TL
10657 */
10658void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
10659{
10660 vos_msg_t wdaMsg = {0} ;
10661 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10662 tFlushACReq *pFlushACReqParams;
10663 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10665 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10666 if(NULL == pWdaParams)
10667 {
10668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10669 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10670 VOS_ASSERT(0) ;
10671 return ;
10672 }
10673
10674 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
10675 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
10676 if(NULL == pFlushACRspParams)
10677 {
10678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10679 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10680 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]10681 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10682 return ;
10683 }
10684 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
10685 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
10686 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
10687 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
10688 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10689 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10690 vos_mem_free(pWdaParams->wdaMsgParam) ;
10691 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10692 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10693 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
10694 wdaMsg.bodyptr = (void *)pFlushACRspParams;
10695 // POST message to TL
10696 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
10697
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10698 return ;
10699}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10700/*
10701 * FUNCTION: WDA_ProcessFlushAcReq
10702 * Request to WDI to Update the DELBA REQ params.
10703 */
10704VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
10705 tFlushACReq *pFlushAcReqParams)
10706{
10707 WDI_Status status = WDI_STATUS_SUCCESS ;
10708 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
10709 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
10710 sizeof(WDI_FlushAcReqParamsType)) ;
10711 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10712 if(NULL == wdiFlushAcReqParam)
10713 {
10714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10715 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10716 VOS_ASSERT(0);
10717 return VOS_STATUS_E_NOMEM;
10718 }
10719 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10720 if(NULL == pWdaParams)
10721 {
10722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10723 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10724 VOS_ASSERT(0);
10725 vos_mem_free(wdiFlushAcReqParam);
10726 return VOS_STATUS_E_NOMEM;
10727 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10729 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10730 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
10731 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
10732 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
10733 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10734 /* Store Flush AC pointer, as this will be used for response */
10735 /* store Params pass it to WDI */
10736 pWdaParams->pWdaContext = pWDA;
10737 pWdaParams->wdaMsgParam = pFlushAcReqParams;
10738 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10739 status = WDI_FlushAcReq(wdiFlushAcReqParam,
10740 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10741 if(IS_WDI_STATUS_FAILURE(status))
10742 {
10743 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10744 "Failure in Flush AC REQ Params WDI API, free all the memory " );
10745 vos_mem_free(pWdaParams->wdaMsgParam) ;
10746 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10747 vos_mem_free(pWdaParams) ;
10748 //TODO: respond to TL with failure
10749 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10750 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10751}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10752/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10753 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10754 *
10755 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10756void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10757{
10758 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10759 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10760 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10761
10762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10763 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10764 if(NULL == pWdaParams)
10765 {
10766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10767 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10768 VOS_ASSERT(0) ;
10769 return ;
10770 }
10771 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10772 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10773 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10774 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10775 {
10776 pWDA->wdaAmpSessionOn = VOS_FALSE;
10777 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10778 vos_mem_free(pWdaParams->wdaMsgParam) ;
10779 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10780 vos_mem_free(pWdaParams) ;
10781 /*
10782 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
10783 * param here
10784 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10785 return ;
10786}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10787/*
10788 * FUNCTION: WDA_BtAmpEventReqCallback
10789 * Free memory.
10790 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
10791 */
10792void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
10793{
10794 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10795 tWDA_CbContext *pWDA;
10796 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10797
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10799 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10800
10801 if(NULL == pWdaParams)
10802 {
10803 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10804 "%s: pWdaParams received NULL", __func__);
10805 VOS_ASSERT(0);
10806 return;
10807 }
10808
10809 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10810 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10811
10812 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10813 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10814 {
10815 pWDA->wdaAmpSessionOn = VOS_FALSE;
10816 }
10817
10818 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10819 {
10820 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10821 vos_mem_free(pWdaParams->wdaMsgParam);
10822 vos_mem_free(pWdaParams);
10823 }
10824
10825 return;
10826}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10827/*
10828 * FUNCTION: WDA_ProcessBtAmpEventReq
10829 * Request to WDI to Update with BT AMP events.
10830 */
10831VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
10832 tSmeBtAmpEvent *pBtAmpEventParams)
10833{
10834 WDI_Status status = WDI_STATUS_SUCCESS ;
10835 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
10836 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
10837 sizeof(WDI_BtAmpEventParamsType)) ;
10838 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10840 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10841 if(NULL == wdiBtAmpEventParam)
10842 {
10843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10844 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10845 VOS_ASSERT(0);
10846 return VOS_STATUS_E_NOMEM;
10847 }
10848 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10849 if(NULL == pWdaParams)
10850 {
10851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10852 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10853 VOS_ASSERT(0);
10854 vos_mem_free(wdiBtAmpEventParam);
10855 return VOS_STATUS_E_NOMEM;
10856 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10857 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
10858 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10859 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
10860 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10861 /* Store BT AMP event pointer, as this will be used for response */
10862 /* store Params pass it to WDI */
10863 pWdaParams->pWdaContext = pWDA;
10864 pWdaParams->wdaMsgParam = pBtAmpEventParams;
10865 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10866 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10867 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10868 if(IS_WDI_STATUS_FAILURE(status))
10869 {
10870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10871 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
10872 vos_mem_free(pWdaParams->wdaMsgParam) ;
10873 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10874 vos_mem_free(pWdaParams) ;
10875 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10876 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10877 {
10878 pWDA->wdaAmpSessionOn = VOS_TRUE;
10879 }
10880 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10881}
10882
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10883/*
10884 * FUNCTION: WDA_FTMCommandReqCallback
10885 * Handle FTM CMD response came from HAL
10886 * Route responce to HDD FTM
10887 */
10888void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
10889 void *usrData)
10890{
10891 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10892 if((NULL == pWDA) || (NULL == ftmCmdRspData))
10893 {
10894 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]10895 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10896 return;
10897 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10898 /* Release Current FTM Command Request */
10899 vos_mem_free(pWDA->wdaFTMCmdReq);
10900 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10901 /* Post FTM Responce to HDD FTM */
10902 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10903 return;
10904}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10905/*
10906 * FUNCTION: WDA_ProcessFTMCommand
10907 * Send FTM command to WDI
10908 */
10909VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
10910 tPttMsgbuffer *pPTTFtmCmd)
10911{
10912 WDI_Status status = WDI_STATUS_SUCCESS;
10913 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10914 ftmCMDReq = (WDI_FTMCommandReqType *)
10915 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
10916 if(NULL == ftmCMDReq)
10917 {
10918 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10919 "WDA FTM Command buffer alloc fail");
10920 return VOS_STATUS_E_NOMEM;
10921 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10922 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
10923 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10924 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10925 /* Send command to WDI */
10926 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10927 return status;
10928}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10929#ifdef FEATURE_OEM_DATA_SUPPORT
10930/*
10931 * FUNCTION: WDA_StartOemDataReqCallback
10932 *
10933 */
10934void WDA_StartOemDataReqCallback(
10935 WDI_oemDataRspParamsType *wdiOemDataRspParams,
10936 void* pUserData)
10937{
10938 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10939 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10940 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10941 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10942
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10944 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10945
10946 if(NULL == pWdaParams)
10947 {
10948 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10949 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10950 VOS_ASSERT(0) ;
10951 return ;
10952 }
10953 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10954
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10955 if(NULL == pWDA)
10956 {
10957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10958 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10959 VOS_ASSERT(0);
10960 return ;
10961 }
10962
10963 /*
10964 * Allocate memory for response params sent to PE
10965 */
10966 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
10967
10968 // Check if memory is allocated for OemdataMeasRsp Params.
10969 if(NULL == pOemDataRspParams)
10970 {
10971 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10972 "OEM DATA WDA callback alloc fail");
10973 VOS_ASSERT(0) ;
10974 return;
10975 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10976
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10977 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10978 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10979 vos_mem_free(pWdaParams->wdaMsgParam);
10980 vos_mem_free(pWdaParams) ;
10981
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10982 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]10983 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10984 * Also, here success always means that we have atleast one BSSID.
10985 */
10986 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
10987
10988 //enable Tx
10989 status = WDA_ResumeDataTx(pWDA);
10990 if(status != VOS_STATUS_SUCCESS)
10991 {
10992 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
10993 }
10994 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
10995 return ;
10996}
10997/*
10998 * FUNCTION: WDA_ProcessStartOemDataReq
10999 * Send Start Oem Data Req to WDI
11000 */
11001VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
11002 tStartOemDataReq *pOemDataReqParams)
11003{
11004 WDI_Status status = WDI_STATUS_SUCCESS;
11005 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11006 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11007
11008 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
11009
11010 if(NULL == wdiOemDataReqParams)
11011 {
11012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11013 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11014 VOS_ASSERT(0);
11015 return VOS_STATUS_E_NOMEM;
11016 }
11017
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11018 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
11019 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
11020 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
11021 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11022
11023 wdiOemDataReqParams->wdiReqStatusCB = NULL;
11024
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11025 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11026 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11027 {
11028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11029 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11030 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11031 vos_mem_free(pOemDataReqParams);
11032 VOS_ASSERT(0);
11033 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11034 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11035
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]11036 pWdaParams->pWdaContext = (void*)pWDA;
11037 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
11038 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11039
11040 status = WDI_StartOemDataReq(wdiOemDataReqParams,
11041 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11042
11043 if(IS_WDI_STATUS_FAILURE(status))
11044 {
11045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11046 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11047 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11048 vos_mem_free(pWdaParams->wdaMsgParam);
11049 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11050 }
11051 return CONVERT_WDI2VOS_STATUS(status) ;
11052}
11053#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11054/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11055 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11056 *
11057 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11058void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11059{
11060 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11061 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11062 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11063 if(NULL == pWdaParams)
11064 {
11065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11066 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11067 VOS_ASSERT(0) ;
11068 return ;
11069 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11070
11071 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11072 vos_mem_free(pWdaParams->wdaMsgParam);
11073 vos_mem_free(pWdaParams);
11074
11075 return ;
11076}
11077/*
11078 * FUNCTION: WDA_SetTxPerTrackingReqCallback
11079 * Free memory.
11080 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
11081 */
11082void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
11083{
11084 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11085
11086 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11087 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11088
11089 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11090 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11092 "%s: pWdaParams received NULL", __func__);
11093 VOS_ASSERT(0);
11094 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11095 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11096
11097 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11098 {
11099 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11100 vos_mem_free(pWdaParams->wdaMsgParam);
11101 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11102 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11103
11104 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11105}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11106#ifdef WLAN_FEATURE_GTK_OFFLOAD
11107/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11108 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11109 *
11110 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11111void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11112 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11113{
11114 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11115
11116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11117 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11118 if(NULL == pWdaParams)
11119 {
11120 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11121 "%s: pWdaParams received NULL", __func__);
11122 VOS_ASSERT(0);
11123 return;
11124 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11125
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11126 vos_mem_free(pWdaParams->wdaMsgParam) ;
11127 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11128 vos_mem_free(pWdaParams) ;
11129
11130 //print a msg, nothing else to do
11131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11132 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11133
11134 return ;
11135}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11136/*
11137 * FUNCTION: WDA_GTKOffloadReqCallback
11138 * Free memory.
11139 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
11140 */
11141void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
11142{
11143 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11144
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11145 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11146 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11147
11148 if(NULL == pWdaParams)
11149 {
11150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11151 "%s: pWdaParams received NULL", __func__);
11152 VOS_ASSERT(0);
11153 return;
11154 }
11155
11156 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11157 {
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame^]11158 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
11159 sizeof(WDI_GtkOffloadReqMsg));
11160 vos_mem_zero(pWdaParams->wdaMsgParam,
11161 sizeof(tSirGtkOffloadParams));
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11162 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11163 vos_mem_free(pWdaParams->wdaMsgParam);
11164 vos_mem_free(pWdaParams);
11165 }
11166
11167 return;
11168}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11169/*
11170 * FUNCTION: WDA_ProcessGTKOffloadReq
11171 * Request to WDI to set the filter to minimize unnecessary host wakeup due
11172 * to broadcast traffic (sta mode).
11173 */
11174VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
11175 tpSirGtkOffloadParams pGtkOffloadParams)
11176{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11177 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11178 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
11179 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
11180 sizeof(WDI_GtkOffloadReqMsg)) ;
11181 tWDA_ReqParams *pWdaParams ;
11182
11183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11184 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11185
11186 if(NULL == wdiGtkOffloadReqMsg)
11187 {
11188 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11189 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11190 VOS_ASSERT(0);
11191 return VOS_STATUS_E_NOMEM;
11192 }
11193
11194 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11195 if(NULL == pWdaParams)
11196 {
11197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11198 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11199 VOS_ASSERT(0);
11200 vos_mem_free(wdiGtkOffloadReqMsg);
11201 return VOS_STATUS_E_NOMEM;
11202 }
11203
11204 //
11205 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
11206 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11207
11208 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11209 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11210
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11211 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
11212 // Copy KCK
11213 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
11214 // Copy KEK
11215 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
11216 // Copy KeyReplayCounter
11217 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
11218 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
11219
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11220 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
11221 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11222
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11223
11224 /* Store Params pass it to WDI */
11225 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
11226 pWdaParams->pWdaContext = pWDA;
11227 /* Store param pointer as passed in by caller */
11228 pWdaParams->wdaMsgParam = pGtkOffloadParams;
11229
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11230 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11231
11232 if(IS_WDI_STATUS_FAILURE(status))
11233 {
11234 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11235 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame^]11236 vos_mem_zero(wdiGtkOffloadReqMsg, sizeof(WDI_GtkOffloadReqMsg));
11237 vos_mem_zero(pGtkOffloadParams, sizeof(tSirGtkOffloadParams));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11238 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11239 vos_mem_free(pWdaParams->wdaMsgParam);
11240 vos_mem_free(pWdaParams);
11241 }
11242
11243 return CONVERT_WDI2VOS_STATUS(status) ;
11244}
11245
11246/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11247 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11248 *
11249 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11250void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11251 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11252{
11253 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11254 tWDA_CbContext *pWDA;
11255 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11256 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11257 vos_msg_t vosMsg;
11258
11259 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11260 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11261
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]11262 if(NULL == pWdaParams)
11263 {
11264 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11265 "%s: pWdaParams received NULL", __func__);
11266 VOS_ASSERT(0);
11267 return;
11268 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11269
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]11270 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
11271 if(NULL == pGtkOffloadGetInfoRsp)
11272 {
11273 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11274 "%s: vos_mem_malloc failed ", __func__);
11275 VOS_ASSERT(0);
11276 return;
11277 }
11278
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11279 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
11280 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
11281
11282 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
11283 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
11284
11285 /* Message Header */
11286 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]11287 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11288
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11289 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
11290 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
11291 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
11292 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
11293 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11294
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11295 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
11296 pwdiGtkOffloadGetInfoRsparams->bssId,
11297 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11298 /* VOS message wrapper */
11299 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11300 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
11301 vosMsg.bodyval = 0;
11302
11303 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
11304 {
11305 /* free the mem and return */
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame^]11306 vos_mem_zero(pGtkOffloadGetInfoRsp,
11307 sizeof(tSirGtkOffloadGetInfoRspParams));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11308 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
11309 }
11310
11311 vos_mem_free(pWdaParams->wdaMsgParam) ;
11312 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11313 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11314
11315 return;
11316}
11317/*
11318 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
11319 * Free memory and send RSP back to SME.
11320 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
11321 */
11322void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
11323{
11324 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11325 vos_msg_t vosMsg;
11326
11327 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11328 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11329
11330 if(NULL == pWdaParams)
11331 {
11332 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11333 "%s: pWdaParams received NULL", __func__);
11334 VOS_ASSERT(0);
11335 return;
11336 }
11337
11338 /* VOS message wrapper */
11339 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
11340 vosMsg.bodyptr = NULL;
11341 vosMsg.bodyval = 0;
11342
11343 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11344 {
11345 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11346 vos_mem_free(pWdaParams->wdaMsgParam);
11347 vos_mem_free(pWdaParams);
11348 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
11349 }
11350
11351 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11352}
11353#endif
11354
11355/*
11356 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
11357 * Request to WDI to set Tx Per Tracking configurations
11358 */
11359VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
11360{
11361 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11362 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11363 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
11364 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
11365 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
11366 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11367 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11368 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11369 if(NULL == pwdiSetTxPerTrackingReqParams)
11370 {
11371 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11372 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11373 vos_mem_free(pTxPerTrackingParams);
11374 VOS_ASSERT(0);
11375 return VOS_STATUS_E_NOMEM;
11376 }
11377 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11378 if(NULL == pWdaParams)
11379 {
11380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11381 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11382 vos_mem_free(pwdiSetTxPerTrackingReqParams);
11383 vos_mem_free(pTxPerTrackingParams);
11384 VOS_ASSERT(0);
11385 return VOS_STATUS_E_NOMEM;
11386 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11387 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
11388 pTxPerTrackingParams->ucTxPerTrackingEnable;
11389 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
11390 pTxPerTrackingParams->ucTxPerTrackingPeriod;
11391 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
11392 pTxPerTrackingParams->ucTxPerTrackingRatio;
11393 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
11394 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11395 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
11396 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11397 /* Store param pointer as passed in by caller */
11398 /* store Params pass it to WDI
11399 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
11400 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
11401 pWdaParams->pWdaContext = pWDA;
11402 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11403 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11404 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11405 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11406 {
11407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11408 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11409 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11410 vos_mem_free(pWdaParams->wdaMsgParam) ;
11411 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11412 vos_mem_free(pWdaParams) ;
11413 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11414 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11415
11416}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11417/*
11418 * FUNCTION: WDA_HALDumpCmdCallback
11419 * Send the VOS complete .
11420 */
11421void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
11422 void* pUserData)
11423{
11424 tANI_U8 *buffer = NULL;
11425 tWDA_CbContext *pWDA = NULL;
11426 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11427 if(NULL == pWdaParams)
11428 {
11429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11430 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11431 VOS_ASSERT(0) ;
11432 return ;
11433 }
11434
11435 pWDA = pWdaParams->pWdaContext;
11436 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11437 if(wdiRspParams->usBufferLen > 0)
11438 {
11439 /*Copy the Resp data to UMAC supplied buffer*/
11440 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
11441 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11442 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11443 vos_mem_free(pWdaParams);
11444
11445 /* Indicate VOSS about the start complete */
11446 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11447 return ;
11448}
11449
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11450/*
11451 * FUNCTION: WDA_ProcessHALDumpCmdReq
11452 * Send Dump command to WDI
11453 */
11454VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
11455 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
11456 tANI_U32 arg4, tANI_U8 *pBuffer)
11457{
11458 WDI_Status status = WDI_STATUS_SUCCESS;
11459 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
11460 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
11461 tWDA_ReqParams *pWdaParams ;
11462 pVosContextType pVosContext = NULL;
11463 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11464 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
11465 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]11466 if(pVosContext)
11467 {
11468 if (pVosContext->isLogpInProgress)
11469 {
11470 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
11471 "%s:LOGP in Progress. Ignore!!!", __func__);
11472 return VOS_STATUS_E_BUSY;
11473 }
11474 }
11475 else
11476 {
11477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11478 "%s: VOS Context Null", __func__);
11479 return VOS_STATUS_E_RESOURCES;
11480 }
11481
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11482 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11483 if(NULL == pWdaParams)
11484 {
11485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11486 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11487 return VOS_STATUS_E_NOMEM;
11488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11489 /* Allocate memory WDI request structure*/
11490 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
11491 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
11492 if(NULL == wdiHALDumpCmdReqParam)
11493 {
11494 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11495 "WDA HAL DUMP Command buffer alloc fail");
11496 vos_mem_free(pWdaParams);
11497 return WDI_STATUS_E_FAILURE;
11498 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11499 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11500 /* Extract the arguments */
11501 wdiHalDumpCmdInfo->command = cmd;
11502 wdiHalDumpCmdInfo->argument1 = arg1;
11503 wdiHalDumpCmdInfo->argument2 = arg2;
11504 wdiHalDumpCmdInfo->argument3 = arg3;
11505 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11506 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11507 pWdaParams->pWdaContext = pVosContext->pWDAContext;
11508
11509 /* Response message will be passed through the buffer */
11510 pWdaParams->wdaMsgParam = (void *)pBuffer;
11511
11512 /* store Params pass it to WDI */
11513 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11514 /* Send command to WDI */
11515 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback, pWdaParams);
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]11516 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent), WDA_DUMPCMD_WAIT_TIMEOUT );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11517 if ( vStatus != VOS_STATUS_SUCCESS )
11518 {
11519 if ( vStatus == VOS_STATUS_E_TIMEOUT )
11520 {
11521 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11522 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11523 }
11524 else
11525 {
11526 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11527 "%s: WDA_HALDUMP reporting other error",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11528 }
11529 VOS_ASSERT(0);
11530 }
11531 return status;
11532}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11533#ifdef WLAN_FEATURE_GTK_OFFLOAD
11534/*
11535 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
11536 * Request to WDI to get GTK Offload Information
11537 */
11538VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
11539 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
11540{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11541 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11542 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
11543 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
11544 tWDA_ReqParams *pWdaParams ;
11545
11546 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
11547 {
11548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11549 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11550 VOS_ASSERT(0);
11551 return VOS_STATUS_E_NOMEM;
11552 }
11553
11554 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11555 if(NULL == pWdaParams)
11556 {
11557 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11558 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11559 VOS_ASSERT(0);
11560 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
11561 return VOS_STATUS_E_NOMEM;
11562 }
11563
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11564 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
11565 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11566
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11567 /* Store Params pass it to WDI */
11568 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
11569 pWdaParams->pWdaContext = pWDA;
11570 /* Store param pointer as passed in by caller */
11571 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
11572
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11573 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11574 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11575
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11576 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11577
11578 if(IS_WDI_STATUS_FAILURE(status))
11579 {
11580 /* failure returned by WDI API */
11581 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11582 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
11583 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11584 vos_mem_free(pWdaParams) ;
11585 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
11586 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
11587 }
11588
11589 return CONVERT_WDI2VOS_STATUS(status) ;
11590}
11591#endif // WLAN_FEATURE_GTK_OFFLOAD
11592
11593/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11594 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
11595 *
11596 */
11597VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11598 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
11599{
11600 WDI_Status wdiStatus;
11601 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
11602
11603 addPeriodicTxPtrnParams =
11604 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
11605
11606 if (NULL == addPeriodicTxPtrnParams)
11607 {
11608 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11609 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
11610 __func__);
11611
11612 return VOS_STATUS_E_NOMEM;
11613 }
11614
11615 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
11616 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
11617
11618 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11619 addPeriodicTxPtrnParams->pUserData = pWDA;
11620
11621 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
11622
11623 if (WDI_STATUS_PENDING == wdiStatus)
11624 {
11625 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11626 "Pending received for %s:%d", __func__, __LINE__ );
11627 }
11628 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11629 {
11630 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11631 "Failure in %s:%d", __func__, __LINE__ );
11632 }
11633
11634 vos_mem_free(addPeriodicTxPtrnParams);
11635
11636 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11637}
11638
11639/*
11640 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
11641 *
11642 */
11643VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11644 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
11645{
11646 WDI_Status wdiStatus;
11647 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
11648
11649 delPeriodicTxPtrnParams =
11650 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
11651
11652 if (NULL == delPeriodicTxPtrnParams)
11653 {
11654 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11655 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
11656 __func__);
11657
11658 return VOS_STATUS_E_NOMEM;
11659 }
11660
11661 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
11662 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
11663
11664 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11665 delPeriodicTxPtrnParams->pUserData = pWDA;
11666
11667 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
11668
11669 if (WDI_STATUS_PENDING == wdiStatus)
11670 {
11671 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11672 "Pending received for %s:%d", __func__, __LINE__ );
11673 }
11674 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11675 {
11676 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11677 "Failure in %s:%d", __func__, __LINE__ );
11678 }
11679
11680 vos_mem_free(delPeriodicTxPtrnParams);
11681
11682 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11683}
11684
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11685#ifdef FEATURE_WLAN_BATCH_SCAN
11686/*
11687 * FUNCTION: WDA_ProcessStopBatchScanInd
11688 *
11689 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
11690 *
11691 * PARAM:
11692 * pWDA: pointer to WDA context
11693 * pReq: pointer to stop batch scan request
11694 */
11695VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
11696 tSirStopBatchScanInd *pReq)
11697{
11698 WDI_Status wdiStatus;
11699 WDI_StopBatchScanIndType wdiReq;
11700
11701 wdiReq.param = pReq->param;
11702
11703 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
11704
11705 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11706 {
11707 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11708 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
11709 }
11710
11711 vos_mem_free(pReq);
11712
11713 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11714}
11715/*==========================================================================
11716 FUNCTION WDA_ProcessTriggerBatchScanResultInd
11717
11718 DESCRIPTION
11719 API to pull batch scan result from FW
11720
11721 PARAMETERS
11722 pWDA: Pointer to WDA context
11723 pGetBatchScanReq: Pointer to get batch scan result indication
11724
11725 RETURN VALUE
11726 NONE
11727
11728===========================================================================*/
11729VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
11730 tSirTriggerBatchScanResultInd *pReq)
11731{
11732 WDI_Status wdiStatus;
11733 WDI_TriggerBatchScanResultIndType wdiReq;
11734
11735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11736 "------> %s " ,__func__);
11737
11738 wdiReq.param = pReq->param;
11739
11740 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
11741
11742 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11743 {
11744 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11745 "Trigger batch scan result ind failed %s:%d",
11746 __func__, wdiStatus);
11747 }
11748
11749 vos_mem_free(pReq);
11750
11751 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11752}
11753
11754/*==========================================================================
11755 FUNCTION WDA_SetBatchScanRespCallback
11756
11757 DESCRIPTION
11758 API to process set batch scan response from FW
11759
11760 PARAMETERS
11761 pRsp: Pointer to set batch scan response
11762 pUserData: Pointer to user data
11763
11764 RETURN VALUE
11765 NONE
11766
11767===========================================================================*/
11768void WDA_SetBatchScanRespCallback
11769(
11770 WDI_SetBatchScanRspType *pRsp,
11771 void* pUserData
11772)
11773{
11774 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
11775 tpAniSirGlobal pMac;
11776 void *pCallbackContext;
11777 tWDA_CbContext *pWDA = NULL ;
11778 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11779
11780
11781 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11782 "<------ %s " ,__func__);
11783 if (NULL == pWdaParams)
11784 {
11785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11786 "%s: pWdaParams received NULL", __func__);
11787 VOS_ASSERT(0) ;
11788 return ;
11789 }
11790
11791 /*extract WDA context*/
11792 pWDA = pWdaParams->pWdaContext;
11793 if (NULL == pWDA)
11794 {
11795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11796 "%s:pWDA is NULL can't invole HDD callback",
11797 __func__);
11798 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11799 vos_mem_free(pWdaParams->wdaMsgParam);
11800 vos_mem_free(pWdaParams);
11801 VOS_ASSERT(0);
11802 return;
11803 }
11804
11805 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11806 vos_mem_free(pWdaParams->wdaMsgParam);
11807 vos_mem_free(pWdaParams);
11808
11809 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11810 if (NULL == pMac)
11811 {
11812 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11813 "%s:pMac is NULL", __func__);
11814 VOS_ASSERT(0);
11815 return;
11816 }
11817
11818 pHddSetBatchScanRsp =
11819 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
11820 if (NULL == pHddSetBatchScanRsp)
11821 {
11822 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11823 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
11824 VOS_ASSERT(0);
11825 return;
11826 }
11827
11828 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
11829
11830 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
11831 /*call hdd callback with set batch scan response data*/
11832 if(pMac->pmc.setBatchScanReqCallback)
11833 {
11834 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
11835 }
11836 else
11837 {
11838 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11839 "%s:HDD callback is null", __func__);
11840 VOS_ASSERT(0);
11841 }
11842
11843 vos_mem_free(pHddSetBatchScanRsp);
11844 return ;
11845}
11846
11847/*==========================================================================
11848 FUNCTION WDA_ProcessSetBatchScanReq
11849
11850 DESCRIPTION
11851 API to send set batch scan request to WDI
11852
11853 PARAMETERS
11854 pWDA: Pointer to WDA context
11855 pSetBatchScanReq: Pointer to set batch scan req
11856
11857 RETURN VALUE
11858 NONE
11859
11860===========================================================================*/
11861VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
11862 tSirSetBatchScanReq *pSetBatchScanReq)
11863{
11864 WDI_Status status;
11865 tWDA_ReqParams *pWdaParams ;
11866 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
11867
11868 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11869 "------> %s " ,__func__);
11870
11871 pWdiSetBatchScanReq =
11872 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
11873 if (NULL == pWdiSetBatchScanReq)
11874 {
11875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11876 "%s: VOS MEM Alloc Failure", __func__);
11877 vos_mem_free(pSetBatchScanReq);
11878 VOS_ASSERT(0);
11879 return VOS_STATUS_E_NOMEM;
11880 }
11881
11882 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
11883 if (NULL == pWdaParams)
11884 {
11885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11886 "%s: VOS MEM Alloc Failure", __func__);
11887 VOS_ASSERT(0);
11888 vos_mem_free(pSetBatchScanReq);
11889 vos_mem_free(pWdiSetBatchScanReq);
11890 return VOS_STATUS_E_NOMEM;
11891 }
11892
11893 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
11894 pWdiSetBatchScanReq->numberOfScansToBatch =
11895 pSetBatchScanReq->numberOfScansToBatch;
11896 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
11897 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
11898 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
11899
11900 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
11901 pWdaParams->pWdaContext = pWDA;
11902 pWdaParams->wdaMsgParam = pSetBatchScanReq;
11903
11904 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
11905 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
11906 if (IS_WDI_STATUS_FAILURE(status))
11907 {
11908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11909 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
11910 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11911 vos_mem_free(pWdaParams->wdaMsgParam);
11912 vos_mem_free(pWdaParams);
11913 }
11914 return CONVERT_WDI2VOS_STATUS(status);
11915}
11916
11917#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11918/*
11919 * FUNCTION: WDA_ProcessHT40OBSSScanInd
11920 *
11921 * DESCRIPTION: This function sends start/update OBSS scan
11922 * inidcation message to WDI
11923 *
11924 * PARAM:
11925 * pWDA: pointer to WDA context
11926 * pReq: pointer to start OBSS scan request
11927 */
11928VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
11929 tSirHT40OBSSScanInd *pReq)
11930{
11931 WDI_Status status;
11932 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
11933 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11934
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11936 "------> %s " ,__func__);
11937 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11938 wdiOBSSScanParams.pUserData = pWDA;
11939
11940 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
11941 pWdiOBSSScanInd->cmdType = pReq->cmdType;
11942 pWdiOBSSScanInd->scanType = pReq->scanType;
11943 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
11944 pReq->OBSSScanActiveDwellTime;
11945 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
11946 pReq->OBSSScanPassiveDwellTime;
11947 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
11948 pReq->BSSChannelWidthTriggerScanInterval;
11949 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
11950 pReq->BSSWidthChannelTransitionDelayFactor;
11951 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
11952 pReq->OBSSScanActiveTotalPerChannel;
11953 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
11954 pReq->OBSSScanPassiveTotalPerChannel;
11955 pWdiOBSSScanInd->OBSSScanActivityThreshold =
11956 pReq->OBSSScanActivityThreshold;
11957 pWdiOBSSScanInd->channelCount = pReq->channelCount;
11958 vos_mem_copy(pWdiOBSSScanInd->channels,
11959 pReq->channels,
11960 pReq->channelCount);
11961 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
11962 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
11963 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
11964 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
11965 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
11966
11967 vos_mem_copy(pWdiOBSSScanInd->ieField,
11968 pReq->ieField,
11969 pReq->ieFieldLen);
11970
11971 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
11972 if (WDI_STATUS_PENDING == status)
11973 {
11974 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11975 "Pending received for %s:%d ",__func__,__LINE__ );
11976 }
11977 else if (WDI_STATUS_SUCCESS_SYNC != status)
11978 {
11979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11980 "Failure in %s:%d ",__func__,__LINE__ );
11981 }
11982 return CONVERT_WDI2VOS_STATUS(status) ;
11983}
11984/*
11985 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
11986 *
11987 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
11988 *
11989 * PARAM:
11990 * pWDA: pointer to WDA context
11991 * pReq: pointer to stop batch scan request
11992 */
11993VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
11994 tANI_U8 *bssIdx)
11995{
11996 WDI_Status status;
11997
11998 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11999 "------> %s " ,__func__);
12000
12001 status = WDI_HT40OBSSStopScanInd(*bssIdx);
12002 if (WDI_STATUS_PENDING == status)
12003 {
12004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12005 "Pending received for %s:%d ",__func__,__LINE__ );
12006 }
12007 else if (WDI_STATUS_SUCCESS_SYNC != status)
12008 {
12009 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12010 "Failure in %s:%d ",__func__,__LINE__ );
12011 }
12012 return CONVERT_WDI2VOS_STATUS(status) ;
12013}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]12014/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]12015 * FUNCTION: WDA_ProcessRateUpdateInd
12016 *
12017 */
12018VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
12019 tSirRateUpdateInd *pRateUpdateParams)
12020{
12021 WDI_Status wdiStatus;
12022 WDI_RateUpdateIndParams rateUpdateParams;
12023
12024 vos_mem_copy(rateUpdateParams.bssid,
12025 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
12026
12027 rateUpdateParams.ucastDataRateTxFlag =
12028 pRateUpdateParams->ucastDataRateTxFlag;
12029 rateUpdateParams.reliableMcastDataRateTxFlag =
12030 pRateUpdateParams->reliableMcastDataRateTxFlag;
12031 rateUpdateParams.mcastDataRate24GHzTxFlag =
12032 pRateUpdateParams->mcastDataRate24GHzTxFlag;
12033 rateUpdateParams.mcastDataRate5GHzTxFlag =
12034 pRateUpdateParams->mcastDataRate5GHzTxFlag;
12035
12036 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
12037 rateUpdateParams.reliableMcastDataRate =
12038 pRateUpdateParams->reliableMcastDataRate;
12039 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
12040 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
12041
12042 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
12043 rateUpdateParams.pUserData = pWDA;
12044
12045 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
12046
12047 if (WDI_STATUS_PENDING == wdiStatus)
12048 {
12049 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12050 "Pending received for %s:%d", __func__, __LINE__ );
12051 }
12052 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
12053 {
12054 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12055 "Failure in %s:%d", __func__, __LINE__ );
12056 }
12057
12058 vos_mem_free(pRateUpdateParams);
12059
12060 return CONVERT_WDI2VOS_STATUS(wdiStatus);
12061}
12062
12063/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12064 * -------------------------------------------------------------------------
12065 * DATA interface with WDI for Mgmt Frames
12066 * -------------------------------------------------------------------------
12067 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12068/*
12069 * FUNCTION: WDA_TxComplete
12070 * Callback function for the WDA_TxPacket
12071 */
12072VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
12073 VOS_STATUS status )
12074{
12075
12076 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
12077 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12078 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12079
12080 if(NULL == wdaContext)
12081 {
12082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12083 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12084 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12085 VOS_ASSERT(0);
12086 return VOS_STATUS_E_FAILURE;
12087 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12088
12089 /*Check if frame was timed out or not*/
12090 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
12091 (v_PVOID_t)&uUserData);
12092
12093 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
12094 {
12095 /*Discard frame - no further processing is needed*/
12096 vos_pkt_return_packet(pData);
12097 return VOS_STATUS_SUCCESS;
12098 }
12099
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12100 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
12101 if( NULL!=wdaContext->pTxCbFunc)
12102 {
12103 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12104 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]12105 {
12106 wdaContext->pTxCbFunc(pMac, pData);
12107 }
12108 else
12109 {
12110 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12111 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12112 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12113 //Return from here since we reaching here because the packet already timeout
12114 return status;
12115 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12116 }
12117
12118 /*
12119 * Trigger the event to bring the HAL TL Tx complete function to come
12120 * out of wait
12121 * Let the coe above to complete the packet first. When this event is set,
12122 * the thread waiting for the event may run and set Vospacket_freed causing the original
12123 * packet not being freed.
12124 */
12125 status = vos_event_set(&wdaContext->txFrameEvent);
12126 if(!VOS_IS_STATUS_SUCCESS(status))
12127 {
12128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12129 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12130 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12131 return status;
12132}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12133/*
12134 * FUNCTION: WDA_TxPacket
12135 * Forward TX management frame to WDI
12136 */
12137VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
12138 void *pFrmBuf,
12139 tANI_U16 frmLen,
12140 eFrameType frmType,
12141 eFrameTxDir txDir,
12142 tANI_U8 tid,
12143 pWDATxRxCompFunc pCompFunc,
12144 void *pData,
12145 pWDAAckFnTxComp pAckTxComp,
Kanchanapally, Vidyullathaf9426e52013-12-24 17:28:54 +0530[diff] [blame]12146 tANI_U32 txFlag)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12147{
12148 VOS_STATUS status = VOS_STATUS_SUCCESS ;
12149 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
12150 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
12151 tANI_U8 eventIdx = 0;
12152 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
12153 tpAniSirGlobal pMac;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12154 if((NULL == pWDA)||(NULL == pFrmBuf))
12155 {
12156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12157 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12158 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12159 VOS_ASSERT(0);
12160 return VOS_STATUS_E_FAILURE;
12161 }
12162
12163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12164 "Tx Mgmt Frame Subtype: %d alloc(%p)", pFc->subType, pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12165 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
12166 if(NULL == pMac)
12167 {
12168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12169 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12170 VOS_ASSERT(0);
12171 return VOS_STATUS_E_FAILURE;
12172 }
12173
12174
12175
12176 /* store the call back function in WDA context */
12177 pWDA->pTxCbFunc = pCompFunc;
12178 /* store the call back for the function of ackTxComplete */
12179 if( pAckTxComp )
12180 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12181 if( NULL != pWDA->pAckTxCbFunc )
12182 {
12183 /* Already TxComp is active no need to active again */
12184 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12185 "There is already one request pending for tx complete");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12186 pWDA->pAckTxCbFunc( pMac, 0);
12187 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12188
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12189 if( VOS_STATUS_SUCCESS !=
12190 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12191 {
12192 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12193 "Tx Complete timeout Timer Stop Failed ");
12194 }
12195 else
12196 {
12197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]12198 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12199 }
12200 }
12201
12202 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
12203 pWDA->pAckTxCbFunc = pAckTxComp;
12204 if( VOS_STATUS_SUCCESS !=
12205 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
12206 {
12207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12208 "Tx Complete Timer Start Failed ");
12209 pWDA->pAckTxCbFunc = NULL;
12210 return eHAL_STATUS_FAILURE;
12211 }
12212 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12213 /* Reset the event to be not signalled */
12214 status = vos_event_reset(&pWDA->txFrameEvent);
12215 if(!VOS_IS_STATUS_SUCCESS(status))
12216 {
12217 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12218 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12219 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
12220 if( pAckTxComp )
12221 {
12222 pWDA->pAckTxCbFunc = NULL;
12223 if( VOS_STATUS_SUCCESS !=
12224 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12225 {
12226 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12227 "Tx Complete timeout Timer Stop Failed ");
12228 }
12229 }
12230 return VOS_STATUS_E_FAILURE;
12231 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12232
12233 /* If Peer Sta mask is set don't overwrite to self sta */
12234 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12235 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12236 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12237 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12238 else
12239 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12240 /* Get system role, use the self station if in unknown role or STA role */
12241 systemRole = wdaGetGlobalSystemRole(pMac);
12242 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
12243 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12244#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12245 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]12246#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]12247 ))
12248 {
12249 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
12250 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]12251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12252
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12253 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
12254 disassoc frame reaches the HW, HAL has already deleted the peer station */
12255 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12256 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]12257 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12258 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12259 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12260 /*Send Probe request frames on self sta idx*/
12261 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12262 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12263 /* Since we donot want probe responses to be retried, send probe responses
12264 through the NO_ACK queues */
12265 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
12266 {
12267 //probe response is sent out using self station and no retries options.
12268 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
12269 }
12270 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
12271 {
12272 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
12273 }
12274 }
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12275 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]12276
12277 /*Set frame tag to 0
12278 We will use the WDA user data in order to tag a frame as expired*/
12279 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12280 (v_PVOID_t)0);
12281
12282
12283 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
12284 frmLen, ucTypeSubType, tid,
12285 WDA_TxComplete, NULL, txFlag)) != VOS_STATUS_SUCCESS)
12286 {
12287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12288 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12289 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12290 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]12291 if( pAckTxComp )
12292 {
12293 pWDA->pAckTxCbFunc = NULL;
12294 if( VOS_STATUS_SUCCESS !=
12295 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12296 {
12297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12298 "Tx Complete timeout Timer Stop Failed ");
12299 }
12300 }
12301 return VOS_STATUS_E_FAILURE;
12302 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12303 /*
12304 * Wait for the event to be set by the TL, to get the response of TX
12305 * complete, this event should be set by the Callback function called by TL
12306 */
12307 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
12308 &eventIdx);
12309 if(!VOS_IS_STATUS_SUCCESS(status))
12310 {
12311 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12312 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12313 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12314 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
12315 after the packet gets completed(packet freed once)*/
12316
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12317 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Katya Nigam53677462014-08-04 11:37:28 +0530[diff] [blame]12318 WDA_TransportChannelDebug(pMac, 1, 0);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]12319
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12320 /*Tag Frame as timed out for later deletion*/
12321 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
12322 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
12323
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12324 /* check whether the packet was freed already,so need not free again when
12325 * TL calls the WDA_Txcomplete routine
12326 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]12327 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
12328 /*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]12329 {
12330 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]12331 } */
12332
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12333 if( pAckTxComp )
12334 {
12335 pWDA->pAckTxCbFunc = NULL;
12336 if( VOS_STATUS_SUCCESS !=
12337 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
12338 {
12339 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12340 "Tx Complete timeout Timer Stop Failed ");
12341 }
12342 }
12343 status = VOS_STATUS_E_FAILURE;
12344 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]12345#ifdef WLAN_DUMP_MGMTFRAMES
12346 if (VOS_IS_STATUS_SUCCESS(status))
12347 {
12348 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12349 "%s() TX packet : SubType %d", __func__,pFc->subType);
12350 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12351 pData, frmLen);
12352 }
12353#endif
12354
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]12355 if (VOS_IS_STATUS_SUCCESS(status))
12356 {
12357 if (pMac->fEnableDebugLog & 0x1)
12358 {
12359 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
12360 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
12361 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
12362 {
12363 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
12364 pFc->type, pFc->subType);
12365 }
12366 }
12367 }
12368
12369
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12370 return status;
12371}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12372/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12373 * FUNCTION: WDA_ProcessDHCPStartInd
12374 * Forward DHCP Start to WDI
12375 */
12376static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
12377 tAniDHCPInd *dhcpStartInd)
12378{
12379 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12380 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12381
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12382 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
12383 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12384 sizeof(tSirMacAddr));
12385
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12386 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12387
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12388 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12389 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12391 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12392 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12393 else if (WDI_STATUS_SUCCESS_SYNC != status)
12394 {
12395 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12396 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
12397 }
12398
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12399 vos_mem_free(dhcpStartInd);
12400 return CONVERT_WDI2VOS_STATUS(status) ;
12401}
12402
12403 /*
12404 * FUNCTION: WDA_ProcessDHCPStopInd
12405 * Forward DHCP Stop to WDI
12406 */
12407 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
12408 tAniDHCPInd *dhcpStopInd)
12409 {
12410 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12411 WDI_DHCPInd wdiDHCPInd;
12412
12413 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
12414 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
12415
12416 status = WDI_dhcpStopInd(&wdiDHCPInd);
12417
12418 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12419 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12421 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12422 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12423 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12424 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12426 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12427 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12428
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12429 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12430
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12431 return CONVERT_WDI2VOS_STATUS(status) ;
12432 }
12433
12434/*
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]12435 * FUNCTION: WDA_ProcessSetSpoofMacAddrReq
12436 *
12437 * DESCRIPTION: This function sends Spoof Mac Addr Req to WDI
12438 *
12439 * PARAM:
12440 * pWDA: pointer to WDA context
12441 * pReq: pointer to stop batch scan request
12442 */
12443VOS_STATUS WDA_ProcessSetSpoofMacAddrReq(tWDA_CbContext *pWDA,
12444 tpSpoofMacAddrReqParams pReq)
12445{
12446 WDI_Status wdiStatus;
12447 WDI_SpoofMacAddrInfoType *WDI_SpoofMacAddrInfoParams;
12448 tWDA_ReqParams *pWdaParams;
12449
12450 WDI_SpoofMacAddrInfoParams = (WDI_SpoofMacAddrInfoType *)vos_mem_malloc(
12451 sizeof(WDI_SpoofMacAddrInfoType));
12452 if(NULL == WDI_SpoofMacAddrInfoParams) {
12453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12454 "%s: VOS MEM Alloc Failure in Spoof Req", __func__);
12455 VOS_ASSERT(0);
12456 return VOS_STATUS_E_NOMEM;
12457 }
12458 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12459 if(NULL == pWdaParams) {
12460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12461 "%s: VOS MEM Alloc Failure", __func__);
12462 VOS_ASSERT(0);
12463 return VOS_STATUS_E_NOMEM;
12464 }
12465
12466 vos_mem_copy(WDI_SpoofMacAddrInfoParams->macAddr,
12467 pReq->macAddr, VOS_MAC_ADDRESS_LEN);
12468
12469 pWdaParams->pWdaContext = pWDA;
12470 /* Store Upper layer req pointer, as this will be used for response */
12471 pWdaParams->wdaMsgParam = (void *)pReq ;
12472 /* store Params pass it to WDI */
12473 pWdaParams->wdaWdiApiMsgParam = (void *)WDI_SpoofMacAddrInfoParams ;
12474
12475 wdiStatus = WDI_SetSpoofMacAddrReq(WDI_SpoofMacAddrInfoParams,
12476 (WDI_SetSpoofMacAddrRspCb) WDA_SpoofMacAddrRspCallback,
12477 pWdaParams );
12478
12479 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12480 {
12481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12482 "Failure in SetSpoofMacAddrReq Params WDI API, free all the memory " );
12483 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12484 vos_mem_free(pWdaParams->wdaMsgParam);
12485 vos_mem_free(pWdaParams);
12486 }
12487
12488 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
12489}
12490
12491/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12492 * FUNCTION: WDA_McProcessMsg
12493 * Trigger DAL-AL to start CFG download
12494 */
12495VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
12496{
12497 VOS_STATUS status = VOS_STATUS_SUCCESS;
12498 tWDA_CbContext *pWDA = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12499 if(NULL == pMsg)
12500 {
12501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12502 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12503 VOS_ASSERT(0);
12504 return VOS_STATUS_E_FAILURE;
12505 }
12506
12507 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12508 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12509
12510 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
12511 if(NULL == pWDA )
12512 {
12513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12514 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12515 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12516 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12517 return VOS_STATUS_E_FAILURE;
12518 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12519 /* Process all the WDA messages.. */
12520 switch( pMsg->type )
12521 {
12522 case WNI_CFG_DNLD_REQ:
12523 {
12524 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12525 /* call WDA complete event if config download success */
12526 if( VOS_IS_STATUS_SUCCESS(status) )
12527 {
12528 vos_WDAComplete_cback(pVosContext);
12529 }
12530 else
12531 {
12532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12533 "WDA Config Download failure" );
12534 }
12535 break ;
12536 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12537 /*
12538 * Init SCAN request from PE, convert it into DAL format
12539 * and send it to DAL
12540 */
12541 case WDA_INIT_SCAN_REQ:
12542 {
12543 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
12544 break ;
12545 }
12546 /* start SCAN request from PE */
12547 case WDA_START_SCAN_REQ:
12548 {
12549 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
12550 break ;
12551 }
12552 /* end SCAN request from PE */
12553 case WDA_END_SCAN_REQ:
12554 {
12555 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
12556 break ;
12557 }
12558 /* end SCAN request from PE */
12559 case WDA_FINISH_SCAN_REQ:
12560 {
12561 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
12562 break ;
12563 }
12564 /* join request from PE */
12565 case WDA_CHNL_SWITCH_REQ:
12566 {
12567 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
12568 {
12569 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
12570 }
12571 else
12572 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]12573 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
12574 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
12575 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
12576 {
12577 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12578 "call ProcessChannelSwitchReq_V1" );
12579 WDA_ProcessChannelSwitchReq_V1(pWDA,
12580 (tSwitchChannelParams*)pMsg->bodyptr) ;
12581 }
12582 else
12583 {
12584 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12585 "call ProcessChannelSwitchReq" );
12586 WDA_ProcessChannelSwitchReq(pWDA,
12587 (tSwitchChannelParams*)pMsg->bodyptr) ;
12588 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12589 }
12590 break ;
12591 }
12592 /* ADD BSS request from PE */
12593 case WDA_ADD_BSS_REQ:
12594 {
12595 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
12596 break ;
12597 }
12598 case WDA_ADD_STA_REQ:
12599 {
12600 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
12601 break ;
12602 }
12603 case WDA_DELETE_BSS_REQ:
12604 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12605 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
12606 break ;
12607 }
12608 case WDA_DELETE_STA_REQ:
12609 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12610 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
12611 break ;
12612 }
12613 case WDA_CONFIG_PARAM_UPDATE_REQ:
12614 {
12615 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
12616 break ;
12617 }
12618 case WDA_SET_BSSKEY_REQ:
12619 {
12620 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
12621 break ;
12622 }
12623 case WDA_SET_STAKEY_REQ:
12624 {
12625 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12626 break ;
12627 }
12628 case WDA_SET_STA_BCASTKEY_REQ:
12629 {
12630 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12631 break ;
12632 }
12633 case WDA_REMOVE_BSSKEY_REQ:
12634 {
12635 WDA_ProcessRemoveBssKeyReq(pWDA,
12636 (tRemoveBssKeyParams *)pMsg->bodyptr);
12637 break ;
12638 }
12639 case WDA_REMOVE_STAKEY_REQ:
12640 {
12641 WDA_ProcessRemoveStaKeyReq(pWDA,
12642 (tRemoveStaKeyParams *)pMsg->bodyptr);
12643 break ;
12644 }
12645 case WDA_REMOVE_STA_BCASTKEY_REQ:
12646 {
12647 /* TODO: currently UMAC is not sending this request, Add the code for
12648 handling this request when UMAC supports */
12649 break;
12650 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12651#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12652 case WDA_TSM_STATS_REQ:
12653 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]12654 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12655 break;
12656 }
12657#endif
12658 case WDA_UPDATE_EDCA_PROFILE_IND:
12659 {
12660 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
12661 break;
12662 }
12663 case WDA_ADD_TS_REQ:
12664 {
12665 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
12666 break;
12667 }
12668 case WDA_DEL_TS_REQ:
12669 {
12670 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
12671 break;
12672 }
12673 case WDA_ADDBA_REQ:
12674 {
12675 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
12676 break;
12677 }
12678 case WDA_DELBA_IND:
12679 {
12680 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
12681 break;
12682 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]12683 case WDA_UPDATE_CHAN_LIST_REQ:
12684 {
12685 WDA_ProcessUpdateChannelList(pWDA,
12686 (tSirUpdateChanList *)pMsg->bodyptr);
12687 break;
12688 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12689 case WDA_SET_LINK_STATE:
12690 {
12691 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
12692 break;
12693 }
12694 case WDA_GET_STATISTICS_REQ:
12695 {
12696 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
12697 break;
12698 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12699#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]12700 case WDA_GET_ROAM_RSSI_REQ:
12701 {
12702 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
12703 break;
12704 }
12705#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12706 case WDA_PWR_SAVE_CFG:
12707 {
12708 if(pWDA->wdaState == WDA_READY_STATE)
12709 {
12710 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
12711 }
12712 else
12713 {
12714 if(NULL != pMsg->bodyptr)
12715 {
12716 vos_mem_free(pMsg->bodyptr);
12717 }
12718 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12719 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
12720 }
12721 break;
12722 }
12723 case WDA_ENTER_IMPS_REQ:
12724 {
12725 if(pWDA->wdaState == WDA_READY_STATE)
12726 {
12727 WDA_ProcessEnterImpsReq(pWDA);
12728 }
12729 else
12730 {
12731 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12732 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12733 }
12734 break;
12735 }
12736 case WDA_EXIT_IMPS_REQ:
12737 {
12738 if(pWDA->wdaState == WDA_READY_STATE)
12739 {
12740 WDA_ProcessExitImpsReq(pWDA);
12741 }
12742 else
12743 {
12744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12745 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12746 }
12747 break;
12748 }
12749 case WDA_ENTER_BMPS_REQ:
12750 {
12751 if(pWDA->wdaState == WDA_READY_STATE)
12752 {
12753 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
12754 }
12755 else
12756 {
12757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12758 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12759 }
12760 break;
12761 }
12762 case WDA_EXIT_BMPS_REQ:
12763 {
12764 if(pWDA->wdaState == WDA_READY_STATE)
12765 {
12766 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
12767 }
12768 else
12769 {
12770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12771 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12772 }
12773 break;
12774 }
12775 case WDA_ENTER_UAPSD_REQ:
12776 {
12777 if(pWDA->wdaState == WDA_READY_STATE)
12778 {
12779 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
12780 }
12781 else
12782 {
12783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12784 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12785 }
12786 break;
12787 }
12788 case WDA_EXIT_UAPSD_REQ:
12789 {
12790 if(pWDA->wdaState == WDA_READY_STATE)
12791 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12792 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12793 }
12794 else
12795 {
12796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12797 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12798 }
12799 break;
12800 }
12801 case WDA_UPDATE_UAPSD_IND:
12802 {
12803 if(pWDA->wdaState == WDA_READY_STATE)
12804 {
12805 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
12806 }
12807 else
12808 {
12809 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12810 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
12811 }
12812 break;
12813 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12814 case WDA_REGISTER_PE_CALLBACK :
12815 {
12816 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12817 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
12818 /*TODO: store the PE callback */
12819 /* Do Nothing? MSG Body should be freed at here */
12820 if(NULL != pMsg->bodyptr)
12821 {
12822 vos_mem_free(pMsg->bodyptr);
12823 }
12824 break;
12825 }
12826 case WDA_SYS_READY_IND :
12827 {
12828 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12829 "Handling msg type WDA_SYS_READY_IND " );
12830 pWDA->wdaState = WDA_READY_STATE;
12831 if(NULL != pMsg->bodyptr)
12832 {
12833 vos_mem_free(pMsg->bodyptr);
12834 }
12835 break;
12836 }
12837 case WDA_BEACON_FILTER_IND :
12838 {
12839 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
12840 break;
12841 }
12842 case WDA_BTC_SET_CFG:
12843 {
12844 /*TODO: handle this while dealing with BTC */
12845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12846 "Handling msg type WDA_BTC_SET_CFG " );
12847 /* Do Nothing? MSG Body should be freed at here */
12848 if(NULL != pMsg->bodyptr)
12849 {
12850 vos_mem_free(pMsg->bodyptr);
12851 }
12852 break;
12853 }
12854 case WDA_SIGNAL_BT_EVENT:
12855 {
12856 /*TODO: handle this while dealing with BTC */
12857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12858 "Handling msg type WDA_SIGNAL_BT_EVENT " );
12859 /* Do Nothing? MSG Body should be freed at here */
12860 if(NULL != pMsg->bodyptr)
12861 {
12862 vos_mem_free(pMsg->bodyptr);
12863 }
12864 break;
12865 }
12866 case WDA_CFG_RXP_FILTER_REQ:
12867 {
12868 WDA_ProcessConfigureRxpFilterReq(pWDA,
12869 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
12870 break;
12871 }
12872 case WDA_SET_HOST_OFFLOAD:
12873 {
12874 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12875 break;
12876 }
12877 case WDA_SET_KEEP_ALIVE:
12878 {
12879 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
12880 break;
12881 }
12882#ifdef WLAN_NS_OFFLOAD
12883 case WDA_SET_NS_OFFLOAD:
12884 {
12885 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12886 break;
12887 }
12888#endif //WLAN_NS_OFFLOAD
12889 case WDA_ADD_STA_SELF_REQ:
12890 {
12891 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
12892 break;
12893 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12894 case WDA_DEL_STA_SELF_REQ:
12895 {
12896 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
12897 break;
12898 }
12899 case WDA_WOWL_ADD_BCAST_PTRN:
12900 {
12901 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
12902 break;
12903 }
12904 case WDA_WOWL_DEL_BCAST_PTRN:
12905 {
12906 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
12907 break;
12908 }
12909 case WDA_WOWL_ENTER_REQ:
12910 {
12911 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
12912 break;
12913 }
12914 case WDA_WOWL_EXIT_REQ:
12915 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12916 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12917 break;
12918 }
12919 case WDA_TL_FLUSH_AC_REQ:
12920 {
12921 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
12922 break;
12923 }
12924 case WDA_SIGNAL_BTAMP_EVENT:
12925 {
12926 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
12927 break;
12928 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]12929#ifdef WLAN_FEATURE_LINK_LAYER_STATS
12930 case WDA_LINK_LAYER_STATS_SET_REQ:
12931 {
12932 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
12933 break;
12934 }
12935 case WDA_LINK_LAYER_STATS_GET_REQ:
12936 {
12937 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
12938 break;
12939 }
12940 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
12941 {
12942 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
12943 break;
12944 }
12945#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]12946#ifdef WLAN_FEATURE_EXTSCAN
12947 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
12948 {
12949 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
12950 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
12951 break;
12952 }
12953 case WDA_EXTSCAN_START_REQ:
12954 {
12955 WDA_ProcessEXTScanStartReq(pWDA,
12956 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
12957 break;
12958 }
12959 case WDA_EXTSCAN_STOP_REQ:
12960 {
12961 WDA_ProcessEXTScanStopReq(pWDA,
12962 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
12963 break;
12964 }
12965 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
12966 {
12967 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
12968 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
12969 break;
12970 }
12971 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
12972 {
12973 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
12974 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
12975 break;
12976 }
12977 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
12978 {
12979 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
12980 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
12981 break;
12982 }
12983 case WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_REQ:
12984 {
12985 WDA_ProcessEXTScanSetSignfRSSIChangeReq(pWDA,
12986 (tSirEXTScanSetSignificantChangeReqParams *)pMsg->bodyptr);
12987 break;
12988 }
12989 case WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_REQ:
12990 {
12991 WDA_ProcessEXTScanResetSignfRSSIChangeReq(pWDA,
12992 (tSirEXTScanResetSignificantChangeReqParams *)pMsg->bodyptr);
12993 break;
12994 }
12995#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12996#ifdef WDA_UT
12997 case WDA_WDI_EVENT_MSG:
12998 {
12999 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
13000 break ;
13001 }
13002#endif
13003 case WDA_UPDATE_BEACON_IND:
13004 {
13005 WDA_ProcessUpdateBeaconParams(pWDA,
13006 (tUpdateBeaconParams *)pMsg->bodyptr);
13007 break;
13008 }
13009 case WDA_SEND_BEACON_REQ:
13010 {
13011 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
13012 break;
13013 }
13014 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
13015 {
13016 WDA_ProcessUpdateProbeRspTemplate(pWDA,
13017 (tSendProbeRespParams *)pMsg->bodyptr);
13018 break;
13019 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]13020#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13021 case WDA_SET_MAX_TX_POWER_REQ:
13022 {
13023 WDA_ProcessSetMaxTxPowerReq(pWDA,
13024 (tMaxTxPowerParams *)pMsg->bodyptr);
13025 break;
13026 }
13027#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]13028 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
13029 {
13030 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
13031 pMsg->bodyptr);
13032 break;
13033 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]13034 case WDA_SET_TX_POWER_REQ:
13035 {
13036 WDA_ProcessSetTxPowerReq(pWDA,
13037 (tSirSetTxPowerReq *)pMsg->bodyptr);
13038 break;
13039 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13040 case WDA_SET_P2P_GO_NOA_REQ:
13041 {
13042 WDA_ProcessSetP2PGONOAReq(pWDA,
13043 (tP2pPsParams *)pMsg->bodyptr);
13044 break;
13045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13046 /* timer related messages */
13047 case WDA_TIMER_BA_ACTIVITY_REQ:
13048 {
13049 WDA_BaCheckActivity(pWDA) ;
13050 break ;
13051 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13052
13053 /* timer related messages */
13054 case WDA_TIMER_TRAFFIC_STATS_IND:
13055 {
13056 WDA_TimerTrafficStatsInd(pWDA);
13057 break;
13058 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13059#ifdef WLAN_FEATURE_VOWIFI_11R
13060 case WDA_AGGR_QOS_REQ:
13061 {
13062 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
13063 break;
13064 }
13065#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13066 case WDA_FTM_CMD_REQ:
13067 {
13068 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
13069 break ;
13070 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13071#ifdef FEATURE_OEM_DATA_SUPPORT
13072 case WDA_START_OEM_DATA_REQ:
13073 {
13074 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
13075 break;
13076 }
13077#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13078 /* Tx Complete Time out Indication */
13079 case WDA_TX_COMPLETE_TIMEOUT_IND:
13080 {
13081 WDA_ProcessTxCompleteTimeOutInd(pWDA);
13082 break;
13083 }
13084 case WDA_WLAN_SUSPEND_IND:
13085 {
13086 WDA_ProcessWlanSuspendInd(pWDA,
13087 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
13088 break;
13089 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13090 case WDA_WLAN_RESUME_REQ:
13091 {
13092 WDA_ProcessWlanResumeReq(pWDA,
13093 (tSirWlanResumeParam *)pMsg->bodyptr) ;
13094 break;
13095 }
13096
13097 case WDA_UPDATE_CF_IND:
13098 {
13099 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
13100 pMsg->bodyptr = NULL;
13101 break;
13102 }
13103#ifdef FEATURE_WLAN_SCAN_PNO
13104 case WDA_SET_PNO_REQ:
13105 {
13106 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
13107 break;
13108 }
13109 case WDA_UPDATE_SCAN_PARAMS_REQ:
13110 {
13111 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
13112 break;
13113 }
13114 case WDA_SET_RSSI_FILTER_REQ:
13115 {
13116 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
13117 break;
13118 }
13119#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13120#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]13121 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13122 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]13123 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]13124 break;
13125 }
13126#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13127 case WDA_SET_TX_PER_TRACKING_REQ:
13128 {
13129 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
13130 break;
13131 }
13132
13133#ifdef WLAN_FEATURE_PACKET_FILTERING
13134 case WDA_8023_MULTICAST_LIST_REQ:
13135 {
13136 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
13137 break;
13138 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13139 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
13140 {
13141 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
13142 break;
13143 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13144 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
13145 {
13146 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
13147 break;
13148 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13149 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
13150 {
13151 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
13152 break;
13153 }
13154#endif // WLAN_FEATURE_PACKET_FILTERING
13155
13156
13157 case WDA_TRANSMISSION_CONTROL_IND:
13158 {
13159 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
13160 break;
13161 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13162 case WDA_SET_POWER_PARAMS_REQ:
13163 {
13164 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
13165 break;
13166 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13167#ifdef WLAN_FEATURE_GTK_OFFLOAD
13168 case WDA_GTK_OFFLOAD_REQ:
13169 {
13170 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
13171 break;
13172 }
13173
13174 case WDA_GTK_OFFLOAD_GETINFO_REQ:
13175 {
13176 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
13177 break;
13178 }
13179#endif //WLAN_FEATURE_GTK_OFFLOAD
13180
13181 case WDA_SET_TM_LEVEL_REQ:
13182 {
13183 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
13184 break;
13185 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13186
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13187 case WDA_UPDATE_OP_MODE:
13188 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]13189 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
13190 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
13191 {
13192 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13193 }
13194 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13195 {
13196 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
13197 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
13198 else
13199 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13200 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13201 }
13202 else
13203 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13204 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]13205 break;
13206 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]13207#ifdef WLAN_FEATURE_11W
13208 case WDA_EXCLUDE_UNENCRYPTED_IND:
13209 {
13210 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
13211 break;
13212 }
13213#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13214#ifdef FEATURE_WLAN_TDLS
13215 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
13216 {
13217 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
13218 break;
13219 }
13220#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]13221 case WDA_DHCP_START_IND:
13222 {
13223 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13224 break;
13225 }
13226 case WDA_DHCP_STOP_IND:
13227 {
13228 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
13229 break;
13230 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13231#ifdef FEATURE_WLAN_LPHB
13232 case WDA_LPHB_CONF_REQ:
13233 {
13234 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
13235 break;
13236 }
13237#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13238 case WDA_ADD_PERIODIC_TX_PTRN_IND:
13239 {
13240 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
13241 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
13242 break;
13243 }
13244 case WDA_DEL_PERIODIC_TX_PTRN_IND:
13245 {
13246 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
13247 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
13248 break;
13249 }
13250
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13251#ifdef FEATURE_WLAN_BATCH_SCAN
13252 case WDA_SET_BATCH_SCAN_REQ:
13253 {
13254 WDA_ProcessSetBatchScanReq(pWDA,
13255 (tSirSetBatchScanReq *)pMsg->bodyptr);
13256 break;
13257 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]13258 case WDA_RATE_UPDATE_IND:
13259 {
13260 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
13261 break;
13262 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13263 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
13264 {
13265 WDA_ProcessTriggerBatchScanResultInd(pWDA,
13266 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
13267 break;
13268 }
13269 case WDA_STOP_BATCH_SCAN_IND:
13270 {
13271 WDA_ProcessStopBatchScanInd(pWDA,
13272 (tSirStopBatchScanInd *)pMsg->bodyptr);
13273 break;
13274 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]13275 case WDA_GET_BCN_MISS_RATE_REQ:
13276 WDA_ProcessGetBcnMissRateReq(pWDA,
13277 (tSirBcnMissRateReq *)pMsg->bodyptr);
13278 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13279#endif
13280
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13281 case WDA_HT40_OBSS_SCAN_IND:
13282 {
13283 WDA_ProcessHT40OBSSScanInd(pWDA,
13284 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
13285 break;
13286 }
13287 case WDA_HT40_OBSS_STOP_SCAN_IND:
13288 {
13289 WDA_ProcessHT40OBSSStopScanInd(pWDA,
13290 (tANI_U8*)pMsg->bodyptr);
13291 break;
13292 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]13293// tdlsoffchan
13294#ifdef FEATURE_WLAN_TDLS
13295 case WDA_SET_TDLS_CHAN_SWITCH_REQ:
13296 {
13297 WDA_ProcessSetTdlsChanSwitchReq(pWDA, (tTdlsChanSwitchParams *)pMsg->bodyptr);
13298 break;
13299 }
13300#endif
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]13301 case WDA_SPOOF_MAC_ADDR_REQ:
13302 {
13303 WDA_ProcessSetSpoofMacAddrReq(pWDA, (tpSpoofMacAddrReqParams)pMsg->bodyptr);
13304 break;
13305 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13306 default:
13307 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]13308 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13309 "No Handling for msg type %x in WDA "
13310 ,pMsg->type);
13311 /* Do Nothing? MSG Body should be freed at here */
13312 if(NULL != pMsg->bodyptr)
13313 {
13314 vos_mem_free(pMsg->bodyptr);
13315 }
13316 //WDA_VOS_ASSERT(0) ;
13317 }
13318 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13319 return status ;
13320}
13321
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13322/*
13323 * FUNCTION: WDA_LowLevelIndCallback
13324 * IND API callback from WDI, send Ind to PE
13325 */
13326void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
13327 void* pUserData )
13328{
13329 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
13330#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13331 tSirRSSINotification rssiNotification;
13332#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13333 if(NULL == pWDA)
13334 {
13335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13336 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13337 VOS_ASSERT(0);
13338 return ;
13339 }
13340
13341 switch(wdiLowLevelInd->wdiIndicationType)
13342 {
13343 case WDI_RSSI_NOTIFICATION_IND:
13344 {
13345 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13346 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13347#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
13348 rssiNotification.bReserved =
13349 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
13350 rssiNotification.bRssiThres1NegCross =
13351 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
13352 rssiNotification.bRssiThres1PosCross =
13353 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
13354 rssiNotification.bRssiThres2NegCross =
13355 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
13356 rssiNotification.bRssiThres2PosCross =
13357 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
13358 rssiNotification.bRssiThres3NegCross =
13359 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
13360 rssiNotification.bRssiThres3PosCross =
13361 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]13362 rssiNotification.avgRssi = (v_S7_t)
13363 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13364 WLANTL_BMPSRSSIRegionChangedNotification(
13365 pWDA->pVosContext,
13366 &rssiNotification);
13367#endif
13368 break ;
13369 }
13370 case WDI_MISSED_BEACON_IND:
13371 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13372 tpSirSmeMissedBeaconInd pMissBeacInd =
13373 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13375 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13376 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]13377 if(NULL == pMissBeacInd)
13378 {
13379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13380 "%s: VOS MEM Alloc Failure", __func__);
13381 break;
13382 }
13383 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
13384 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
13385 pMissBeacInd->bssIdx =
13386 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
13387 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13388 break ;
13389 }
13390 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
13391 {
13392 /* TODO: Decode Ind and send Ind to PE */
13393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13394 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
13395 break ;
13396 }
13397
13398 case WDI_MIC_FAILURE_IND:
13399 {
13400 tpSirSmeMicFailureInd pMicInd =
13401 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
13402
13403 if(NULL == pMicInd)
13404 {
13405 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13406 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13407 break;
13408 }
13409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13410 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13411 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
13412 pMicInd->length = sizeof(tSirSmeMicFailureInd);
13413 vos_mem_copy(pMicInd->bssId,
13414 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
13415 sizeof(tSirMacAddr));
13416 vos_mem_copy(pMicInd->info.srcMacAddr,
13417 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
13418 sizeof(tSirMacAddr));
13419 vos_mem_copy(pMicInd->info.taMacAddr,
13420 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
13421 sizeof(tSirMacAddr));
13422 vos_mem_copy(pMicInd->info.dstMacAddr,
13423 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
13424 sizeof(tSirMacAddr));
13425 vos_mem_copy(pMicInd->info.rxMacAddr,
13426 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
13427 sizeof(tSirMacAddr));
13428 pMicInd->info.multicast =
13429 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
13430 pMicInd->info.keyId=
13431 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
13432 pMicInd->info.IV1=
13433 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
13434 vos_mem_copy(pMicInd->info.TSC,
13435 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13436 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
13437 (void *)pMicInd , 0) ;
13438 break ;
13439 }
13440 case WDI_FATAL_ERROR_IND:
13441 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]13442 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13443 /* TODO: Decode Ind and send Ind to PE */
13444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13445 "Received WDI_FATAL_ERROR_IND from WDI ");
13446 break ;
13447 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13448 case WDI_DEL_STA_IND:
13449 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13450 tpDeleteStaContext pDelSTACtx =
13451 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
13452
13453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13454 "Received WDI_DEL_STA_IND from WDI ");
13455 if(NULL == pDelSTACtx)
13456 {
13457 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13458 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13459 break;
13460 }
13461 vos_mem_copy(pDelSTACtx->addr2,
13462 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
13463 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13464 vos_mem_copy(pDelSTACtx->bssId,
13465 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
13466 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13467 pDelSTACtx->assocId =
13468 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
13469 pDelSTACtx->reasonCode =
13470 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
13471 pDelSTACtx->staId =
13472 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13473 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
13474 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13475 break ;
13476 }
13477 case WDI_COEX_IND:
13478 {
13479 tANI_U32 index;
13480 vos_msg_t vosMsg;
13481 tSirSmeCoexInd *pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
13482 if(NULL == pSmeCoexInd)
13483 {
13484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13485 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13486 break;
13487 }
13488 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13489 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13490 /* Message Header */
13491 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
13492 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13493 /* Info from WDI Indication */
13494 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
13495 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
13496 {
13497 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
13498 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13499 /* VOS message wrapper */
13500 vosMsg.type = eWNI_SME_COEX_IND;
13501 vosMsg.bodyptr = (void *)pSmeCoexInd;
13502 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13503 /* Send message to SME */
13504 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13505 {
13506 /* free the mem and return */
13507 vos_mem_free((v_VOID_t *)pSmeCoexInd);
13508 }
13509 else
13510 {
13511 /* DEBUG */
13512 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13513 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
13514 pSmeCoexInd->coexIndType,
13515 pSmeCoexInd->coexIndData[0],
13516 pSmeCoexInd->coexIndData[1],
13517 pSmeCoexInd->coexIndData[2],
13518 pSmeCoexInd->coexIndData[3]);
13519 }
13520 break;
13521 }
13522 case WDI_TX_COMPLETE_IND:
13523 {
13524 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
13525 /* Calling TxCompleteAck Indication from wda context*/
13526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13527 "Complete Indication received from HAL");
13528 if( pWDA->pAckTxCbFunc )
13529 {
13530 if( VOS_STATUS_SUCCESS !=
13531 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13532 {
13533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13534 "Tx Complete timeout Timer Stop Failed ");
13535 }
13536 pWDA->pAckTxCbFunc( pMac, wdiLowLevelInd->wdiIndicationData.tx_complete_status);
13537 pWDA->pAckTxCbFunc = NULL;
13538 }
13539 else
13540 {
13541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13542 "Tx Complete Indication is received after timeout ");
13543 }
13544 break;
13545 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]13546 case WDI_P2P_NOA_START_IND :
13547 {
13548 tSirP2PNoaStart *pP2pNoaStart =
13549 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
13550
13551 if (NULL == pP2pNoaStart)
13552 {
13553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13554 "Memory allocation failure, "
13555 "WDI_P2P_NOA_START_IND not forwarded");
13556 break;
13557 }
13558 pP2pNoaStart->status =
13559 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
13560 pP2pNoaStart->bssIdx =
13561 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
13562 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
13563 (void *)pP2pNoaStart , 0) ;
13564 break;
13565 }
13566
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13567#ifdef FEATURE_WLAN_TDLS
13568 case WDI_TDLS_IND :
13569 {
13570 tSirTdlsInd *pTdlsInd =
13571 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
13572
13573 if (NULL == pTdlsInd)
13574 {
13575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13576 "Memory allocation failure, "
13577 "WDI_TDLS_IND not forwarded");
13578 break;
13579 }
13580 pTdlsInd->status =
13581 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
13582 pTdlsInd->assocId =
13583 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
13584 pTdlsInd->staIdx =
13585 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
13586 pTdlsInd->reasonCode =
13587 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
13588 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
13589 (void *)pTdlsInd , 0) ;
13590 break;
13591 }
13592#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13593 case WDI_P2P_NOA_ATTR_IND :
13594 {
13595 tSirP2PNoaAttr *pP2pNoaAttr =
13596 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13598 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13599 if (NULL == pP2pNoaAttr)
13600 {
13601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13602 "Memory allocation failure, "
13603 "WDI_P2P_NOA_ATTR_IND not forwarded");
13604 break;
13605 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13606 pP2pNoaAttr->index =
13607 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
13608 pP2pNoaAttr->oppPsFlag =
13609 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
13610 pP2pNoaAttr->ctWin =
13611 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
13612
13613 pP2pNoaAttr->uNoa1IntervalCnt =
13614 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
13615 pP2pNoaAttr->uNoa1Duration =
13616 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
13617 pP2pNoaAttr->uNoa1Interval =
13618 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
13619 pP2pNoaAttr->uNoa1StartTime =
13620 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13621 pP2pNoaAttr->uNoa2IntervalCnt =
13622 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
13623 pP2pNoaAttr->uNoa2Duration =
13624 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
13625 pP2pNoaAttr->uNoa2Interval =
13626 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
13627 pP2pNoaAttr->uNoa2StartTime =
13628 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13629 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
13630 (void *)pP2pNoaAttr , 0) ;
13631 break;
13632 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13633#ifdef FEATURE_WLAN_SCAN_PNO
13634 case WDI_PREF_NETWORK_FOUND_IND:
13635 {
13636 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13637 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
13638 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13639 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
13640 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
13641
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13643 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13644 if (NULL == pPrefNetworkFoundInd)
13645 {
13646 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13647 "Memory allocation failure, "
13648 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]13649 if (NULL !=
13650 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13651 {
13652 wpalMemoryFree(
13653 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
13654 );
13655 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13656 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13657 break;
13658 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13659 /* Message Header */
13660 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13661 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13662
13663 /* Info from WDI Indication */
13664 pPrefNetworkFoundInd->ssId.length =
13665 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13666 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13667 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
13668 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
13669 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13670 if (NULL !=
13671 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13672 {
13673 pPrefNetworkFoundInd->frameLength =
13674 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13675 vos_mem_copy( pPrefNetworkFoundInd->data,
13676 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
13677 pPrefNetworkFoundInd->frameLength);
13678 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
13679 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13680 }
13681 else
13682 {
13683 pPrefNetworkFoundInd->frameLength = 0;
13684 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13685 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13686 /* VOS message wrapper */
13687 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
13688 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
13689 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13690 /* Send message to SME */
13691 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13692 {
13693 /* free the mem and return */
13694 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
13695 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13696 break;
13697 }
13698#endif // FEATURE_WLAN_SCAN_PNO
13699
13700#ifdef WLAN_WAKEUP_EVENTS
13701 case WDI_WAKE_REASON_IND:
13702 {
13703 vos_msg_t vosMsg;
13704 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
13705 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
13706 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
13707
13708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13709 "[WAKE_REASON WDI] WAKE_REASON_IND Type (0x%x) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
13710 wdiLowLevelInd->wdiIndicationType,
13711 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
13712 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
13713 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13714
13715 if (NULL == pWakeReasonInd)
13716 {
13717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13718 "Memory allocation failure, "
13719 "WDI_WAKE_REASON_IND not forwarded");
13720 break;
13721 }
13722
13723 vos_mem_zero(pWakeReasonInd, allocSize);
13724
13725 /* Message Header */
13726 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
13727 pWakeReasonInd->mesgLen = allocSize;
13728
13729 /* Info from WDI Indication */
13730 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
13731 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
13732 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
13733 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
13734 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
13735 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
13736 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
13737 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13738
13739 /* VOS message wrapper */
13740 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
13741 vosMsg.bodyptr = (void *) pWakeReasonInd;
13742 vosMsg.bodyval = 0;
13743
13744 /* Send message to SME */
13745 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13746 {
13747 /* free the mem and return */
13748 vos_mem_free((v_VOID_t *) pWakeReasonInd);
13749 }
13750
13751 break;
13752 }
13753#endif // WLAN_WAKEUP_EVENTS
13754
13755 case WDI_TX_PER_HIT_IND:
13756 {
13757 vos_msg_t vosMsg;
13758 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
13759 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
13760 /* VOS message wrapper */
13761 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
13762 vosMsg.bodyptr = NULL;
13763 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13764 /* Send message to SME */
13765 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13766 {
13767 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
13768 }
13769 break;
13770 }
13771
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13772#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13773 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13774 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13775 vos_msg_t vosMsg;
13776 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13777
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13778 lphbInd =
13779 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
13780 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13781 {
13782 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13783 "%s: LPHB IND buffer alloc Fail", __func__);
13784 return ;
13785 }
13786
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13787 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13788 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13789 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13790 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13791 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13792 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
13793
13794 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13795 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13796 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
13797
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13798 vosMsg.type = eWNI_SME_LPHB_IND;
13799 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13800 vosMsg.bodyval = 0;
13801 /* Send message to SME */
13802 if (VOS_STATUS_SUCCESS !=
13803 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13804 {
13805 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13806 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13807 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13808 }
13809 break;
13810 }
13811#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13812 case WDI_PERIODIC_TX_PTRN_FW_IND:
13813 {
13814 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13815 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
13816 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
13817 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
13818 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
13819 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
13820 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
13821
13822 break;
13823 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13824
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]13825 case WDI_IBSS_PEER_INACTIVITY_IND:
13826 {
13827 tSirIbssPeerInactivityInd *pIbssInd =
13828 (tSirIbssPeerInactivityInd *)
13829 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
13830
13831 if (NULL == pIbssInd)
13832 {
13833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13834 "Memory allocation failure, "
13835 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
13836 break;
13837 }
13838
13839 pIbssInd->bssIdx =
13840 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
13841 pIbssInd->staIdx =
13842 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
13843 vos_mem_copy(pIbssInd->peerAddr,
13844 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
13845 sizeof(tSirMacAddr));
13846 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
13847 break;
13848 }
13849
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13850#ifdef FEATURE_WLAN_BATCH_SCAN
13851 case WDI_BATCH_SCAN_RESULT_IND:
13852 {
13853 void *pBatchScanResult;
13854 void *pCallbackContext;
13855 tpAniSirGlobal pMac;
13856
13857 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13858 "Received WDI_BATCHSCAN_RESULT_IND from FW");
13859
13860 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13861 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13862 {
13863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13864 "%s:pWDA is NULL", __func__);
13865 VOS_ASSERT(0);
13866 return;
13867 }
13868
13869 pBatchScanResult =
13870 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
13871 if (NULL == pBatchScanResult)
13872 {
13873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13874 "%s:Batch scan result from FW is null can't invoke HDD callback",
13875 __func__);
13876 VOS_ASSERT(0);
13877 return;
13878 }
13879
13880 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13881 if (NULL == pMac)
13882 {
13883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13884 "%s:pMac is NULL", __func__);
13885 VOS_ASSERT(0);
13886 return;
13887 }
13888
13889 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
13890 /*call hdd callback with set batch scan response data*/
13891 if(pMac->pmc.batchScanResultCallback)
13892 {
13893 pMac->pmc.batchScanResultCallback(pCallbackContext,
13894 pBatchScanResult);
13895 }
13896 else
13897 {
13898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13899 "%s:HDD callback is null", __func__);
13900 VOS_ASSERT(0);
13901 }
13902 break;
13903 }
13904#endif
13905
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]13906#ifdef FEATURE_WLAN_CH_AVOID
13907 case WDI_CH_AVOID_IND:
13908 {
13909 vos_msg_t vosMsg;
13910 tSirChAvoidIndType *chAvoidInd;
13911
13912 chAvoidInd =
13913 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
13914 if (NULL == chAvoidInd)
13915 {
13916 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13917 "%s: CH_AVOID IND buffer alloc Fail", __func__);
13918 return ;
13919 }
13920
13921 chAvoidInd->avoidRangeCount =
13922 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
13923 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
13924 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
13925 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
13926
13927 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13928 "%s : WDA CH avoid notification", __func__);
13929
13930 vosMsg.type = eWNI_SME_CH_AVOID_IND;
13931 vosMsg.bodyptr = chAvoidInd;
13932 vosMsg.bodyval = 0;
13933 /* Send message to SME */
13934 if (VOS_STATUS_SUCCESS !=
13935 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13936 {
13937 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13938 "post eWNI_SME_CH_AVOID_IND to SME Failed");
13939 vos_mem_free(chAvoidInd);
13940 }
13941 break;
13942 }
13943#endif /* FEATURE_WLAN_CH_AVOID */
13944
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13945#ifdef WLAN_FEATURE_LINK_LAYER_STATS
13946 case WDI_LL_STATS_RESULTS_IND:
13947 {
13948 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13949 tpAniSirGlobal pMac;
13950
13951 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13952 "Received WDI_LL_STATS_RESULTS_IND from FW");
13953
13954 /*sanity check*/
13955 if (NULL == pWDA)
13956 {
13957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13958 "%s:pWDA is NULL", __func__);
13959 VOS_ASSERT(0);
13960 return;
13961 }
13962
13963 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13964 (void *)wdiLowLevelInd->
13965 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13966 if (NULL == pLinkLayerStatsInd)
13967 {
13968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13969 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
13970 __func__);
13971 VOS_ASSERT(0);
13972 return;
13973 }
13974
13975 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13976 if (NULL == pMac)
13977 {
13978 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13979 "%s:pMac is NULL", __func__);
13980 VOS_ASSERT(0);
13981 return;
13982 }
13983
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13984 /* call hdd callback with Link Layer Statistics.
13985 * vdev_id/ifacId in link_stats_results will be
13986 * used to retrieve the correct HDD context
13987 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13988 if (pMac->sme.pLinkLayerStatsIndCallback)
13989 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13990 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13991 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13992 pLinkLayerStatsInd,
13993 wdiLowLevelInd->
13994 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13995 }
13996 else
13997 {
13998 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13999 "%s:HDD callback is null", __func__);
14000 }
14001 break;
14002 }
14003#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
14004
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]14005#ifdef WLAN_FEATURE_EXTSCAN
14006 case WDI_EXTSCAN_PROGRESS_IND:
14007 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
14008 case WDI_EXTSCAN_SCAN_RESULT_IND:
14009 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
14010 case WDI_EXTSCAN_SIGN_RSSI_RESULT_IND:
14011 {
14012 void *pEXTScanData;
14013 void *pCallbackContext;
14014 tpAniSirGlobal pMac;
14015 tANI_U16 indType;
14016
14017 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14018 "Received WDI_EXTSCAN Indications from FW");
14019 /*sanity check*/
14020 if (NULL == pWDA)
14021 {
14022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14023 "%s:pWDA is NULL", __func__);
14024 VOS_ASSERT(0);
14025 return;
14026 }
14027 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
14028 {
14029 indType = WDA_EXTSCAN_PROGRESS_IND;
14030
14031 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14032 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
14033 }
14034 if (wdiLowLevelInd->wdiIndicationType ==
14035 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
14036 {
14037 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
14038
14039 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14040 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
14041 }
14042 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
14043 {
14044 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
14045
14046 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14047 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
14048 }
14049 if (wdiLowLevelInd->wdiIndicationType ==
14050 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
14051 {
14052 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
14053
14054 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14055 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
14056 }
14057 if (wdiLowLevelInd->wdiIndicationType ==
14058 WDI_EXTSCAN_SIGN_RSSI_RESULT_IND)
14059 {
14060 indType = WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND;
14061
14062 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14063 "WDI_EXTSCAN Indication is WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND");
14064 }
14065
14066 pEXTScanData =
14067 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
14068 if (NULL == pEXTScanData)
14069 {
14070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14071 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
14072 __func__);
14073 VOS_ASSERT(0);
14074 return;
14075 }
14076
14077 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14078 if (NULL == pMac)
14079 {
14080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14081 "%s:pMac is NULL", __func__);
14082 VOS_ASSERT(0);
14083 return;
14084 }
14085
14086 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
14087
14088 if(pMac->sme.pEXTScanIndCb)
14089 {
14090 pMac->sme.pEXTScanIndCb(pCallbackContext,
14091 indType,
14092 pEXTScanData);
14093 }
14094 else
14095 {
14096 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14097 "%s:HDD callback is null", __func__);
14098 }
14099 break;
14100 }
14101#endif /* WLAN_FEATURE_EXTSCAN */
Abhishek Singh66c16762014-08-14 19:13:19 +0530[diff] [blame]14102 case WDI_DEL_BA_IND:
14103 {
14104 tpBADeleteParams pDelBAInd =
14105 (tpBADeleteParams)vos_mem_malloc(sizeof(tpBADeleteParams));
14106
14107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14108 "Received WDI_DEL_BA_IND from WDI ");
14109 if(NULL == pDelBAInd)
14110 {
14111 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14112 "%s: VOS MEM Alloc Failure", __func__);
14113 break;
14114 }
14115 vos_mem_copy(pDelBAInd->peerMacAddr,
14116 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.peerMacAddr,
14117 sizeof(tSirMacAddr));
14118 vos_mem_copy(pDelBAInd->bssId,
14119 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.bssId,
14120 sizeof(tSirMacAddr));
14121 pDelBAInd->staIdx =
14122 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.staIdx;
14123 pDelBAInd->baTID =
14124 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baTID;
14125 pDelBAInd->baDirection =
14126 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baDirection;
14127 pDelBAInd->reasonCode =
14128 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.reasonCode;
14129
14130 WDA_SendMsg(pWDA, SIR_LIM_DEL_BA_IND,
14131 (void *)pDelBAInd , 0) ;
14132 break;
14133 }
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]14134
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14135 default:
14136 {
14137 /* TODO error */
14138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14139 "Received UNKNOWN Indication from WDI ");
14140 }
14141 }
14142 return ;
14143}
14144
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14145/*
14146 * BA related processing in WDA.
14147 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14148void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
14149 void* pUserData)
14150{
14151 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14152 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14153 if(NULL == pWdaParams)
14154 {
14155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14156 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14157 VOS_ASSERT(0) ;
14158 return ;
14159 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14160 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14161 vos_mem_free(pWdaParams->wdaMsgParam) ;
14162 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14163 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14165 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14166 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
14167 {
14168 tANI_U8 i = 0 ;
14169 tBaActivityInd *baActivityInd = NULL ;
14170 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
14171 tANI_U8 allocSize = sizeof(tBaActivityInd)
14172 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
14173 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
14174 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14175 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14176 if(NULL == baActivityInd)
14177 {
14178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14179 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14180 VOS_ASSERT(0) ;
14181 return;
14182 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14183 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
14184 sizeof(tSirMacAddr)) ;
14185 baActivityInd->baCandidateCnt = baCandidateCount ;
14186
14187 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
14188 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
14189
14190 for(i = 0 ; i < baCandidateCount ; i++)
14191 {
14192 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14193 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
14194 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14195 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
14196 {
14197 baCandidate->baInfo[tid].fBaEnable =
14198 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
14199 baCandidate->baInfo[tid].startingSeqNum =
14200 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
14201 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]14202 wdiBaCandidate++ ;
14203 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14204 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14205 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
14206 }
14207 else
14208 {
14209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14210 "BA Trigger RSP with Failure received ");
14211 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14212 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14213}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14214
14215
14216/*
14217 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
14218 * during MCC
14219 */
14220void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
14221{
14222 wpt_uint32 enabled;
14223 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
14224 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
14225 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
14226
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14227 if (NULL == pMac )
14228 {
14229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14230 "%s: Invoked with invalid MAC context ", __func__ );
14231 VOS_ASSERT(0);
14232 return;
14233 }
14234
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14235 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14236 != eSIR_SUCCESS)
14237 {
14238 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14239 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14240 return;
14241 }
14242
14243 if(!enabled)
14244 {
14245 return;
14246 }
14247
14248 if(NULL == pWDA)
14249 {
14250 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14251 "%s:WDA context is NULL", __func__);
14252 VOS_ASSERT(0);
14253 return;
14254 }
14255
14256 if(activate)
14257 {
14258 if( VOS_STATUS_SUCCESS !=
14259 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14260 {
14261 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14262 "Traffic Stats Timer Start Failed ");
14263 return;
14264 }
14265 WDI_DS_ActivateTrafficStats();
14266 }
14267 else
14268 {
14269 WDI_DS_DeactivateTrafficStats();
14270 WDI_DS_ClearTrafficStats();
14271
14272 if( VOS_STATUS_SUCCESS !=
14273 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14274 {
14275 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14276 "Traffic Stats Timer Stop Failed ");
14277 return;
14278 }
14279 }
14280}
14281
14282/*
14283 * Traffic Stats Timer handler
14284 */
14285void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
14286{
14287 WDI_Status wdiStatus;
14288 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
14289 WDI_TrafficStatsIndType trafficStatsIndParams;
14290 wpt_uint32 length, enabled;
14291 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14292
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14293 if (NULL == pMac )
14294 {
14295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14296 "%s: Invoked with invalid MAC context ", __func__ );
14297 VOS_ASSERT(0);
14298 return;
14299 }
14300
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14301 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
14302 != eSIR_SUCCESS)
14303 {
14304 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14305 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
14306 return;
14307 }
14308
14309 if(!enabled)
14310 {
14311 WDI_DS_DeactivateTrafficStats();
14312 return;
14313 }
14314
14315 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
14316
14317 if(pWdiTrafficStats != NULL)
14318 {
14319 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
14320 trafficStatsIndParams.length = length;
14321 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]14322 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14323 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
14324 trafficStatsIndParams.pUserData = pWDA;
14325
14326 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
14327
14328 if(WDI_STATUS_PENDING == wdiStatus)
14329 {
14330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14331 "Pending received for %s:%d ",__func__,__LINE__ );
14332 }
14333 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
14334 {
14335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14336 "Failure in %s:%d ",__func__,__LINE__ );
14337 }
14338
14339 WDI_DS_ClearTrafficStats();
14340 }
14341 else
14342 {
14343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14344 "pWdiTrafficStats is Null");
14345 }
14346
14347 if( VOS_STATUS_SUCCESS !=
14348 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
14349 {
14350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
14351 "Traffic Stats Timer Start Failed ");
14352 return;
14353 }
14354}
14355
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14356/*
14357 * BA Activity check timer handler
14358 */
14359void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
14360{
14361 tANI_U8 curSta = 0 ;
14362 tANI_U8 tid = 0 ;
14363 tANI_U8 size = 0 ;
14364 tANI_U8 baCandidateCount = 0 ;
14365 tANI_U8 newBaCandidate = 0 ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14366 tANI_U32 val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14367 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14368 tpAniSirGlobal pMac;
14369
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14370 if(NULL == pWDA)
14371 {
14372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14373 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14374 VOS_ASSERT(0);
14375 return ;
14376 }
14377 if(WDA_MAX_STA < pWDA->wdaMaxSta)
14378 {
14379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14380 "Inconsistent STA entries in WDA");
14381 VOS_ASSERT(0) ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14382 }
14383 if(NULL == pWDA->pVosContext)
14384 {
14385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14386 "%s: pVosContext is NULL",__func__);
14387 VOS_ASSERT(0);
14388 return ;
14389 }
14390 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14391 if (wlan_cfgGetInt(pMac,
14392 WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC, &val) !=
14393 eSIR_SUCCESS)
14394 {
14395 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14396 "Unable to get WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC");
14397 val = 0;
14398 }
14399
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14400 /* walk through all STA entries and find out TX packet count */
14401 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
14402 {
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14403 tANI_U32 currentOperChan = pWDA->wdaStaInfo[curSta].currentOperChan;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]14404#ifdef WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14405 // We can only do BA on "hard" STAs.
14406 if (!(IS_HWSTA_IDX(curSta)))
14407 {
14408 continue;
14409 }
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]14410#endif //WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14411 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
14412 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14413 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14414 tANI_U32 txPktCount = 0 ;
14415 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14416 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14417 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
14418 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14419 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
14420 curSta, tid, &txPktCount)))
14421 {
14422#if 0
14423 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14424 "************* %d:%d, %d ",curSta, txPktCount,
14425 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
14426#endif
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]14427 if(val && ( (currentOperChan >= SIR_11B_CHANNEL_BEGIN) &&
14428 (currentOperChan <= SIR_11B_CHANNEL_END)))
14429 {
14430 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14431 "%s: BTC disabled aggregation - dont start "
14432 "TX ADDBA req",__func__);
14433 }
14434 else if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]14435 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14436 && (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
14437 curSta, tid)))
14438 {
14439 /* get prepare for sending message to HAL */
14440 //baCandidate[baCandidateCount].staIdx = curSta ;
14441 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
14442 newBaCandidate = WDA_ENABLE_BA ;
14443 }
14444 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
14445 }
14446 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14447 /* fill the entry for all the sta with given TID's */
14448 if(WDA_ENABLE_BA == newBaCandidate)
14449 {
14450 /* move to next BA candidate */
14451 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
14452 size += sizeof(WDI_TriggerBAReqCandidateType) ;
14453 baCandidateCount++ ;
14454 newBaCandidate = WDA_DISABLE_BA ;
14455 }
14456 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14457 /* prepare and send message to hal */
14458 if( 0 < baCandidateCount)
14459 {
14460 WDI_Status status = WDI_STATUS_SUCCESS ;
14461 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
14462 tWDA_ReqParams *pWdaParams =
14463 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14464 if(NULL == pWdaParams)
14465 {
14466 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14467 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14468 VOS_ASSERT(0) ;
14469 return;
14470 }
14471 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
14472 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
14473 if(NULL == wdiTriggerBaReq)
14474 {
14475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14476 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14477 VOS_ASSERT(0) ;
14478 vos_mem_free(pWdaParams);
14479 return;
14480 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14481 do
14482 {
14483 WDI_TriggerBAReqinfoType *triggerBaInfo =
14484 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
14485 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
14486 /* TEMP_FIX: Need to see if WDI need check for assoc session for
14487 * for each request */
14488 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
14489 triggerBaInfo->ucBASessionID = 0;
14490 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
14491 } while(0) ;
14492 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
14493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14494 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14495 pWdaParams->pWdaContext = pWDA;
14496 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
14497 pWdaParams->wdaMsgParam = NULL;
14498 status = WDI_TriggerBAReq(wdiTriggerBaReq,
14499 WDA_TriggerBaReqCallback, pWdaParams) ;
14500 if(IS_WDI_STATUS_FAILURE(status))
14501 {
14502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14503 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
14504 vos_mem_free(pWdaParams->wdaMsgParam) ;
14505 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14506 vos_mem_free(pWdaParams) ;
14507 }
14508 }
14509 else
14510 {
14511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14512 "There is no TID for initiating BA");
14513 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14514 if( VOS_STATUS_SUCCESS !=
14515 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14516 {
14517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14518 "BA Activity Timer Stop Failed ");
14519 return ;
14520 }
14521 if( VOS_STATUS_SUCCESS !=
14522 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14523 {
14524 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14525 "BA Activity Timer Start Failed ");
14526 return;
14527 }
14528 return ;
14529}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14530/*
14531 * WDA common routine to create timer used by WDA.
14532 */
14533static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
14534{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14535 VOS_STATUS status = VOS_STATUS_SUCCESS ;
14536 tANI_U32 val = 0 ;
14537 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14538
14539 if(NULL == pMac)
14540 {
14541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14542 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14543 VOS_ASSERT(0);
14544 return VOS_STATUS_E_FAILURE;
14545 }
14546 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
14547 != eSIR_SUCCESS)
14548 {
14549 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14550 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
14551 return VOS_STATUS_E_FAILURE;
14552 }
14553 val = SYS_MS_TO_TICKS(val) ;
14554
14555 /* BA activity check timer */
14556 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
14557 "BA Activity Check timer", WDA_TimerHandler,
14558 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
14559 if(status != TX_SUCCESS)
14560 {
14561 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14562 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14563 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14564 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14565 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14566 /* Tx Complete Timeout timer */
14567 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
14568 "Tx Complete Check timer", WDA_TimerHandler,
14569 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14570 if(status != TX_SUCCESS)
14571 {
14572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14573 "Unable to create Tx Complete Timeout timer");
14574 /* Destroy timer of BA activity check timer */
14575 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14576 if(status != TX_SUCCESS)
14577 {
14578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14579 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14580 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14581 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14582 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14583 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14584
14585 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
14586
14587 /* Traffic Stats timer */
14588 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
14589 "Traffic Stats timer", WDA_TimerHandler,
14590 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
14591 if(status != TX_SUCCESS)
14592 {
14593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14594 "Unable to create traffic stats timer");
14595 /* Destroy timer of BA activity check timer */
14596 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14597 if(status != TX_SUCCESS)
14598 {
14599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14600 "Unable to Destroy BA activity timer");
14601 }
14602 /* Destroy timer of tx complete timer */
14603 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14604 if(status != TX_SUCCESS)
14605 {
14606 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14607 "Unable to Tx complete timer");
14608 }
14609 return VOS_STATUS_E_FAILURE ;
14610 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14611 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14612}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14613/*
14614 * WDA common routine to destroy timer used by WDA.
14615 */
14616static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
14617{
14618 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14619 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14620 if(status != TX_SUCCESS)
14621 {
14622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14623 "Unable to Destroy Tx Complete Timeout timer");
14624 return eSIR_FAILURE ;
14625 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14626 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14627 if(status != TX_SUCCESS)
14628 {
14629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14630 "Unable to Destroy BA activity timer");
14631 return eSIR_FAILURE ;
14632 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14633 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
14634 if(status != TX_SUCCESS)
14635 {
14636 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14637 "Unable to Destroy traffic stats timer");
14638 return eSIR_FAILURE ;
14639 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14640 return eSIR_SUCCESS ;
14641}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14642/*
14643 * WDA timer handler.
14644 */
14645void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
14646{
14647 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
14648 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14649 /*
14650 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
14651 */
14652 wdaMsg.type = timerInfo ;
14653 wdaMsg.bodyptr = NULL;
14654 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14655 /* post the message.. */
14656 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
14657 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
14658 {
14659 vosStatus = VOS_STATUS_E_BADMSG;
14660 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14661}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14662/*
14663 * WDA Tx Complete timeout Indication.
14664 */
14665void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
14666{
14667 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14668 if( pWDA->pAckTxCbFunc )
14669 {
14670 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14671 "TxComplete timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14672 pWDA->pAckTxCbFunc( pMac, 0);
14673 pWDA->pAckTxCbFunc = NULL;
14674 }
14675 else
14676 {
14677 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14678 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14679 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14680}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14681/*
14682 * WDA Set REG Domain to VOS NV
14683 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14684eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
14685 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14686{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14687 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14688 {
14689 return eHAL_STATUS_INVALID_PARAMETER;
14690 }
14691 return eHAL_STATUS_SUCCESS;
14692}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14693
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14694#ifdef FEATURE_WLAN_SCAN_PNO
14695/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14696 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14697 *
14698 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14699void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14700{
14701 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14702 tSirPNOScanReq *pPNOScanReqParams;
14703
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14705 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14706 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14707 {
14708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14709 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14710 VOS_ASSERT(0) ;
14711 return ;
14712 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14713
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14714 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14715 if(pPNOScanReqParams->statusCallback)
14716 {
14717 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14718 (status == WDI_STATUS_SUCCESS) ?
14719 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
14720 }
14721
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14722 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14723 vos_mem_free(pWdaParams->wdaMsgParam);
14724 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14725
14726 return ;
14727}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14728/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14729 * FUNCTION: WDA_PNOScanReqCallback
14730 * Free memory.
14731 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
14732 */
14733void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14734{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14735 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14736 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14737
14738 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14739 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14740
14741 if(NULL == pWdaParams)
14742 {
14743 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14744 "%s: pWdaParams received NULL", __func__);
14745 VOS_ASSERT(0);
14746 return;
14747 }
14748
14749 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14750 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14751 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14752 if(pPNOScanReqParams->statusCallback)
14753 {
14754 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14755 VOS_STATUS_E_FAILURE);
14756 }
14757
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14758 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14759 vos_mem_free(pWdaParams->wdaMsgParam);
14760 vos_mem_free(pWdaParams);
14761 }
14762
14763 return;
14764}
14765/*
14766 * FUNCTION: WDA_UpdateScanParamsRespCallback
14767 *
14768 */
14769void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
14770{
14771 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14773 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14774 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14775 {
14776 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14777 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14778 VOS_ASSERT(0) ;
14779 return ;
14780 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14781
14782 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14783 vos_mem_free(pWdaParams->wdaMsgParam);
14784 vos_mem_free(pWdaParams);
14785
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14786 return ;
14787}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14788/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14789 * FUNCTION: WDA_UpdateScanParamsReqCallback
14790 * Free memory.
14791 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
14792 */
14793void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14794{
14795 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14796
14797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14798 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14799
14800 if(NULL == pWdaParams)
14801 {
14802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14803 "%s: pWdaParams received NULL", __func__);
14804 VOS_ASSERT(0);
14805 return;
14806 }
14807
14808 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14809 {
14810 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14811 vos_mem_free(pWdaParams->wdaMsgParam);
14812 vos_mem_free(pWdaParams);
14813 }
14814
14815 return;
14816}
14817/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14818 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14819 * Request to WDI to set Preferred Network List.Offload
14820 */
14821VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
14822 tSirPNOScanReq *pPNOScanReqParams)
14823{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14824 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14825 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
14826 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
14827 tWDA_ReqParams *pWdaParams ;
14828 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14830 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14831 if(NULL == pwdiPNOScanReqInfo)
14832 {
14833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14834 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14835 VOS_ASSERT(0);
14836 return VOS_STATUS_E_NOMEM;
14837 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14838 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14839 if(NULL == pWdaParams)
14840 {
14841 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14842 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14843 VOS_ASSERT(0);
14844 vos_mem_free(pwdiPNOScanReqInfo);
14845 return VOS_STATUS_E_NOMEM;
14846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14847 //
14848 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
14849 //
14850 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
14851 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14852 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
14853 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
14854 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14855 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
14856 {
14857 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
14858 &pPNOScanReqParams->aNetworks[i],
14859 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
14860 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14861 /*Scan timer intervals*/
14862 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
14863 &pPNOScanReqParams->scanTimers,
14864 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14865 /*Probe template for 2.4GHz band*/
14866 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
14867 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14868 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14869 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
14870 pPNOScanReqParams->p24GProbeTemplate,
14871 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14872 /*Probe template for 5GHz band*/
14873 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
14874 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14875 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14876 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
14877 pPNOScanReqParams->p5GProbeTemplate,
14878 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14879 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
14880 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14881
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14882 /* Store Params pass it to WDI */
14883 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
14884 pWdaParams->pWdaContext = pWDA;
14885 /* Store param pointer as passed in by caller */
14886 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14887 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14888 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14889 if(IS_WDI_STATUS_FAILURE(status))
14890 {
14891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14892 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14893 if(pPNOScanReqParams->statusCallback)
14894 {
14895 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14896 VOS_STATUS_E_FAILURE);
14897 }
14898
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14899 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14900 vos_mem_free(pWdaParams->wdaMsgParam);
14901 pWdaParams->wdaWdiApiMsgParam = NULL;
14902 pWdaParams->wdaMsgParam = NULL;
14903 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14904 return CONVERT_WDI2VOS_STATUS(status) ;
14905}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14906
14907#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14908
14909void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
14910{
14911 /*Convert the CSR Auth types to WDI Auth types */
14912 switch (csrAuthType)
14913 {
14914 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
14915 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14916 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14917#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14918 case eCSR_AUTH_TYPE_CCKM_WPA:
14919 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
14920 break;
14921#endif
14922 case eCSR_AUTH_TYPE_WPA:
14923 *AuthType = eWDA_AUTH_TYPE_WPA;
14924 break;
14925 case eCSR_AUTH_TYPE_WPA_PSK:
14926 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
14927 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14928#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14929 case eCSR_AUTH_TYPE_CCKM_RSN:
14930 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
14931 break;
14932#endif
14933 case eCSR_AUTH_TYPE_RSN:
14934 *AuthType = eWDA_AUTH_TYPE_RSN;
14935 break;
14936 case eCSR_AUTH_TYPE_RSN_PSK:
14937 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
14938 break;
14939#if defined WLAN_FEATURE_VOWIFI_11R
14940 case eCSR_AUTH_TYPE_FT_RSN:
14941 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
14942 break;
14943 case eCSR_AUTH_TYPE_FT_RSN_PSK:
14944 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
14945 break;
14946#endif
14947#ifdef FEATURE_WLAN_WAPI
14948 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
14949 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
14950 break;
14951 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
14952 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
14953 break;
14954#endif /* FEATURE_WLAN_WAPI */
14955 case eCSR_AUTH_TYPE_SHARED_KEY:
14956 case eCSR_AUTH_TYPE_AUTOSWITCH:
14957 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14958 break;
14959#if 0
14960 case eCSR_AUTH_TYPE_SHARED_KEY:
14961 *AuthType = eWDA_AUTH_TYPE_SHARED_KEY;
14962 break;
14963 case eCSR_AUTH_TYPE_AUTOSWITCH:
14964 *AuthType = eWDA_AUTH_TYPE_AUTOSWITCH;
14965#endif
14966 default:
14967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14968 "%s: Unknown Auth Type", __func__);
14969 break;
14970 }
14971}
14972void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
14973{
14974 switch (csrEncrType)
14975 {
14976 case eCSR_ENCRYPT_TYPE_NONE:
14977 *EncrType = WDI_ED_NONE;
14978 break;
14979 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
14980 case eCSR_ENCRYPT_TYPE_WEP40:
14981 *EncrType = WDI_ED_WEP40;
14982 break;
14983 case eCSR_ENCRYPT_TYPE_WEP104:
14984 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
14985 *EncrType = WDI_ED_WEP104;
14986 break;
14987 case eCSR_ENCRYPT_TYPE_TKIP:
14988 *EncrType = WDI_ED_TKIP;
14989 break;
14990 case eCSR_ENCRYPT_TYPE_AES:
14991 *EncrType = WDI_ED_CCMP;
14992 break;
14993#ifdef WLAN_FEATURE_11W
14994 case eCSR_ENCRYPT_TYPE_AES_CMAC:
14995 *EncrType = WDI_ED_AES_128_CMAC;
14996 break;
14997#endif
14998#ifdef FEATURE_WLAN_WAPI
14999 case eCSR_ENCRYPT_TYPE_WPI:
15000 *EncrType = WDI_ED_WPI;
15001 break;
15002#endif
15003 case eCSR_ENCRYPT_TYPE_ANY:
15004 *EncrType = WDI_ED_ANY;
15005 break;
15006
15007 default:
15008 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15009 "%s: Unknown Encryption Type", __func__);
15010 break;
15011 }
15012}
15013
15014/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15015 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15016 * Request to WDI to set Roam Offload Scan
15017 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15018VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15019 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
15020{
15021 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15022 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
15023 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15024 tWDA_ReqParams *pWdaParams ;
15025 v_U8_t csrAuthType;
15026 WDI_RoamNetworkType *pwdiRoamNetworkType;
15027 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
15028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15029 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15030 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15031 {
15032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15033 "%s: VOS MEM Alloc Failure", __func__);
15034 VOS_ASSERT(0);
15035 return VOS_STATUS_E_NOMEM;
15036 }
15037 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15038 if (NULL == pWdaParams)
15039 {
15040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15041 "%s: VOS MEM Alloc Failure", __func__);
15042 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15043 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15044 return VOS_STATUS_E_NOMEM;
15045 }
15046
15047 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15048 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15049 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15050 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
15051 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15052 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
15053 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
15054 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
15055 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
15056 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
15057 sizeof(pwdiRoamNetworkType->currAPbssid));
15058 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
15059 csrAuthType);
15060 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
15061 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
15062 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
15063 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
15064 pwdiRoamOffloadScanInfo->LookupThreshold =
15065 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]15066 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
15067 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15068 pwdiRoamOffloadScanInfo->RoamRssiDiff =
15069 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]15070 pwdiRoamOffloadScanInfo->MAWCEnabled =
15071 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15072 pwdiRoamOffloadScanInfo->Command =
15073 pRoamOffloadScanReqParams->Command ;
15074 pwdiRoamOffloadScanInfo->StartScanReason =
15075 pRoamOffloadScanReqParams->StartScanReason ;
15076 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
15077 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
15078 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
15079 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
15080 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
15081 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
15082 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
15083 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
15084 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
15085 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]15086 pwdiRoamOffloadScanInfo->IsESEEnabled =
15087 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15088 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
15089 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
15090 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
15091 pwdiRoamNetworkType->ssId.ucLength =
15092 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
15093 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
15094 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
15095 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
15096 pwdiRoamNetworkType->ChannelCount =
15097 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
15098 pwdiRoamOffloadScanInfo->ChannelCacheType =
15099 pRoamOffloadScanReqParams->ChannelCacheType;
15100 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
15101 pRoamOffloadScanReqParams->ValidChannelList,
15102 pRoamOffloadScanReqParams->ValidChannelCount);
15103 pwdiRoamOffloadScanInfo->ValidChannelCount =
15104 pRoamOffloadScanReqParams->ValidChannelCount;
15105 pwdiRoamOffloadScanInfo->us24GProbeSize =
15106 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
15107 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
15108 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
15109 pRoamOffloadScanReqParams->p24GProbeTemplate,
15110 pwdiRoamOffloadScanInfo->us24GProbeSize);
15111 pwdiRoamOffloadScanInfo->us5GProbeSize =
15112 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
15113 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
15114 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
15115 pRoamOffloadScanReqParams->p5GProbeTemplate,
15116 pwdiRoamOffloadScanInfo->us5GProbeSize);
15117 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
15118 pRoamOffloadScanReqParams->MDID.mdiePresent;
15119 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
15120 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15121 pwdiRoamOffloadScanInfo->nProbes =
15122 pRoamOffloadScanReqParams->nProbes;
15123 pwdiRoamOffloadScanInfo->HomeAwayTime =
15124 pRoamOffloadScanReqParams->HomeAwayTime;
15125 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15126 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15127 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15128 pWdaParams->pWdaContext = pWDA;
15129 /* Store param pointer as passed in by caller */
15130 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15131 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15132 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
15133 if(IS_WDI_STATUS_FAILURE(status))
15134 {
15135 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15136 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
15137 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15138 vos_mem_free(pWdaParams->wdaMsgParam);
15139 pWdaParams->wdaWdiApiMsgParam = NULL;
15140 pWdaParams->wdaMsgParam = NULL;
15141 }
15142 return CONVERT_WDI2VOS_STATUS(status) ;
15143}
15144#endif
15145
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15146/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15147 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15148 *
15149 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15150void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15151{
15152 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15153
15154 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15155 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15156
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15157 if(NULL == pWdaParams)
15158 {
15159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15160 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15161 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15162 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]15163 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15164
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15165 vos_mem_free(pWdaParams->wdaMsgParam) ;
15166 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15167 vos_mem_free(pWdaParams) ;
15168
15169 return ;
15170}
15171/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15172 * FUNCTION: WDA_RssiFilterReqCallback
15173 * Free memory.
15174 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
15175 */
15176void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15177{
15178 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15179
15180 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15181 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15182
15183 if(NULL == pWdaParams)
15184 {
15185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15186 "%s: pWdaParams received NULL", __func__);
15187 VOS_ASSERT(0);
15188 return;
15189 }
15190
15191 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15192 {
15193 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15194 vos_mem_free(pWdaParams->wdaMsgParam);
15195 vos_mem_free(pWdaParams);
15196 }
15197
15198 return;
15199}
15200/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15201 * FUNCTION: WDA_ProcessSetPreferredNetworkList
15202 * Request to WDI to set Preferred Network List.Offload
15203 */
15204VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
15205 tSirSetRSSIFilterReq* pRssiFilterParams)
15206{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15207 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15208 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
15209 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
15210 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15212 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15213 if(NULL == pwdiSetRssiFilterReqInfo)
15214 {
15215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15216 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15217 VOS_ASSERT(0);
15218 return VOS_STATUS_E_NOMEM;
15219 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15220 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15221 if(NULL == pWdaParams)
15222 {
15223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15224 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15225 VOS_ASSERT(0);
15226 vos_mem_free(pwdiSetRssiFilterReqInfo);
15227 return VOS_STATUS_E_NOMEM;
15228 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15229 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15230 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
15231 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15232
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15233 /* Store Params pass it to WDI */
15234 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
15235 pWdaParams->pWdaContext = pWDA;
15236 /* Store param pointer as passed in by caller */
15237 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15238 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15239 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15240 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15241 if(IS_WDI_STATUS_FAILURE(status))
15242 {
15243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15244 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
15245 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15246 vos_mem_free(pWdaParams->wdaMsgParam);
15247 pWdaParams->wdaWdiApiMsgParam = NULL;
15248 pWdaParams->wdaMsgParam = NULL;
15249 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15250 return CONVERT_WDI2VOS_STATUS(status) ;
15251}
15252
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15253/*
15254 * FUNCTION: WDA_ProcessUpdateScanParams
15255 * Request to WDI to update Scan Parameters
15256 */
15257VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
15258 tSirUpdateScanParams *pUpdateScanParams)
15259{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15260 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15261 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
15262 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
15263 sizeof(WDI_UpdateScanParamsInfoType)) ;
15264 tWDA_ReqParams *pWdaParams ;
15265 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15266 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15267 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15268 if(NULL == wdiUpdateScanParamsInfoType)
15269 {
15270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15271 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15272 VOS_ASSERT(0);
15273 return VOS_STATUS_E_NOMEM;
15274 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15275 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15276 if ( NULL == pWdaParams )
15277 {
15278 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15279 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15280 VOS_ASSERT(0);
15281 vos_mem_free(wdiUpdateScanParamsInfoType);
15282 return VOS_STATUS_E_NOMEM;
15283 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15284 //
15285 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
15286 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15288 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
15289 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
15290 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]15291 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15292 pUpdateScanParams->b11dEnabled,
15293 pUpdateScanParams->b11dResolved,
15294 pUpdateScanParams->ucChannelCount,
15295 pUpdateScanParams->usPassiveMinChTime,
15296 pUpdateScanParams->usPassiveMaxChTime,
15297 pUpdateScanParams->usActiveMinChTime,
15298 pUpdateScanParams->usActiveMaxChTime,
15299 sizeof(tSirUpdateScanParams),
15300 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
15301
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15302 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
15303 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15304 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
15305 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15306 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
15307 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15308 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
15309 pUpdateScanParams->usActiveMaxChTime;
15310 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
15311 pUpdateScanParams->usActiveMinChTime;
15312 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
15313 pUpdateScanParams->usPassiveMaxChTime;
15314 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
15315 pUpdateScanParams->usPassiveMinChTime;
15316
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15317 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]15318 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
15319 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15320
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15321 for ( i = 0; i <
15322 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
15323 i++)
15324 {
15325 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15326 "Update Scan Parameters channel: %d",
15327 pUpdateScanParams->aChannels[i]);
15328
15329 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
15330 pUpdateScanParams->aChannels[i];
15331 }
15332
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15333 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
15334 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15335
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15336 /* Store Params pass it to WDI */
15337 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
15338 pWdaParams->pWdaContext = pWDA;
15339 /* Store param pointer as passed in by caller */
15340 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15341
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15342
15343
15344 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15345 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15346 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15347 if(IS_WDI_STATUS_FAILURE(status))
15348 {
15349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15350 "Failure in Update Scan Params EQ WDI API, free all the memory " );
15351 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15352 vos_mem_free(pWdaParams->wdaMsgParam);
15353 vos_mem_free(pWdaParams);
15354 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15355 return CONVERT_WDI2VOS_STATUS(status) ;
15356}
15357#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15358
15359#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
15360/*
15361 * FUNCTION: WDA_RoamOffloadScanReqCallback
15362 *
15363 */
15364void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
15365{
15366 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15367 vos_msg_t vosMsg;
15368 wpt_uint8 reason = 0;
15369
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]15370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15371 "<------ %s " ,__func__);
15372 if (NULL == pWdaParams)
15373 {
15374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15375 "%s: pWdaParams received NULL", __func__);
15376 VOS_ASSERT(0) ;
15377 return ;
15378 }
15379 if ( pWdaParams != NULL )
15380 {
15381 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
15382 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15383 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15384 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15385 }
15386 if ( pWdaParams->wdaMsgParam != NULL)
15387 {
15388 vos_mem_free(pWdaParams->wdaMsgParam);
15389 }
15390
15391 vos_mem_free(pWdaParams) ;
15392 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15393 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
15394 vosMsg.bodyptr = NULL;
15395 if (WDI_STATUS_SUCCESS != status)
15396 {
15397 reason = 0;
15398 }
15399 vosMsg.bodyval = reason;
15400 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15401 {
15402 /* free the mem and return */
15403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]15404 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]15405 }
15406
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15407 return ;
15408}
15409#endif
15410
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15411/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15412 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15413 *
15414 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15415void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15416{
15417 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15418
15419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15420 "<------ %s " ,__func__);
15421
15422 if(NULL == pWdaParams)
15423 {
15424 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15425 "%s: pWdaParams received NULL", __func__);
15426 VOS_ASSERT(0);
15427 return;
15428 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15429
15430 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15431 vos_mem_free(pWdaParams->wdaMsgParam);
15432 vos_mem_free(pWdaParams);
15433
15434 return;
15435}
15436/*
15437 * FUNCTION: WDA_SetPowerParamsReqCallback
15438 * Free memory.
15439 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
15440 */
15441void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
15442{
15443 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15444
15445 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15446 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15447
15448 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15449 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15450 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15451 "%s: pWdaParams received NULL", __func__);
15452 VOS_ASSERT(0);
15453 return;
15454 }
15455
15456 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15457 {
15458 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15459 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15460 vos_mem_free(pWdaParams);
15461 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15462
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]15463 return;
15464}
15465
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15466#ifdef WLAN_FEATURE_PACKET_FILTERING
15467/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15468 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15469 *
15470 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15471void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15472 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
15473 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15474{
15475 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15477 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15478 if(NULL == pWdaParams)
15479 {
15480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15481 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15482 VOS_ASSERT(0) ;
15483 return ;
15484 }
15485
15486 vos_mem_free(pWdaParams->wdaMsgParam) ;
15487 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15488 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15489 //print a msg, nothing else to do
15490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15491 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15492 return ;
15493}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15494/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15495 * FUNCTION: WDA_8023MulticastListReqCallback
15496 * Free memory.
15497 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
15498 */
15499void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
15500{
15501 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15502
15503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15504 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15505
15506 if(NULL == pWdaParams)
15507 {
15508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15509 "%s: pWdaParams received NULL", __func__);
15510 VOS_ASSERT(0);
15511 return;
15512 }
15513
15514 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15515 {
15516 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15517 vos_mem_free(pWdaParams->wdaMsgParam);
15518 vos_mem_free(pWdaParams);
15519 }
15520
15521 return;
15522}
15523/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15524 * FUNCTION: WDA_Process8023MulticastListReq
15525 * Request to WDI to add 8023 Multicast List
15526 */
15527VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
15528 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
15529{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15530 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15531 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
15532 tWDA_ReqParams *pWdaParams ;
15533 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15535 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15536 pwdiFltPktSetMcListReqParamsType =
15537 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
15538 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
15539 ) ;
15540 if(NULL == pwdiFltPktSetMcListReqParamsType)
15541 {
15542 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15543 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15544 return VOS_STATUS_E_NOMEM;
15545 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15546 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15547 if(NULL == pWdaParams)
15548 {
15549 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15550 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15551 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
15552 return VOS_STATUS_E_NOMEM;
15553 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15554
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15555 //
15556 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
15557 //
15558 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15559 pRcvFltMcAddrList->ulMulticastAddrCnt;
15560
15561 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
15562 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
15563 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
15564 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
15565
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15566 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
15567 {
15568 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
15569 &(pRcvFltMcAddrList->multicastAddr[i]),
15570 sizeof(tSirMacAddr));
15571 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15572 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
15573 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15574
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15575 /* Store Params pass it to WDI */
15576 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
15577 pWdaParams->pWdaContext = pWDA;
15578 /* Store param pointer as passed in by caller */
15579 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15580 status = WDI_8023MulticastListReq(
15581 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15582 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15583 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15584 if(IS_WDI_STATUS_FAILURE(status))
15585 {
15586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15587 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
15588 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15589 vos_mem_free(pWdaParams->wdaMsgParam);
15590 vos_mem_free(pWdaParams);
15591 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15592 return CONVERT_WDI2VOS_STATUS(status) ;
15593}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15594/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15595 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15596 *
15597 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15598void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15599 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
15600 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15601{
15602 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15603 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15604 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15605 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15606 if(NULL == pWdaParams)
15607 {
15608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15609 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15610 VOS_ASSERT(0) ;
15611 return ;
15612 }
15613
15614 vos_mem_free(pWdaParams->wdaMsgParam) ;
15615 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15616 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15617 //print a msg, nothing else to do
15618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15619 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15620 return ;
15621}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15622
15623/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15624 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
15625 * Free memory.
15626 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15627 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15628void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15629 void* pUserData)
15630{
15631 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15632
15633 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15634 "<------ %s, wdiStatus: %d",
15635 __func__, wdiStatus);
15636
15637 if (NULL == pWdaParams)
15638 {
15639 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15640 "%s: Invalid pWdaParams pointer", __func__);
15641 VOS_ASSERT(0);
15642 return;
15643 }
15644
15645 if (IS_WDI_STATUS_FAILURE(wdiStatus))
15646 {
15647 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15648 vos_mem_free(pWdaParams->wdaMsgParam);
15649 vos_mem_free(pWdaParams);
15650 }
15651
15652 return;
15653}
15654
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15655/*
15656 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
15657 * Request to WDI to set Receive Filters
15658 */
15659VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
15660 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
15661{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15662 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15663 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
15664 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
15665 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
15666 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
15667 tWDA_ReqParams *pWdaParams ;
15668 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15670 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15671 if(NULL == pwdiSetRcvPktFilterReqParamsType)
15672 {
15673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15674 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15675 VOS_ASSERT(0);
15676 return VOS_STATUS_E_NOMEM;
15677 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15678 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15679 if(NULL == pWdaParams)
15680 {
15681 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15682 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15683 VOS_ASSERT(0);
15684 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
15685 return VOS_STATUS_E_NOMEM;
15686 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15687 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
15688 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
15689 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
15690 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15691 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
15692 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
15693
15694 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
15695 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15696
15697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15698 "FID %d FT %d NParams %d CT %d",
15699 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
15700 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
15701 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
15702 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15703 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
15704 {
15705 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
15706 &pRcvPktFilterCfg->paramsData[i],
15707 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15709 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15710 pwdiSetRcvPktFilterReqParamsType->
15711 wdiPktFilterCfg.paramsData[i].protocolLayer,
15712 pwdiSetRcvPktFilterReqParamsType->
15713 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15715 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15716 pwdiSetRcvPktFilterReqParamsType->
15717 wdiPktFilterCfg.paramsData[i].dataOffset,
15718 pwdiSetRcvPktFilterReqParamsType->
15719 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15721 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15722 pwdiSetRcvPktFilterReqParamsType->
15723 wdiPktFilterCfg.paramsData[i].compareData[0],
15724 pwdiSetRcvPktFilterReqParamsType->
15725 wdiPktFilterCfg.paramsData[i].compareData[1],
15726 pwdiSetRcvPktFilterReqParamsType->
15727 wdiPktFilterCfg.paramsData[i].compareData[2],
15728 pwdiSetRcvPktFilterReqParamsType->
15729 wdiPktFilterCfg.paramsData[i].compareData[3],
15730 pwdiSetRcvPktFilterReqParamsType->
15731 wdiPktFilterCfg.paramsData[i].compareData[4],
15732 pwdiSetRcvPktFilterReqParamsType->
15733 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15735 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15736 pwdiSetRcvPktFilterReqParamsType->
15737 wdiPktFilterCfg.paramsData[i].dataMask[0],
15738 pwdiSetRcvPktFilterReqParamsType->
15739 wdiPktFilterCfg.paramsData[i].dataMask[1],
15740 pwdiSetRcvPktFilterReqParamsType->
15741 wdiPktFilterCfg.paramsData[i].dataMask[2],
15742 pwdiSetRcvPktFilterReqParamsType->
15743 wdiPktFilterCfg.paramsData[i].dataMask[3],
15744 pwdiSetRcvPktFilterReqParamsType->
15745 wdiPktFilterCfg.paramsData[i].dataMask[4],
15746 pwdiSetRcvPktFilterReqParamsType->
15747 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15748 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15749 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15750 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15751 /* Store Params pass it to WDI */
15752 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
15753 pWdaParams->pWdaContext = pWDA;
15754 /* Store param pointer as passed in by caller */
15755 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15756 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15757 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15758 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15759 if(IS_WDI_STATUS_FAILURE(status))
15760 {
15761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15762 "Failure in SetFilter(),free all the memory,status %d ",status);
15763 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15764 vos_mem_free(pWdaParams->wdaMsgParam);
15765 vos_mem_free(pWdaParams);
15766 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15767 return CONVERT_WDI2VOS_STATUS(status) ;
15768}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15769/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15770 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15771 *
15772 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15773void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15774 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
15775 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15776{
15777 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15778 tWDA_CbContext *pWDA;
15779 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
15780 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
15781 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
15782 tANI_U8 i;
15783 vos_msg_t vosMsg;
15784
15785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15786 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15787 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
15788
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15789 if(NULL == pRcvFltPktMatchCntRsp)
15790 {
15791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15792 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15793 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15794 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15795 return ;
15796 }
15797
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15798 if(NULL == pWdaParams)
15799 {
15800 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15801 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15802 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15803 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15804 return ;
15805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15806 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
15807 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15808 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
15809 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
15810
15811 /* Message Header */
15812 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15813 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
15814
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15815 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15816
15817 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
15818 {
15819 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
15820 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
15821 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15822 /* VOS message wrapper */
15823 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15824 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
15825 vosMsg.bodyval = 0;
15826 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15827 {
15828 /* free the mem and return */
15829 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
15830 }
15831
15832 vos_mem_free(pWdaParams->wdaMsgParam) ;
15833 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15834 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15835
15836 return;
15837}
15838/*
15839 * FUNCTION: WDA_FilterMatchCountReqCallback
15840 * Free memory and send RSP back to SME.
15841 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
15842 */
15843void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
15844{
15845 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15846 vos_msg_t vosMsg;
15847
15848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15849 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15850
15851 if(NULL == pWdaParams)
15852 {
15853 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15854 "%s: pWdaParams received NULL", __func__);
15855 VOS_ASSERT(0);
15856 return;
15857 }
15858
15859 /* VOS message wrapper */
15860 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15861 vosMsg.bodyptr = NULL;
15862 vosMsg.bodyval = 0;
15863
15864 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15865 {
15866 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15867 vos_mem_free(pWdaParams->wdaMsgParam);
15868 vos_mem_free(pWdaParams);
15869 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
15870 }
15871
15872 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15873}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15874/*
15875 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
15876 * Request to WDI to get PC Filter Match Count
15877 */
15878VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
15879{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15880 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15881 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
15882 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
15883 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15885 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15886 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
15887 {
15888 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15889 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15890 VOS_ASSERT(0);
15891 return VOS_STATUS_E_NOMEM;
15892 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15893 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15894 if(NULL == pWdaParams)
15895 {
15896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15897 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15898 VOS_ASSERT(0);
15899 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
15900 return VOS_STATUS_E_NOMEM;
15901 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15902
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15903 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
15904 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15905
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15906 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
15907 pRcvFltPktMatchRsp->bssId,
15908 sizeof(wpt_macAddr));
15909
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15910 /* Store Params pass it to WDI */
15911 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
15912 pWdaParams->pWdaContext = pWDA;
15913 /* Store param pointer as passed in by caller */
15914 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15915 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15916 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15917 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15918 if(IS_WDI_STATUS_FAILURE(status))
15919 {
15920 /* failure returned by WDI API */
15921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15922 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
15923 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15924 vos_mem_free(pWdaParams) ;
15925 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
15926 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
15927 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15928 return CONVERT_WDI2VOS_STATUS(status) ;
15929}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15930/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15931 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15932 *
15933 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15934void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15935 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
15936 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15937{
15938 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15939 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15940 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15941/* WDA_VOS_ASSERT(NULL != pWdaParams); */
15942 if(NULL == pWdaParams)
15943 {
15944 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15945 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15946 VOS_ASSERT(0) ;
15947 return ;
15948 }
15949
15950 vos_mem_free(pWdaParams->wdaMsgParam) ;
15951 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15952 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15953 //print a msg, nothing else to do
15954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15955 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15956 return ;
15957}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15958/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15959 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
15960 * Free memory.
15961 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
15962 */
15963void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15964{
15965 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15966
15967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15968 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15969
15970 if(NULL == pWdaParams)
15971 {
15972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15973 "%s: Invalid pWdaParams pointer", __func__);
15974 VOS_ASSERT(0);
15975 return;
15976 }
15977
15978 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15979 {
15980 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15981 vos_mem_free(pWdaParams->wdaMsgParam);
15982 vos_mem_free(pWdaParams);
15983 }
15984
15985 return;
15986}
15987/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15988 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
15989 * Request to WDI to clear Receive Filters
15990 */
15991VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
15992 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
15993{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15994 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15995 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
15996 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
15997 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15998 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15999 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16000 if(NULL == pwdiRcvFltPktClearReqParamsType)
16001 {
16002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16003 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16004 VOS_ASSERT(0);
16005 return VOS_STATUS_E_NOMEM;
16006 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16007 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16008 if(NULL == pWdaParams)
16009 {
16010 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16011 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16012 VOS_ASSERT(0);
16013 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
16014 return VOS_STATUS_E_NOMEM;
16015 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16016 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
16017 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16018 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
16019 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
16020 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
16021 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16022
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16023 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]16024 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16025 /* Store Params pass it to WDI */
16026 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
16027 pWdaParams->pWdaContext = pWDA;
16028 /* Store param pointer as passed in by caller */
16029 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16030 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]16031 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16032 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16033 if(IS_WDI_STATUS_FAILURE(status))
16034 {
16035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16036 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
16037 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]16038 vos_mem_free(pWdaParams->wdaMsgParam);
16039 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16040 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16041 return CONVERT_WDI2VOS_STATUS(status) ;
16042}
16043#endif // WLAN_FEATURE_PACKET_FILTERING
16044
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16045/*
16046 * FUNCTION: WDA_ProcessSetPowerParamsReq
16047 * Request to WDI to set power params
16048 */
16049VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
16050 tSirSetPowerParamsReq *pPowerParams)
16051{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]16052 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16053 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
16054 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16055 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16056 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16057 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16058 if(NULL == pwdiSetPowerParamsReqInfo)
16059 {
16060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16061 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16062 VOS_ASSERT(0);
16063 return VOS_STATUS_E_NOMEM;
16064 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16065 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16066 if(NULL == pWdaParams)
16067 {
16068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16069 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16070 VOS_ASSERT(0);
16071 vos_mem_free(pwdiSetPowerParamsReqInfo);
16072 return VOS_STATUS_E_NOMEM;
16073 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16074
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16075
16076 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
16077 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16078 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
16079 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16080 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
16081 pPowerParams->uListenInterval;
16082 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
16083 pPowerParams->uBcastMcastFilter;
16084 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
16085 pPowerParams->uEnableBET;
16086 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
16087 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]16088 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
16089 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16090 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
16091 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16092
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16093 /* Store Params pass it to WDI */
16094 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
16095 pWdaParams->pWdaContext = pWDA;
16096 /* Store param pointer as passed in by caller */
16097 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16098 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16099 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16100 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16101 if(IS_WDI_STATUS_FAILURE(status))
16102 {
16103 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16104 "Failure in Set power params REQ WDI API, free all the memory " );
16105 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16106 vos_mem_free(pWdaParams->wdaMsgParam);
16107 pWdaParams->wdaWdiApiMsgParam = NULL;
16108 pWdaParams->wdaMsgParam = NULL;
16109 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16110 return CONVERT_WDI2VOS_STATUS(status) ;
16111}
16112
16113/*
16114 * FUNCTION: WDA_SetTmLevelRspCallback
16115 * Set TM Level response
16116 */
16117void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
16118{
16119 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16120
16121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16122 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16123
16124 if(NULL == pWdaParams)
16125 {
16126 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16127 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16128 VOS_ASSERT(0) ;
16129 return ;
16130 }
16131
16132 /* Dose not need to send notification to upper layer
16133 * Just free allocated resources */
16134 if( pWdaParams != NULL )
16135 {
16136 if( pWdaParams->wdaWdiApiMsgParam != NULL )
16137 {
16138 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16139 }
16140 vos_mem_free(pWdaParams->wdaMsgParam) ;
16141 vos_mem_free(pWdaParams) ;
16142 }
16143}
16144
16145/*
16146 * FUNCTION: WDA_ProcessSetTmLevelReq
16147 * Set TM Level request
16148 */
16149VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
16150 tAniSetTmLevelReq *setTmLevelReq)
16151{
16152 WDI_Status status = WDI_STATUS_SUCCESS ;
16153 tWDA_ReqParams *pWdaParams ;
16154 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
16155 (WDI_SetTmLevelReqType *)vos_mem_malloc(
16156 sizeof(WDI_SetTmLevelReqType)) ;
16157 if(NULL == wdiSetTmLevelReq)
16158 {
16159 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16160 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16161 VOS_ASSERT(0);
16162 return VOS_STATUS_E_NOMEM;
16163 }
16164
16165 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16166 if(NULL == pWdaParams)
16167 {
16168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16169 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16170 VOS_ASSERT(0);
16171 vos_mem_free(wdiSetTmLevelReq);
16172 return VOS_STATUS_E_NOMEM;
16173 }
16174
16175 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16176 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16177
16178 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
16179 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
16180
16181 pWdaParams->pWdaContext = pWDA;
16182 pWdaParams->wdaMsgParam = setTmLevelReq;
16183 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
16184
16185 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
16186 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
16187
16188 if(IS_WDI_STATUS_FAILURE(status))
16189 {
16190 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]16191 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16192 vos_mem_free(pWdaParams->wdaMsgParam) ;
16193 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16194 vos_mem_free(pWdaParams) ;
16195 }
16196
16197 return CONVERT_WDI2VOS_STATUS(status) ;
16198}
16199
16200VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
16201 tpTxControlParams pTxCtrlParam)
16202{
16203 VOS_STATUS wdaStatus;
16204
16205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16206 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16207 if( pTxCtrlParam == NULL )
16208 {
16209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16210 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16211 return VOS_STATUS_E_FAILURE;
16212 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16213 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
16214 {
16215 wdaStatus = WDA_SuspendDataTx(pWDA);
16216 }
16217 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
16218 {
16219 wdaStatus = WDA_ResumeDataTx(pWDA);
16220 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16221 return wdaStatus;
16222}
16223
16224 /* FUNCTION WDA_featureCapsExchange
16225 * WDA API to invoke capability exchange between host and FW.
16226 */
16227void WDA_featureCapsExchange(v_PVOID_t pVosContext)
16228{
16229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16230 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16231 WDI_featureCapsExchangeReq( NULL, pVosContext);
16232}
16233
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]16234/* FUNCTION WDA_disableCapablityFeature
16235 * WDA API to diable Active mode offload in host.
16236 */
16237void WDA_disableCapablityFeature(tANI_U8 feature_index)
16238{
16239 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16240 "%s:enter", __func__ );
16241 WDI_disableCapablityFeature(feature_index);
16242}
16243
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16244 /* FUNCTION WDA_getHostWlanFeatCaps
16245 * Wrapper for WDI API, that will return if the feature (enum value).passed
16246 * to this API is supported or not in Host
16247 * return value
16248 * 0 - implies feature is NOT Supported
16249 * any non zero value - implies feature is SUPPORTED
16250 */
16251tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
16252{
16253 return WDI_getHostWlanFeatCaps(featEnumValue);
16254}
16255
16256 /* FUNCTION WDA_getFwWlanFeatCaps
16257 * Wrapper for WDI API, that will return if the feature (enum value).passed
16258 * to this API is supported or not in FW
16259 * return value
16260 * 0 - implies feature is NOT Supported
16261 * any non zero value - implies feature is SUPPORTED
16262 */
16263tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
16264{
16265 return WDI_getFwWlanFeatCaps(featEnumValue);
16266}
16267
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]16268
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16269/*
16270 * FUNCTION: WDA_shutdown
16271 * Shutdown WDA/WDI without handshaking with Riva.
16272 * Synchronous function.
16273 */
16274VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
16275{
16276 WDI_Status wdiStatus;
16277 //tANI_U8 eventIdx = 0;
16278 VOS_STATUS status = VOS_STATUS_SUCCESS;
16279 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16280 if (NULL == pWDA)
16281 {
16282 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16283 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16284 VOS_ASSERT(0);
16285 return VOS_STATUS_E_FAILURE;
16286 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16287 /* FTM mode stay START_STATE */
16288 if( (WDA_READY_STATE != pWDA->wdaState) &&
16289 (WDA_INIT_STATE != pWDA->wdaState) &&
16290 (WDA_START_STATE != pWDA->wdaState) )
16291 {
16292 VOS_ASSERT(0);
16293 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16294
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16295 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
16296 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16297 {
16298 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16299 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16300 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]16301 else
16302 {
16303 vos_event_destroy(&pWDA->ftmStopDoneEvent);
16304 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]16305
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16306 /* call WDI shutdown */
16307 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16308 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
16309 {
16310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16311 "error in WDA Stop" );
16312 status = VOS_STATUS_E_FAILURE;
16313 }
16314 /* WDI stop is synchrnous, shutdown is complete when it returns */
16315 pWDA->wdaState = WDA_STOP_STATE;
16316
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16317 /* shutdown should perform the stop & close actions. */
16318 /* Destroy the event */
16319 status = vos_event_destroy(&pWDA->txFrameEvent);
16320 if(!VOS_IS_STATUS_SUCCESS(status))
16321 {
16322 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16323 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16324 status = VOS_STATUS_E_FAILURE;
16325 }
16326 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
16327 if(!VOS_IS_STATUS_SUCCESS(status))
16328 {
16329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16330 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16331 status = VOS_STATUS_E_FAILURE;
16332 }
16333 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
16334 if(!VOS_IS_STATUS_SUCCESS(status))
16335 {
16336 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16337 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16338 status = VOS_STATUS_E_FAILURE;
16339 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16340 /* free WDA context */
16341 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
16342 if ( !VOS_IS_STATUS_SUCCESS(status) )
16343 {
16344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16345 "error in WDA close " );
16346 status = VOS_STATUS_E_FAILURE;
16347 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16348 return status;
16349}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16350
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16351/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16352 * FUNCTION: WDA_setNeedShutdown
16353 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16354 */
16355
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]16356void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16357{
16358 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16359 if(pWDA == NULL)
16360 {
16361 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16362 "Could not get the WDA Context pointer" );
16363 return;
16364 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16365 pWDA->needShutdown = TRUE;
16366}
16367/*
16368 * FUNCTION: WDA_needShutdown
16369 * WDA needs a shutdown
16370 */
16371
16372v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
16373{
16374 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]16375 if(pWDA == NULL)
16376 {
16377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16378 "Could not get the WDA Context pointer" );
16379 return 0;
16380 }
16381 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16382}
16383
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16384#ifdef WLAN_FEATURE_11AC
16385/*
16386 * FUNCTION: WDA_SetBeaconFilterReqCallback
16387 *
16388 */
16389void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
16390{
16391 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16393 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16394 if(NULL == pWdaParams)
16395 {
16396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16397 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16398 VOS_ASSERT(0) ;
16399 return ;
16400 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]16401
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16402 vos_mem_free(pWdaParams->wdaMsgParam) ;
16403 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16404 vos_mem_free(pWdaParams) ;
16405 /*
16406 * No respone required for SetBeaconFilter req so just free the request
16407 * param here
16408 */
16409
16410 return ;
16411}
16412
16413VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
16414 tUpdateVHTOpMode *pData)
16415{
16416 WDI_Status status = WDI_STATUS_SUCCESS ;
16417 tWDA_ReqParams *pWdaParams ;
16418 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
16419 sizeof(WDI_UpdateVHTOpMode)) ;
16420 if(NULL == wdiTemp)
16421 {
16422 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16423 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16424 VOS_ASSERT(0);
16425 return VOS_STATUS_E_NOMEM;
16426 }
16427 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16428 if(NULL == pWdaParams)
16429 {
16430 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16431 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]16432 VOS_ASSERT(0);
16433 vos_mem_free(wdiTemp);
16434 return VOS_STATUS_E_NOMEM;
16435 }
16436
16437 wdiTemp->opMode = pData->opMode;
16438 wdiTemp->staId = pData->staId;
16439
16440 pWdaParams->pWdaContext = pWDA;
16441 /* Store Req pointer, as this will be used for response */
16442 pWdaParams->wdaMsgParam = (void *)pData;
16443 /* store Params pass it to WDI */
16444 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
16445
16446 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
16447
16448 if(IS_WDI_STATUS_FAILURE(status))
16449 {
16450 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16451 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
16452 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
16453 vos_mem_free(pWdaParams->wdaMsgParam);
16454 vos_mem_free(pWdaParams);
16455 }
16456 return CONVERT_WDI2VOS_STATUS(status) ;
16457}
16458#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16459
16460/*==========================================================================
16461 FUNCTION WDA_TransportChannelDebug
16462
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]16463 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16464 Display Transport Channel debugging information
16465 User may request to display DXE channel snapshot
16466 Or if host driver detects any abnormal stcuk may display
16467
16468 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16469 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]16470 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16471 debugFlags : Enable stall detect features
16472 defined by WPAL_DeviceDebugFlags
16473 These features may effect
16474 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16475
16476 RETURN VALUE
16477 NONE
16478
16479===========================================================================*/
16480void WDA_TransportChannelDebug
16481(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16482 tpAniSirGlobal pMac,
16483 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16484 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16485)
16486{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16487 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16488 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16489}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]16490
16491/*==========================================================================
16492 FUNCTION WDA_SetEnableSSR
16493
16494 DESCRIPTION
16495 API to enable/disable SSR on WDI timeout
16496
16497 PARAMETERS
16498 enableSSR : enable/disable SSR
16499
16500 RETURN VALUE
16501 NONE
16502
16503===========================================================================*/
16504void WDA_SetEnableSSR(v_BOOL_t enableSSR)
16505{
16506 WDI_SetEnableSSR(enableSSR);
16507}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]16508
16509#ifdef FEATURE_WLAN_LPHB
16510/*
16511 * FUNCTION: WDA_LPHBconfRspCallback
16512 *
16513 */
16514void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
16515{
16516 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16517
16518 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16519 "<------ %s " ,__func__);
16520 if (NULL == pWdaParams)
16521 {
16522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16523 "%s: pWdaParams received NULL", __func__);
16524 VOS_ASSERT(0) ;
16525 return ;
16526 }
16527
16528 /* Do not need to send notification to upper layer
16529 * Just free allocated resources */
16530 if (pWdaParams != NULL)
16531 {
16532 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16533 {
16534 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16535 }
16536 vos_mem_free(pWdaParams->wdaMsgParam) ;
16537 vos_mem_free(pWdaParams) ;
16538 }
16539
16540 return;
16541}
16542
16543/*
16544 * FUNCTION: WDA_ProcessLPHBConfReq
16545 *
16546 */
16547VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
16548 tSirLPHBReq *pData)
16549{
16550 WDI_Status wdiStatus;
16551 tWDA_ReqParams *pWdaParams ;
16552
16553 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16554 "------> %s " , __func__);
16555
16556 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16557 if (NULL == pWdaParams)
16558 {
16559 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16560 "%s: VOS MEM Alloc Failure", __func__);
16561 VOS_ASSERT(0);
16562 vos_mem_free(pData);
16563 return VOS_STATUS_E_NOMEM;
16564 }
16565
16566 pWdaParams->pWdaContext = pWDA;
16567 pWdaParams->wdaMsgParam = (void *)pData;
16568 pWdaParams->wdaWdiApiMsgParam = NULL;
16569
16570 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
16571 if (WDI_STATUS_PENDING == wdiStatus)
16572 {
16573 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16574 "Pending received for %s:%d ", __func__, __LINE__);
16575 }
16576 else if (WDI_STATUS_SUCCESS != wdiStatus)
16577 {
16578 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16579 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
16580 vos_mem_free(pWdaParams->wdaMsgParam);
16581 vos_mem_free(pWdaParams);
16582 }
16583
16584 return CONVERT_WDI2VOS_STATUS(wdiStatus);
16585}
16586#endif /* FEATURE_WLAN_LPHB */
16587
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]16588void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
16589 void* pUserData)
16590{
16591 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
16592
16593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16594 "<------ %s " ,__func__);
16595 if (NULL == pBcnMissRateInfo)
16596 {
16597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16598 "%s: pWdaParams received NULL", __func__);
16599 VOS_ASSERT(0) ;
16600 return ;
16601 }
16602 if (pBcnMissRateInfo->callback)
16603 {
16604 pBcnMissRateInfo->callback(status, bcnMissRate,
16605 pBcnMissRateInfo->data);
16606 }
16607 vos_mem_free(pUserData);
16608
16609 return;
16610}
16611
16612v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
16613 tSirBcnMissRateReq *pData)
16614{
16615 WDI_Status wdiStatus;
16616 tSirBcnMissRateInfo *pBcnMissRateInfo;
16617
16618 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16619 "------> %s " , __func__);
16620
16621 pBcnMissRateInfo =
16622 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
16623 if (NULL == pBcnMissRateInfo)
16624 {
16625 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16626 "%s: VOS MEM Alloc Failure", __func__);
16627 VOS_ASSERT(0);
16628 vos_mem_free(pData);
16629 return;
16630 }
16631
16632 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
16633 pBcnMissRateInfo->data = pData->data;
16634
16635 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
16636 WDA_GetBcnMissRateCallback,
16637 pData->bssid);
16638 if (WDI_STATUS_PENDING == wdiStatus)
16639 {
16640 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16641 "Pending received for %s:%d ", __func__, __LINE__);
16642 }
16643 else if (WDI_STATUS_SUCCESS != wdiStatus)
16644 {
16645 if (pBcnMissRateInfo->callback)
16646 {
16647 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
16648 -1, pBcnMissRateInfo->data);
16649 }
16650 }
16651 vos_mem_free(pData);
16652}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16653
16654#ifdef WLAN_FEATURE_EXTSCAN
16655
16656/*==========================================================================
16657 FUNCTION WDA_EXTScanStartRspCallback
16658
16659 DESCRIPTION
16660 API to send EXTScan Start Response to HDD
16661
16662 PARAMETERS
16663 pEventData: Response from FW
16664 pUserData:
16665===========================================================================*/
16666void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
16667{
16668 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16669 tWDA_CbContext *pWDA = NULL;
16670 void *pCallbackContext;
16671 tpAniSirGlobal pMac;
16672
16673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16674 "%s:", __func__);
16675 if (NULL == pWdaParams)
16676 {
16677 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16678 "%s: pWdaParams received NULL", __func__);
16679 VOS_ASSERT(0);
16680 return;
16681 }
16682
16683 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16684
16685 if (NULL == pWDA)
16686 {
16687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16688 "%s: pWDA received NULL", __func__);
16689 VOS_ASSERT(0);
16690 goto error;
16691 }
16692
16693 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16694 if (NULL == pMac)
16695 {
16696 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16697 "%s:pMac is NULL", __func__);
16698 VOS_ASSERT(0);
16699 goto error;
16700 }
16701
16702 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16703
16704 if (pMac->sme.pEXTScanIndCb)
16705 {
16706 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
16707 pEventData);
16708 }
16709 else
16710 {
16711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16712 "%s:HDD callback is null", __func__);
16713 VOS_ASSERT(0);
16714 }
16715
16716error:
16717
16718 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16719 {
16720 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16721 }
16722 if (pWdaParams->wdaMsgParam != NULL)
16723 {
16724 vos_mem_free(pWdaParams->wdaMsgParam);
16725 }
16726 vos_mem_free(pWdaParams) ;
16727
16728 return;
16729}
16730
16731/*==========================================================================
16732 FUNCTION WDA_EXTScanStopRspCallback
16733
16734 DESCRIPTION
16735 API to send EXTScan Stop Response to HDD
16736
16737 PARAMETERS
16738 pEventData: Response from FW
16739 pUserData:
16740===========================================================================*/
16741void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
16742{
16743 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16744 tWDA_CbContext *pWDA = NULL;
16745 void *pCallbackContext;
16746 tpAniSirGlobal pMac;
16747
16748 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16749 "%s:", __func__);
16750 if (NULL == pWdaParams)
16751 {
16752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16753 "%s: pWdaParams received NULL", __func__);
16754 VOS_ASSERT(0);
16755 return;
16756 }
16757
16758 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16759
16760 if (NULL == pWDA)
16761 {
16762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16763 "%s: pWDA received NULL", __func__);
16764 VOS_ASSERT(0);
16765 goto error;
16766 }
16767
16768 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16769 if (NULL == pMac)
16770 {
16771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16772 "%s:pMac is NULL", __func__);
16773 VOS_ASSERT(0);
16774 goto error;
16775 }
16776 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16777
16778 if (pMac->sme.pEXTScanIndCb)
16779 {
16780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16781 "%s:HDD call back function called", __func__);
16782 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
16783 pEventData);
16784 }
16785 else
16786 {
16787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16788 "%s:HDD callback is null", __func__);
16789 VOS_ASSERT(0);
16790 }
16791
16792error:
16793
16794 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16795 {
16796 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16797 }
16798 if (pWdaParams->wdaMsgParam != NULL)
16799 {
16800 vos_mem_free(pWdaParams->wdaMsgParam);
16801 }
16802 vos_mem_free(pWdaParams) ;
16803
16804
16805 return;
16806}
16807
16808/*==========================================================================
16809 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
16810
16811 DESCRIPTION
16812 API to send EXTScan Get Cached Results Response to HDD
16813
16814 PARAMETERS
16815 pEventData: Response from FW
16816 pUserData:
16817===========================================================================*/
16818void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
16819{
16820 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16821 tWDA_CbContext *pWDA = NULL;
16822 void *pCallbackContext;
16823 tpAniSirGlobal pMac;
16824
16825 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16826 "%s: ", __func__);
16827 if (NULL == pWdaParams)
16828 {
16829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16830 "%s: pWdaParams received NULL", __func__);
16831 VOS_ASSERT(0);
16832 return;
16833 }
16834
16835 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16836
16837 if (NULL == pWDA)
16838 {
16839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16840 "%s: pWDA received NULL", __func__);
16841 VOS_ASSERT(0);
16842 goto error;
16843 }
16844
16845 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16846 if (NULL == pMac)
16847 {
16848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16849 "%s:pMac is NULL", __func__);
16850 VOS_ASSERT(0);
16851 goto error;
16852 }
16853
16854 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16855
16856 if (pMac->sme.pEXTScanIndCb)
16857 {
16858 pMac->sme.pEXTScanIndCb(pCallbackContext,
16859 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
16860 pEventData);
16861 }
16862 else
16863 {
16864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16865 "%s:HDD callback is null", __func__);
16866 VOS_ASSERT(0);
16867 }
16868
16869
16870error:
16871
16872 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16873 {
16874 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16875 }
16876 if (pWdaParams->wdaMsgParam != NULL)
16877 {
16878 vos_mem_free(pWdaParams->wdaMsgParam);
16879 }
16880 vos_mem_free(pWdaParams) ;
16881
16882 return;
16883}
16884
16885/*==========================================================================
16886 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
16887
16888 DESCRIPTION
16889 API to send EXTScan Get Capabilities Response to HDD
16890
16891 PARAMETERS
16892 pEventData: Response from FW
16893 pUserData:
16894===========================================================================*/
16895void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
16896{
16897 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16898 tWDA_CbContext *pWDA = NULL;
16899 void *pCallbackContext;
16900 tpAniSirGlobal pMac;
16901
16902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16903 "%s:", __func__);
16904 if (NULL == pWdaParams)
16905 {
16906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16907 "%s: pWdaParams received NULL", __func__);
16908 VOS_ASSERT(0);
16909 return;
16910 }
16911
16912 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16913
16914 if (NULL == pWDA)
16915 {
16916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16917 "%s: pWDA received NULL", __func__);
16918 VOS_ASSERT(0);
16919 goto error;
16920 }
16921
16922 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16923 if (NULL == pMac)
16924 {
16925 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16926 "%s:pMac is NULL", __func__);
16927 VOS_ASSERT(0);
16928 goto error;
16929 }
16930
16931 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16932
16933 if (pMac->sme.pEXTScanIndCb)
16934 {
16935 pMac->sme.pEXTScanIndCb(pCallbackContext,
16936 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
16937 pEventData);
16938 }
16939 else
16940 {
16941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16942 "%s:HDD callback is null", __func__);
16943 VOS_ASSERT(0);
16944 }
16945
16946
16947error:
16948
16949 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16950 {
16951 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16952 }
16953 if (pWdaParams->wdaMsgParam != NULL)
16954 {
16955 vos_mem_free(pWdaParams->wdaMsgParam);
16956 }
16957 vos_mem_free(pWdaParams) ;
16958
16959 return;
16960}
16961
16962/*==========================================================================
16963 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
16964
16965 DESCRIPTION
16966 API to send EXTScan Set BSSID Hotlist Response to HDD
16967
16968 PARAMETERS
16969 pEventData: Response from FW
16970 pUserData:
16971===========================================================================*/
16972void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16973{
16974 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16975 tWDA_CbContext *pWDA = NULL;
16976 void *pCallbackContext;
16977 tpAniSirGlobal pMac;
16978
16979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16980 "%s: ", __func__);
16981 if (NULL == pWdaParams)
16982 {
16983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16984 "%s: pWdaParams received NULL", __func__);
16985 VOS_ASSERT(0) ;
16986 return;
16987 }
16988
16989 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16990
16991 if (NULL == pWDA)
16992 {
16993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16994 "%s: pWDA received NULL", __func__);
16995 VOS_ASSERT(0);
16996 goto error;
16997 }
16998
16999 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17000 if (NULL == pMac)
17001 {
17002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17003 "%s:pMac is NULL", __func__);
17004 VOS_ASSERT(0);
17005 goto error;
17006 }
17007
17008 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17009
17010 if (pMac->sme.pEXTScanIndCb)
17011 {
17012 pMac->sme.pEXTScanIndCb(pCallbackContext,
17013 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
17014 pEventData);
17015 }
17016 else
17017 {
17018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17019 "%s:HDD callback is null", __func__);
17020 VOS_ASSERT(0);
17021 }
17022
17023
17024error:
17025
17026 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17027 {
17028 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17029 }
17030 if (pWdaParams->wdaMsgParam != NULL)
17031 {
17032 vos_mem_free(pWdaParams->wdaMsgParam);
17033 }
17034 vos_mem_free(pWdaParams) ;
17035
17036 return;
17037}
17038
17039/*==========================================================================
17040 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
17041
17042 DESCRIPTION
17043 API to send EXTScan ReSet BSSID Hotlist Response to HDD
17044
17045 PARAMETERS
17046 pEventData: Response from FW
17047 pUserData:
17048===========================================================================*/
17049void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
17050{
17051 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17052 tWDA_CbContext *pWDA = NULL;
17053 void *pCallbackContext;
17054 tpAniSirGlobal pMac;
17055
17056 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17057 "%s:", __func__);
17058 if (NULL == pWdaParams)
17059 {
17060 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17061 "%s: pWdaParams received NULL", __func__);
17062 VOS_ASSERT(0) ;
17063 return;
17064 }
17065
17066 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17067
17068 if (NULL == pWDA)
17069 {
17070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17071 "%s: pWDA received NULL", __func__);
17072 VOS_ASSERT(0);
17073 goto error;
17074 }
17075
17076 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17077 if (NULL == pMac)
17078 {
17079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17080 "%s:pMac is NULL", __func__);
17081 VOS_ASSERT(0);
17082 goto error;
17083 }
17084
17085 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17086
17087 if (pMac->sme.pEXTScanIndCb)
17088 {
17089 pMac->sme.pEXTScanIndCb(pCallbackContext,
17090 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
17091 pEventData);
17092 }
17093 else
17094 {
17095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17096 "%s:HDD callback is null", __func__);
17097 VOS_ASSERT(0);
17098 }
17099
17100
17101error:
17102
17103 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17104 {
17105 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17106 }
17107 if (pWdaParams->wdaMsgParam != NULL)
17108 {
17109 vos_mem_free(pWdaParams->wdaMsgParam);
17110 }
17111 vos_mem_free(pWdaParams) ;
17112
17113 return;
17114}
17115
17116/*==========================================================================
17117 FUNCTION WDA_EXTScanSetSignfRSSIChangeRspCallback
17118
17119 DESCRIPTION
17120 API to send EXTScan Set Significant RSSI Change RSP to HDD
17121
17122 PARAMETERS
17123 pEventData: Response from FW
17124 pUserData:
17125===========================================================================*/
17126void WDA_EXTScanSetSignfRSSIChangeRspCallback(void *pEventData, void* pUserData)
17127{
17128 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17129 tWDA_CbContext *pWDA = NULL;
17130 void *pCallbackContext;
17131 tpAniSirGlobal pMac;
17132
17133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17134 "%s:", __func__);
17135 if (NULL == pWdaParams)
17136 {
17137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17138 "%s: pWdaParams received NULL", __func__);
17139 VOS_ASSERT(0) ;
17140 return;
17141 }
17142
17143 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17144
17145 if (NULL == pWDA)
17146 {
17147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17148 "%s: pWDA received NULL", __func__);
17149 VOS_ASSERT(0);
17150 goto error;
17151 }
17152
17153 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17154 if (NULL == pMac)
17155 {
17156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17157 "%s:pMac is NULL", __func__);
17158 VOS_ASSERT(0);
17159 goto error;
17160 }
17161
17162 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17163
17164 if (pMac->sme.pEXTScanIndCb)
17165 {
17166 pMac->sme.pEXTScanIndCb(pCallbackContext,
17167 WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_RSP,
17168 pEventData);
17169 }
17170 else
17171 {
17172 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17173 "%s:HDD callback is null", __func__);
17174 VOS_ASSERT(0);
17175 }
17176
17177
17178error:
17179
17180 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17181 {
17182 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17183 }
17184 if (pWdaParams->wdaMsgParam != NULL)
17185 {
17186 vos_mem_free(pWdaParams->wdaMsgParam);
17187 }
17188 vos_mem_free(pWdaParams) ;
17189
17190 return;
17191}
17192
17193/*==========================================================================
17194 FUNCTION WDA_EXTScanResetSignfRSSIChangeRspCallback
17195
17196 DESCRIPTION
17197 API to send EXTScan Set Significant RSSI Change RSP to HDD
17198
17199 PARAMETERS
17200 pEventData: Response from FW
17201 pUserData:
17202===========================================================================*/
17203void WDA_EXTScanResetSignfRSSIChangeRspCallback(void *pEventData,
17204 void* pUserData)
17205{
17206 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17207 tWDA_CbContext *pWDA = NULL;
17208 void *pCallbackContext;
17209 tpAniSirGlobal pMac;
17210
17211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17212 "%s:", __func__);
17213 if (NULL == pWdaParams)
17214 {
17215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17216 "%s: pWdaParams received NULL", __func__);
17217 VOS_ASSERT(0) ;
17218 return;
17219 }
17220
17221 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
17222
17223 if (NULL == pWDA)
17224 {
17225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17226 "%s: pWDA received NULL", __func__);
17227 VOS_ASSERT(0);
17228 goto error;
17229 }
17230
17231 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
17232 if (NULL == pMac)
17233 {
17234 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17235 "%s:pMac is NULL", __func__);
17236 VOS_ASSERT(0);
17237 goto error;
17238 }
17239
17240 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
17241
17242 if (pMac->sme.pEXTScanIndCb)
17243 {
17244 pMac->sme.pEXTScanIndCb(pCallbackContext,
17245 WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_RSP,
17246 pEventData);
17247 }
17248 else
17249 {
17250 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17251 "%s:HDD callback is null", __func__);
17252 VOS_ASSERT(0);
17253 }
17254
17255
17256error:
17257
17258 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17259 {
17260 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17261 }
17262 if (pWdaParams->wdaMsgParam != NULL)
17263 {
17264 vos_mem_free(pWdaParams->wdaMsgParam);
17265 }
17266 vos_mem_free(pWdaParams) ;
17267
17268 return;
17269}
17270
17271/*==========================================================================
17272 FUNCTION WDA_ProcessEXTScanStartReq
17273
17274 DESCRIPTION
17275 API to send EXTScan Start Request to WDI
17276
17277 PARAMETERS
17278 pWDA: Pointer to WDA context
17279 wdaRequest: Pointer to EXTScan req parameters
17280===========================================================================*/
17281VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
17282 tSirEXTScanStartReqParams *wdaRequest)
17283{
17284 WDI_Status status = WDI_STATUS_SUCCESS;
17285 tWDA_ReqParams *pWdaParams;
17286
17287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17288 "%s: ", __func__);
17289 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17290 if (NULL == pWdaParams)
17291 {
17292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17293 "%s: VOS MEM Alloc Failure", __func__);
17294 VOS_ASSERT(0);
17295 return VOS_STATUS_E_NOMEM;
17296 }
17297 pWdaParams->pWdaContext = pWDA;
17298 pWdaParams->wdaMsgParam = wdaRequest;
17299 pWdaParams->wdaWdiApiMsgParam = NULL;
17300
17301 status = WDI_EXTScanStartReq((void *)wdaRequest,
17302 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
17303 (void *)pWdaParams);
17304 if (IS_WDI_STATUS_FAILURE(status))
17305 {
17306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17307 "Failure to request. Free all the memory " );
17308 vos_mem_free(pWdaParams->wdaMsgParam);
17309 vos_mem_free(pWdaParams);
17310 }
17311 return CONVERT_WDI2VOS_STATUS(status);
17312}
17313
17314/*==========================================================================
17315 FUNCTION WDA_ProcessEXTScanStopReq
17316
17317 DESCRIPTION
17318 API to send EXTScan Start Request to WDI
17319
17320 PARAMETERS
17321 pWDA: Pointer to WDA context
17322 wdaRequest: Pointer to EXTScan req parameters
17323===========================================================================*/
17324VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
17325 tSirEXTScanStopReqParams *wdaRequest)
17326{
17327 WDI_Status status = WDI_STATUS_SUCCESS;
17328 tWDA_ReqParams *pWdaParams;
17329
17330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17331 "%s:", __func__);
17332 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17333 if (NULL == pWdaParams)
17334 {
17335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17336 "%s: VOS MEM Alloc Failure", __func__);
17337 VOS_ASSERT(0);
17338 return VOS_STATUS_E_NOMEM;
17339 }
17340 pWdaParams->pWdaContext = pWDA;
17341 pWdaParams->wdaMsgParam = wdaRequest;
17342 pWdaParams->wdaWdiApiMsgParam = NULL;
17343
17344 status = WDI_EXTScanStopReq((void *)wdaRequest,
17345 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
17346 (void *)pWdaParams);
17347 if (IS_WDI_STATUS_FAILURE(status))
17348 {
17349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17350 "Failure to request. Free all the memory " );
17351 vos_mem_free(pWdaParams->wdaMsgParam);
17352 vos_mem_free(pWdaParams);
17353 }
17354 return CONVERT_WDI2VOS_STATUS(status);
17355}
17356
17357/*==========================================================================
17358 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
17359
17360 DESCRIPTION
17361 API to send EXTScan Get Cached Results Request to WDI
17362
17363 PARAMETERS
17364 pWDA: Pointer to WDA context
17365 wdaRequest: Pointer to EXTScan req parameters
17366===========================================================================*/
17367VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
17368 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
17369{
17370 WDI_Status status = WDI_STATUS_SUCCESS;
17371 tWDA_ReqParams *pWdaParams;
17372
17373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17374 "%s: ", __func__);
17375 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17376 if (NULL == pWdaParams)
17377 {
17378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17379 "%s: VOS MEM Alloc Failure", __func__);
17380 VOS_ASSERT(0);
17381 return VOS_STATUS_E_NOMEM;
17382 }
17383 pWdaParams->pWdaContext = pWDA;
17384 pWdaParams->wdaMsgParam = wdaRequest;
17385 pWdaParams->wdaWdiApiMsgParam = NULL;
17386
17387 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
17388 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
17389 (void *)pWdaParams);
17390 if (IS_WDI_STATUS_FAILURE(status))
17391 {
17392 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17393 "Failure to request. Free all the memory " );
17394 vos_mem_free(pWdaParams->wdaMsgParam);
17395 vos_mem_free(pWdaParams);
17396 }
17397 return CONVERT_WDI2VOS_STATUS(status);
17398}
17399
17400/*==========================================================================
17401 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
17402
17403 DESCRIPTION
17404 API to send EXTScan Get Capabilities Request to WDI
17405
17406 PARAMETERS
17407 pWDA: Pointer to WDA context
17408 wdaRequest: Pointer to EXTScan req parameters
17409===========================================================================*/
17410VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
17411 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
17412{
17413 WDI_Status status = WDI_STATUS_SUCCESS;
17414 tWDA_ReqParams *pWdaParams;
17415
17416 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17417 "%s:", __func__);
17418 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17419 if (NULL == pWdaParams)
17420 {
17421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17422 "%s: VOS MEM Alloc Failure", __func__);
17423 VOS_ASSERT(0);
17424 return VOS_STATUS_E_NOMEM;
17425 }
17426 pWdaParams->pWdaContext = pWDA;
17427 pWdaParams->wdaMsgParam = wdaRequest;
17428 pWdaParams->wdaWdiApiMsgParam = NULL;
17429
17430 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
17431 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
17432 (void *)pWdaParams);
17433 if (IS_WDI_STATUS_FAILURE(status))
17434 {
17435 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17436 "Failure to request. Free all the memory " );
17437 vos_mem_free(pWdaParams->wdaMsgParam);
17438 vos_mem_free(pWdaParams);
17439 }
17440 return CONVERT_WDI2VOS_STATUS(status);
17441}
17442
17443/*==========================================================================
17444 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
17445
17446 DESCRIPTION
17447 API to send Set BSSID Hotlist Request to WDI
17448
17449 PARAMETERS
17450 pWDA: Pointer to WDA context
17451 wdaRequest: Pointer to EXTScan req parameters
17452===========================================================================*/
17453VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17454 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
17455{
17456 WDI_Status status = WDI_STATUS_SUCCESS;
17457 tWDA_ReqParams *pWdaParams;
17458
17459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17460 "%s: ", __func__);
17461 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17462 if (NULL == pWdaParams)
17463 {
17464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17465 "%s: VOS MEM Alloc Failure", __func__);
17466 VOS_ASSERT(0);
17467 return VOS_STATUS_E_NOMEM;
17468 }
17469 pWdaParams->pWdaContext = pWDA;
17470 pWdaParams->wdaMsgParam = wdaRequest;
17471 pWdaParams->wdaWdiApiMsgParam = NULL;
17472
17473 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
17474 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
17475 (void *)pWdaParams);
17476 if (IS_WDI_STATUS_FAILURE(status))
17477 {
17478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17479 "Failure to request. Free all the memory " );
17480 vos_mem_free(pWdaParams->wdaMsgParam);
17481 vos_mem_free(pWdaParams);
17482 }
17483 return CONVERT_WDI2VOS_STATUS(status);
17484}
17485
17486/*==========================================================================
17487 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
17488
17489 DESCRIPTION
17490 API to send Reset BSSID Hotlist Request to WDI
17491
17492 PARAMETERS
17493 pWDA: Pointer to WDA context
17494 wdaRequest: Pointer to EXTScan req parameters
17495===========================================================================*/
17496VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17497 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
17498{
17499 WDI_Status status = WDI_STATUS_SUCCESS;
17500 tWDA_ReqParams *pWdaParams;
17501
17502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17503 "%s:", __func__);
17504 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17505 if (NULL == pWdaParams)
17506 {
17507 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17508 "%s: VOS MEM Alloc Failure", __func__);
17509 VOS_ASSERT(0);
17510 return VOS_STATUS_E_NOMEM;
17511 }
17512 pWdaParams->pWdaContext = pWDA;
17513 pWdaParams->wdaMsgParam = wdaRequest;
17514 pWdaParams->wdaWdiApiMsgParam = NULL;
17515
17516 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
17517 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
17518 (void *)pWdaParams);
17519 if (IS_WDI_STATUS_FAILURE(status))
17520 {
17521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17522 "Failure to request. Free all the memory " );
17523 vos_mem_free(pWdaParams->wdaMsgParam);
17524 vos_mem_free(pWdaParams);
17525 }
17526 return CONVERT_WDI2VOS_STATUS(status);
17527}
17528
17529/*==========================================================================
17530 FUNCTION WDA_ProcessEXTScanSetSignfRSSIChangeReq
17531
17532 DESCRIPTION
17533 API to send Set Significant RSSI Change Request to WDI
17534
17535 PARAMETERS
17536 pWDA: Pointer to WDA context
17537 wdaRequest: Pointer to EXTScan req parameters
17538===========================================================================*/
17539VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17540 tSirEXTScanSetSignificantChangeReqParams *wdaRequest)
17541{
17542 WDI_Status status = WDI_STATUS_SUCCESS;
17543 tWDA_ReqParams *pWdaParams;
17544
17545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17546 "%s: ", __func__);
17547 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17548 if (NULL == pWdaParams)
17549 {
17550 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17551 "%s: VOS MEM Alloc Failure", __func__);
17552 VOS_ASSERT(0);
17553 return VOS_STATUS_E_NOMEM;
17554 }
17555 pWdaParams->pWdaContext = pWDA;
17556 pWdaParams->wdaMsgParam = wdaRequest;
17557 pWdaParams->wdaWdiApiMsgParam = NULL;
17558
17559 status = WDI_EXTScanSetSignfRSSIChangeReq((void *)wdaRequest,
17560 (WDI_EXTScanSetSignfRSSIChangeRspCb)WDA_EXTScanSetSignfRSSIChangeRspCallback,
17561 (void *)pWdaParams);
17562 if (IS_WDI_STATUS_FAILURE(status))
17563 {
17564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17565 "Failure to request. Free all the memory " );
17566 vos_mem_free(pWdaParams->wdaMsgParam);
17567 vos_mem_free(pWdaParams);
17568 }
17569 return CONVERT_WDI2VOS_STATUS(status);
17570}
17571
17572/*==========================================================================
17573 FUNCTION WDA_ProcessEXTScanResetSignfRSSIChangeReq
17574
17575 DESCRIPTION
17576 API to send Reset Significant RSSI Change Request to WDI
17577
17578 PARAMETERS
17579 pWDA: Pointer to WDA context
17580 wdaRequest: Pointer to EXTScan req parameters
17581===========================================================================*/
17582VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17583 tSirEXTScanResetSignificantChangeReqParams *wdaRequest)
17584{
17585 WDI_Status status = WDI_STATUS_SUCCESS;
17586 tWDA_ReqParams *pWdaParams;
17587
17588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17589 "%s:", __func__);
17590 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17591 if (NULL == pWdaParams)
17592 {
17593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17594 "%s: VOS MEM Alloc Failure", __func__);
17595 VOS_ASSERT(0);
17596 return VOS_STATUS_E_NOMEM;
17597 }
17598 pWdaParams->pWdaContext = pWDA;
17599 pWdaParams->wdaMsgParam = wdaRequest;
17600 pWdaParams->wdaWdiApiMsgParam = NULL;
17601
17602 status = WDI_EXTScanResetSignfRSSIChangeReq((void *)wdaRequest,
17603 (WDI_EXTScanResetSignfRSSIChangeRspCb)
17604 WDA_EXTScanResetSignfRSSIChangeRspCallback,
17605 (void *)pWdaParams);
17606 if (IS_WDI_STATUS_FAILURE(status))
17607 {
17608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17609 "Failure to request. Free all the memory " );
17610 vos_mem_free(pWdaParams->wdaMsgParam);
17611 vos_mem_free(pWdaParams);
17612 }
17613 return CONVERT_WDI2VOS_STATUS(status);
17614}
17615#endif /* WLAN_FEATURE_EXTSCAN */
17616
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]17617#ifdef WLAN_FEATURE_LINK_LAYER_STATS
17618
17619/*==========================================================================
17620 FUNCTION WDA_LLStatsSetRspCallback
17621
17622 DESCRIPTION
17623 API to process set link layer statistics response from FW
17624
17625 PARAMETERS
17626 pRsp: Pointer to set link layer statistics response
17627 pUserData: Pointer to user data
17628
17629 RETURN VALUE
17630 NONE
17631
17632===========================================================================*/
17633void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
17634{
17635 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17636
17637
17638 if (NULL == pWdaParams)
17639 {
17640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17641 "%s: pWdaParams received NULL", __func__);
17642 VOS_ASSERT(0) ;
17643 return ;
17644 }
17645
17646 /* Do not need to send notification to upper layer
17647 * Just free allocated resources */
17648 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17649 {
17650 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17651 }
17652 if (pWdaParams->wdaMsgParam != NULL)
17653 {
17654 vos_mem_free(pWdaParams->wdaMsgParam);
17655 }
17656 vos_mem_free(pWdaParams) ;
17657
17658 return;
17659}
17660
17661/*==========================================================================
17662 FUNCTION WDA_ProcessLLStatsSetReq
17663
17664 DESCRIPTION
17665 API to send Set Link Layer Stats request to WDI
17666
17667 PARAMETERS
17668 pWDA: Pointer to WDA context
17669 wdaRequest: Pointer to set Link Layer Stats req parameters
17670===========================================================================*/
17671VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
17672 tSirLLStatsSetReq *wdaRequest)
17673{
17674 WDI_Status status = WDI_STATUS_SUCCESS;
17675 tWDA_ReqParams *pWdaParams;
17676
17677 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17678 if (NULL == pWdaParams)
17679 {
17680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17681 "%s: VOS MEM Alloc Failure", __func__);
17682 VOS_ASSERT(0);
17683 return VOS_STATUS_E_NOMEM;
17684 }
17685 pWdaParams->pWdaContext = pWDA;
17686 pWdaParams->wdaMsgParam = wdaRequest;
17687 pWdaParams->wdaWdiApiMsgParam = NULL;
17688
17689 status = WDI_LLStatsSetReq((void *)wdaRequest,
17690 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
17691 (void *)pWdaParams);
17692 if (IS_WDI_STATUS_FAILURE(status))
17693 {
17694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17695 "Failure to request. Free all the memory " );
17696 vos_mem_free(pWdaParams->wdaMsgParam);
17697 vos_mem_free(pWdaParams);
17698 }
17699 return CONVERT_WDI2VOS_STATUS(status);
17700}
17701
17702/*==========================================================================
17703 FUNCTION WDA_LLStatsGetRspCallback
17704
17705 DESCRIPTION
17706 API to process get link layer statistics response from FW
17707
17708 PARAMETERS
17709 pRsp: Pointer to get link layer statistics response
17710 pUserData: Pointer to user data
17711
17712 RETURN VALUE
17713 NONE
17714
17715===========================================================================*/
17716void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
17717{
17718 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17719
17720 if (NULL == pWdaParams)
17721 {
17722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17723 "%s: pWdaParams received NULL", __func__);
17724 VOS_ASSERT(0) ;
17725 return ;
17726 }
17727
17728 /* Do not need to send notification to upper layer
17729 * Just free allocated resources */
17730 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17731 {
17732 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17733 }
17734 if (pWdaParams->wdaMsgParam != NULL)
17735 {
17736 vos_mem_free(pWdaParams->wdaMsgParam);
17737 }
17738 vos_mem_free(pWdaParams) ;
17739
17740 return;
17741}
17742
17743/*==========================================================================
17744 FUNCTION WDA_ProcessLLStatsGetReq
17745
17746 DESCRIPTION
17747 API to send Get Link Layer Stats request to WDI
17748
17749 PARAMETERS
17750 pWDA: Pointer to WDA context
17751 wdaRequest: Pointer to get Link Layer Stats req parameters
17752===========================================================================*/
17753VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
17754 tSirLLStatsGetReq *wdaRequest)
17755{
17756 WDI_Status status = WDI_STATUS_SUCCESS;
17757 tWDA_ReqParams *pWdaParams;
17758
17759 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17760 if (NULL == pWdaParams)
17761 {
17762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17763 "%s: VOS MEM Alloc Failure", __func__);
17764 VOS_ASSERT(0);
17765 return VOS_STATUS_E_NOMEM;
17766 }
17767 pWdaParams->pWdaContext = pWDA;
17768 pWdaParams->wdaMsgParam = wdaRequest;
17769 pWdaParams->wdaWdiApiMsgParam = NULL;
17770
17771 status = WDI_LLStatsGetReq((void *) wdaRequest,
17772 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
17773 (void *)pWdaParams);
17774 if (IS_WDI_STATUS_FAILURE(status))
17775 {
17776 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17777 "Failure to request. Free all the memory " );
17778 vos_mem_free(pWdaParams->wdaMsgParam);
17779 vos_mem_free(pWdaParams);
17780 }
17781 return CONVERT_WDI2VOS_STATUS(status);
17782}
17783
17784/*==========================================================================
17785 FUNCTION WDA_LLStatsClearRspCallback
17786
17787 DESCRIPTION
17788 API to process clear link layer statistics response from FW
17789
17790 PARAMETERS
17791 pRsp: Pointer to clear link layer statistics response
17792 pUserData: Pointer to user data
17793
17794 RETURN VALUE
17795 NONE
17796
17797===========================================================================*/
17798void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
17799{
17800 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17801
17802
17803 if (NULL == pWdaParams)
17804 {
17805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17806 "%s: pWdaParams received NULL", __func__);
17807 VOS_ASSERT(0) ;
17808 return ;
17809 }
17810 /* Do not need to send notification to upper layer
17811 * Just free allocated resources */
17812 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17813 {
17814 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17815 }
17816 if (pWdaParams->wdaMsgParam != NULL)
17817 {
17818 vos_mem_free(pWdaParams->wdaMsgParam);
17819 }
17820 vos_mem_free(pWdaParams) ;
17821 return;
17822}
17823
17824/*==========================================================================
17825 FUNCTION WDA_ProcessLLStatsClearReq
17826
17827 DESCRIPTION
17828 API to send Clear Link Layer Stats request to WDI
17829
17830 PARAMETERS
17831 pWDA: Pointer to WDA context
17832 wdaRequest: Pointer to earLink Layer Stats req
17833===========================================================================*/
17834VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
17835 tSirLLStatsClearReq *wdaRequest)
17836{
17837 WDI_Status status = WDI_STATUS_SUCCESS;
17838 tWDA_ReqParams *pWdaParams;
17839
17840 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17841 if (NULL == pWdaParams)
17842 {
17843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17844 "%s: VOS MEM Alloc Failure", __func__);
17845 VOS_ASSERT(0);
17846 return VOS_STATUS_E_NOMEM;
17847 }
17848 pWdaParams->pWdaContext = pWDA;
17849 pWdaParams->wdaMsgParam = wdaRequest;
17850 pWdaParams->wdaWdiApiMsgParam = NULL;
17851
17852 status = WDI_LLStatsClearReq((void *) wdaRequest,
17853 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
17854 (void *)pWdaParams);
17855 if (IS_WDI_STATUS_FAILURE(status))
17856 {
17857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17858 "Failure to request. Free all the memory " );
17859 vos_mem_free(pWdaParams->wdaMsgParam);
17860 vos_mem_free(pWdaParams);
17861 }
17862 return CONVERT_WDI2VOS_STATUS(status);
17863}
17864
17865#endif /* WLAN_FEATURE_LINK_LAYER_STATS */