Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / a7f454da76919c9281b19947aa02d9d95ebfff9d / . / CORE / WDA / src / wlan_qct_wda.c
blob: 8e534778d3a19bc62ca1b42a152a7eba5f1ab4d9 [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]2 * Copyright (c) 2012-2014 The Linux Foundation. All rights reserved.
3 *
4 * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
5 *
6 *
7 * Permission to use, copy, modify, and/or distribute this software for
8 * any purpose with or without fee is hereby granted, provided that the
9 * above copyright notice and this permission notice appear in all
10 * copies.
11 *
12 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
13 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
14 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
15 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
16 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
17 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
18 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
19 * PERFORMANCE OF THIS SOFTWARE.
20 */
21
22/*
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame^]23 * This file was originally distributed by Qualcomm Atheros, Inc.
24 * under proprietary terms before Copyright ownership was assigned
25 * to the Linux Foundation.
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]26 */
27
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]28
Kiet Lama7f454d2014-07-24 12:04:06 -0700[diff] [blame^]29
30
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]31/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]32 W L A N _ Q C T _ WDA . C
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]33 OVERVIEW:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]34 This software unit holds the implementation of the WLAN Transport Layer.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]35 The functions externalized by this module are to be called ONLY by other
36 WLAN modules that properly register with the Transport Layer initially.
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]37 DEPENDENCIES:
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]38 Are listed for each API below.
39
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]40 Copyright (c) 2010-2011 QUALCOMM Incorporated.
41 All Rights Reserved.
42 Qualcomm Confidential and Proprietary
43===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]44/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]45 EDIT HISTORY FOR FILE
46
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]47 This section contains comments describing changes made to the module.
48 Notice that changes are listed in reverse chronological order.
49
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]50 $Header$$DateTime$$Author$
51
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]52 when who what, where, why
53---------- --- -------------------------------------------------
5410/05/2011 haparna Adding support for Keep Alive Feature
552010-12-30 smiryala UMAC convergence changes
562010-08-19 adwivedi WLAN DAL AL(WDA) layer for Prima
57===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]58#include "vos_mq.h"
59#include "vos_api.h"
60#include "vos_packet.h"
61#include "vos_nvitem.h"
62#include "sirApi.h"
63#include "wlan_qct_pal_packet.h"
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]64#include "wlan_qct_pal_device.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]65#include "wlan_qct_wda.h"
66#include "wlan_qct_wda_msg.h"
67#include "wlan_qct_wdi_cfg.h"
68#include "wlan_qct_wdi.h"
69#include "wlan_qct_wdi_ds.h"
70#include "wlan_hal_cfg.h"
71/**********************/
72#include "wniApi.h"
73#include "cfgApi.h"
74#include "limApi.h"
75#include "wlan_qct_tl.h"
76#include "wlan_qct_tli_ba.h"
77#include "limUtils.h"
78#include "btcApi.h"
79#include "vos_sched.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]80#include "pttMsgApi.h"
81#include "wlan_qct_sys.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]82/* Used MACRO's */
83/* Get WDA context from vOSS module */
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]84#define WDA_2_4_GHZ_MAX_FREQ 3000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]85#define VOS_GET_WDA_CTXT(a) vos_get_context(VOS_MODULE_ID_WDA, a)
86#define VOS_GET_MAC_CTXT(a) vos_get_context(VOS_MODULE_ID_PE, a)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]87#define WDA_BA_TX_FRM_THRESHOLD (5)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]88#define CONVERT_WDI2SIR_STATUS(x) \
89 ((WDI_STATUS_SUCCESS != (x)) ? eSIR_FAILURE : eSIR_SUCCESS)
90
91#define IS_WDI_STATUS_FAILURE(status) \
92 ((WDI_STATUS_SUCCESS != (status)) && (WDI_STATUS_PENDING != (status)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]93#define CONVERT_WDI2VOS_STATUS(x) \
94 ((IS_WDI_STATUS_FAILURE(x)) ? VOS_STATUS_E_FAILURE : VOS_STATUS_SUCCESS)
95
96/* macro's for acessing TL API/data structures */
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]97#define WDA_TL_GET_STA_STATE(a, b, c) WLANTL_GetSTAState(a, b, c)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]98#define WDA_TL_GET_TX_PKTCOUNT(a, b, c, d) WLANTL_GetTxPktCount(a, b, c, d)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]99#define WDA_GET_BA_TXFLAG(a, b, c) \
100 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) & (1 << (c)))
101
102#define WDA_SET_BA_TXFLAG(a, b, c) \
103 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) |= (1 << (c)))
104
105#define WDA_CLEAR_BA_TXFLAG(a, b, c) \
106 (((a)->wdaStaInfo[b].ucUseBaBitmap) &= ~(1 << c))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]107#define WDA_TL_BA_SESSION_ADD(a, b, c, d, e, f, g) \
108 WLANTL_BaSessionAdd(a, b, c, d, e, f, g)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]109/* timer related Macros */
110#define WDA_CREATE_TIMER(a, b, c, d, e, f, g) \
111 tx_timer_create(a, b, c, d, e, f, g)
112#define WDA_START_TIMER(a) tx_timer_activate(a)
113#define WDA_STOP_TIMER(a) tx_timer_deactivate(a)
114#define WDA_DESTROY_TIMER(a) tx_timer_delete(a)
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]115#define WDA_WDI_START_TIMEOUT (WDI_RESPONSE_TIMEOUT + 5000)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]116
117#define WDA_LAST_POLLED_THRESHOLD(a, curSta, tid) \
118 ((a)->wdaStaInfo[curSta].framesTxed[tid] + WDA_BA_TX_FRM_THRESHOLD)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]119#define WDA_BA_MAX_WINSIZE (64)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]120#define WDA_INVALID_KEY_INDEX 0xFF
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]121#define WDA_NUM_PWR_SAVE_CFG 11
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]122#define WDA_TX_COMPLETE_TIME_OUT_VALUE 1000
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]123#define WDA_TRAFFIC_STATS_TIME_OUT_VALUE 1000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]124
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]125#define WDA_MAX_RETRIES_TILL_RING_EMPTY 1000 /* MAX 10000 msec = 10 seconds wait */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]126
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]127#define WDA_WAIT_MSEC_TILL_RING_EMPTY 10 /* 10 msec wait per cycle */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]128#define WDA_IS_NULL_MAC_ADDRESS(mac_addr) \
129 ((mac_addr[0] == 0x00) && (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) &&\
130 (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) && (mac_addr[3] == 0x00))
131
132#define WDA_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
133#define WDA_MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]134#define WDA_DUMPCMD_WAIT_TIMEOUT 10000
135
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]136/* extern declarations */
137extern void vos_WDAComplete_cback(v_PVOID_t pVosContext);
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]138extern wpt_uint8 WDI_GetActiveSessionsCount (void *pWDICtx, wpt_macAddr macBSSID, wpt_boolean skipBSSID);
139
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]140/* forward declarations */
141void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
142 void *pBodyptr, tANI_U32 bodyVal) ;
143VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
144 WDI_StartReqParamsType *wdiStartParams ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]145VOS_STATUS WDA_wdiCompleteCB(v_PVOID_t pVosContext) ;
146VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams);
147
148extern v_BOOL_t sys_validateStaConfig( void *pImage, unsigned long cbFile,
149 void **ppStaConfig, v_SIZE_t *pcbStaConfig ) ;
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]150void processCfgDownloadReq(tpAniSirGlobal pMac) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]151void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
152 WDI_ConfigBSSReqInfoType *wdiBssParams, tAddBssParams *wdaBssParams) ;
153void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
154 WDI_ConfigStaReqInfoType *wdiStaParams, tAddStaParams *wdaStaParams) ;
155void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
156 void* pUserData ) ;
157static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA) ;
158static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA);
159void WDA_BaCheckActivity(tWDA_CbContext *pWDA) ;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]160void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]161void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams, void* pUserData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]162#ifdef WLAN_FEATURE_VOWIFI_11R
163VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA, tAggrAddTsParams *pAggrAddTsReqParams);
164#endif /* WLAN_FEATURE_VOWIFI_11R */
165
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]166void WDA_TimerHandler(v_VOID_t *pWDA, tANI_U32 timerInfo) ;
167void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pContext) ;
168VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]169#ifdef FEATURE_WLAN_SCAN_PNO
170static VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA, tSirPNOScanReq *pPNOScanReqParams);
171static VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA, tSirSetRSSIFilterReq* pRssiFilterParams);
172static VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA, tSirUpdateScanParams *pUpdateScanParams);
173#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]174#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]175VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,tSirRoamOffloadScanReq *pRoamOffloadScanReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]176void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData);
177void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType);
178void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType);
179#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]180#ifdef WLAN_FEATURE_PACKET_FILTERING
181static VOS_STATUS WDA_Process8023MulticastListReq (
182 tWDA_CbContext *pWDA,
183 tSirRcvFltMcAddrList *pRcvFltMcAddrLis
184 );
185static VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (
186 tWDA_CbContext *pWDA,
187 tSirRcvPktFilterCfgType *pRcvPktFilterCfg
188 );
189static VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (
190 tWDA_CbContext *pWDA,
191 tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp
192 );
193static VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (
194 tWDA_CbContext *pWDA,
195 tSirRcvFltPktClearParam *pRcvFltPktClearParam
196 );
197#endif // WLAN_FEATURE_PACKET_FILTERING
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]198VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA, tSirSetPowerParamsReq *pPowerParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]199static VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
200 tpTxControlParams pTxCtrlParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]201VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
202 v_U8_t *pDefaultKeyId,
203 v_U8_t *pNumKeys,
204 WDI_KeysType *pWdiKeys );
205
206#ifdef WLAN_FEATURE_GTK_OFFLOAD
207static VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA, tpSirGtkOffloadParams pGtkOffloadParams);
208static VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA, tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp);
209#endif // WLAN_FEATURE_GTK_OFFLOAD
210
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]211v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
212 tSirBcnMissRateReq *pData);
213
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]214VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
215 tAniSetTmLevelReq *setTmLevelReq);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]216#ifdef WLAN_FEATURE_11AC
217VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
218 tUpdateVHTOpMode *pData);
219#endif
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]220
221#ifdef FEATURE_WLAN_LPHB
222VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
223 tSirLPHBReq *pData);
224#endif /* FEATURE_WLAN_LPHB */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]225
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]226#ifdef WLAN_FEATURE_EXTSCAN
227VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
228 tSirEXTScanStartReqParams *wdaRequest);
229VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
230 tSirEXTScanStopReqParams *wdaRequest);
231VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
232 tSirEXTScanGetCachedResultsReqParams *wdaRequest);
233VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
234 tSirGetEXTScanCapabilitiesReqParams *wdaRequest);
235VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
236 tSirEXTScanSetBssidHotListReqParams *wdaRequest);
237VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
238 tSirEXTScanResetBssidHotlistReqParams *wdaRequest);
239VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
240 tSirEXTScanSetSignificantChangeReqParams *wdaRequest);
241VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
242 tSirEXTScanResetSignificantChangeReqParams *wdaRequest);
243#endif /* WLAN_FEATURE_EXTSCAN */
244
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]245#ifdef WLAN_FEATURE_LINK_LAYER_STATS
246VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
247 tSirLLStatsSetReq *wdaRequest);
248
249VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
250 tSirLLStatsGetReq *wdaRequest);
251
252VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
253 tSirLLStatsClearReq *wdaRequest);
254#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]255/*
256 * FUNCTION: WDA_open
257 * Allocate the WDA context
258 */
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]259VOS_STATUS WDA_open(v_PVOID_t pVosContext, v_PVOID_t devHandle,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]260 tMacOpenParameters *pMacParams )
261{
262 tWDA_CbContext *wdaContext;
263 VOS_STATUS status;
264 WDI_DeviceCapabilityType wdiDevCapability = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]265 /* Allocate WDA context */
266 status = vos_alloc_context(pVosContext, VOS_MODULE_ID_WDA,
267 (v_VOID_t **)&wdaContext, sizeof(tWDA_CbContext)) ;
268 if(!VOS_IS_STATUS_SUCCESS(status))
269 {
270 return VOS_STATUS_E_NOMEM;
271 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]272 /*__asm int 3;*/
273 vos_mem_zero(wdaContext,sizeof(tWDA_CbContext));
274
275 /* Initialize data structures */
276 wdaContext->pVosContext = pVosContext;
277 wdaContext->wdaState = WDA_INIT_STATE;
278 wdaContext->uTxFlowMask = WDA_TXFLOWMASK;
279
280 /* Initialize WDA-WDI synchronization event */
281 status = vos_event_init(&wdaContext->wdaWdiEvent);
282 if(!VOS_IS_STATUS_SUCCESS(status))
283 {
284 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]285 "WDI Sync Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]286 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]287 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]288 /* Init Frame transfer event */
289 status = vos_event_init(&wdaContext->txFrameEvent);
290 if(!VOS_IS_STATUS_SUCCESS(status))
291 {
292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]293 "VOS Mgmt Frame Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]294 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]295 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]296 status = vos_event_init(&wdaContext->suspendDataTxEvent);
297 if(!VOS_IS_STATUS_SUCCESS(status))
298 {
299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]300 "VOS suspend data tx Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]301 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]302 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]303 status = vos_event_init(&wdaContext->waitOnWdiIndicationCallBack);
304 if(!VOS_IS_STATUS_SUCCESS(status))
305 {
306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]307 "VOS wait On Wdi Ind Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]308 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]309 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]310 vos_trace_setLevel(VOS_MODULE_ID_WDA,VOS_TRACE_LEVEL_ERROR);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]311 wdaContext->driverMode = pMacParams->driverType;
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]312 if(WDI_STATUS_SUCCESS != WDI_Init(devHandle, &wdaContext->pWdiContext,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]313 &wdiDevCapability, pMacParams->driverType))
314 {
315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
316 "WDI Init failed" );
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]317 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]318 }
319 else
320 {
321 pMacParams->maxStation = wdiDevCapability.ucMaxSTASupported ;
322 pMacParams->maxBssId = wdiDevCapability.ucMaxBSSSupported;
323 pMacParams->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]324 /* update max STA in WDA used for BA */
325 wdaContext->wdaMaxSta = pMacParams->maxStation;
326 /* store the frameTransRequired flag in wdaContext, to send this to HAL
327 * in WDA_Start
328 */
329 wdaContext->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
330 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]331 return status;
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]332
333error:
334 vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
335 return VOS_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]336}
337
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]338/*
339 * FUNCTION: WDA_preStart
340 * Trigger DAL-AL to start CFG download
341 */
342VOS_STATUS WDA_preStart(v_PVOID_t pVosContext)
343{
344 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
345 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]346 /*
347 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
348 */
349 wdaMsg.type = WNI_CFG_DNLD_REQ ;
350 wdaMsg.bodyptr = NULL;
351 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]352 /* post the message.. */
353 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
354 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
355 {
356 vosStatus = VOS_STATUS_E_BADMSG;
357 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]358 return( vosStatus );
359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]360/*
361 * FUNCTION: WDA_wdiStartCallback
362 * Once WDI_Start is finished, WDI start callback will be called by WDI
363 * to indicate completion of WDI_Start.
364 */
365void WDA_wdiStartCallback(WDI_StartRspParamsType *wdiRspParams,
366 void *pVosContext)
367{
368 tWDA_CbContext *wdaContext;
369 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]370 if (NULL == pVosContext)
371 {
372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]373 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]374 return;
375 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]376 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
377 if (NULL == wdaContext)
378 {
379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]380 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]381 return;
382 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]383 if (WDI_STATUS_SUCCESS != wdiRspParams->wdiStatus)
384 {
385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]386 "%s: WDI_Start() failure reported", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]387 }
388 else
389 {
390 wdaContext->wdaState = WDA_START_STATE;
391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]392 /* extract and save version information from the Start Response */
393 wdaContext->wcnssWlanCompiledVersion.major =
394 wdiRspParams->wlanCompiledVersion.major;
395 wdaContext->wcnssWlanCompiledVersion.minor =
396 wdiRspParams->wlanCompiledVersion.minor;
397 wdaContext->wcnssWlanCompiledVersion.version =
398 wdiRspParams->wlanCompiledVersion.version;
399 wdaContext->wcnssWlanCompiledVersion.revision =
400 wdiRspParams->wlanCompiledVersion.revision;
401 wdaContext->wcnssWlanReportedVersion.major =
402 wdiRspParams->wlanReportedVersion.major;
403 wdaContext->wcnssWlanReportedVersion.minor =
404 wdiRspParams->wlanReportedVersion.minor;
405 wdaContext->wcnssWlanReportedVersion.version =
406 wdiRspParams->wlanReportedVersion.version;
407 wdaContext->wcnssWlanReportedVersion.revision =
408 wdiRspParams->wlanReportedVersion.revision;
409 wpalMemoryCopy(wdaContext->wcnssSoftwareVersionString,
410 wdiRspParams->wcnssSoftwareVersion,
411 sizeof(wdaContext->wcnssSoftwareVersionString));
412 wpalMemoryCopy(wdaContext->wcnssHardwareVersionString,
413 wdiRspParams->wcnssHardwareVersion,
414 sizeof(wdaContext->wcnssHardwareVersionString));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]415 /* Notify WDA_start that WDI_Start has completed */
416 status = vos_event_set(&wdaContext->wdaWdiEvent);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]417 if (VOS_STATUS_SUCCESS != status)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]418 {
419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]420 "%s: Unable to unblock WDA_start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]421 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]422 return;
423}
424
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]425/*
426 * FUNCTION: WDA_start
427 * Prepare TLV configuration and call WDI_Start.
428 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]429VOS_STATUS WDA_start(v_PVOID_t pVosContext)
430{
431 tWDA_CbContext *wdaContext;
432 VOS_STATUS status;
433 WDI_Status wdiStatus;
434 WDI_StartReqParamsType wdiStartParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]435 if (NULL == pVosContext)
436 {
437 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]438 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]439 return VOS_STATUS_E_FAILURE;
440 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]441 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
442 if (NULL == wdaContext)
443 {
444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]445 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]446 return VOS_STATUS_E_FAILURE;
447 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]448 /* Non-FTM mode, WDA status for START must be INIT
449 * FTM mode, WDA Status for START can be INIT or STOP */
450 if ( (WDA_INIT_STATE != wdaContext->wdaState) &&
451 (WDA_STOP_STATE != wdaContext->wdaState) )
452 {
453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
454 "%s: Invoked from wrong state %d",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]455 __func__, wdaContext->wdaState );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]456 return VOS_STATUS_E_FAILURE;
457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]458 /* initialize the wdiStartParam. Note that we can create this on
459 the stack since we won't exit until WDI_Start() completes or
460 times out */
461 vos_mem_set(&wdiStartParam, sizeof(wdiStartParam), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]462 wdiStartParam.wdiDriverType = wdaContext->driverMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]463 /* prepare the config TLV for the WDI */
464 status = WDA_prepareConfigTLV(pVosContext, &wdiStartParam);
465 if ( !VOS_IS_STATUS_SUCCESS(status) )
466 {
467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]468 "%s: Unable to prepare Config TLV", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]469 return VOS_STATUS_E_FAILURE;
470 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]471 /* note from here onwards if an error occurs we must
472 reclaim the config TLV buffer */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]473 wdiStartParam.wdiLowLevelIndCB = WDA_lowLevelIndCallback;
474 wdiStartParam.pIndUserData = (v_PVOID_t *)wdaContext;
475 wdiStartParam.wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]476 /* initialize the WDA-WDI synchronization event */
477 vos_event_reset(&wdaContext->wdaWdiEvent);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]478 /* call WDI start */
479 wdiStatus = WDI_Start(&wdiStartParam,
480 (WDI_StartRspCb)WDA_wdiStartCallback,
481 (v_VOID_t *)pVosContext);
482 if ( IS_WDI_STATUS_FAILURE(wdiStatus) )
483 {
484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]485 "%s: WDI Start failed", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]486 vos_mem_free(wdiStartParam.pConfigBuffer);
487 return VOS_STATUS_E_FAILURE;
488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]489 /* wait for WDI start to invoke our callback */
490 status = vos_wait_single_event( &wdaContext->wdaWdiEvent,
491 WDA_WDI_START_TIMEOUT );
492 if ( !VOS_IS_STATUS_SUCCESS(status) )
493 {
494 if ( VOS_STATUS_E_TIMEOUT == status )
495 {
496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]497 "%s: Timeout occurred during WDI_Start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]498 }
499 else
500 {
501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
502 "%s: Error %d while waiting for WDI_Start",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]503 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]504 }
505 vos_mem_free(wdiStartParam.pConfigBuffer);
506 return VOS_STATUS_E_FAILURE;
507 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]508 /* WDI_Start() has completed so we can resume our work */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]509 /* we no longer need the config TLV */
510 vos_mem_free(wdiStartParam.pConfigBuffer);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]511 /* if we are not in the START state then WDI_Start() failed */
512 if (WDA_START_STATE != wdaContext->wdaState)
513 {
514 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]515 "%s: WDI_Start() failure detected", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]516 return VOS_STATUS_E_FAILURE;
517 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]518 /* FTM mode does not need to monitor BA activity */
519 if ( eDRIVER_TYPE_MFG != wdaContext->driverMode )
520 {
521 status = wdaCreateTimers(wdaContext) ;
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]522 if(VOS_STATUS_SUCCESS == status)
523 {
524 wdaContext->wdaTimersCreated = VOS_TRUE;
525 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]526 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]527 else
528 {
529 vos_event_init(&wdaContext->ftmStopDoneEvent);
530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]531 return status;
532}
533
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]534/*
535 * FUNCTION: WDA_prepareConfigTLV
536 * Function to prepare CFG for DAL(WDA)
537 */
538VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
539 WDI_StartReqParamsType *wdiStartParams )
540{
541 /* get pMac to acess CFG data base */
542 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
543 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
544 tHalCfg *tlvStruct = NULL ;
545 tANI_U8 *tlvStructStart = NULL ;
546 tANI_U32 strLength = WNI_CFG_STA_ID_LEN;
547 v_PVOID_t *configParam;
548 tANI_U32 configParamSize;
549 tANI_U32 *configDataValue;
550 WDI_WlanVersionType wcnssCompiledApiVersion;
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]551 tANI_U8 i;
552
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]553 if ((NULL == pMac)||(NULL == wdaContext))
554 {
555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]556 "%s: Invoked with invalid wdaContext or pMac", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]557 VOS_ASSERT(0);
558 return VOS_STATUS_E_FAILURE;
559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]560 configParamSize = (sizeof(tHalCfg) * QWLAN_HAL_CFG_MAX_PARAMS) +
561 WNI_CFG_STA_ID_LEN +
562 WNI_CFG_EDCA_WME_ACBK_LEN +
563 WNI_CFG_EDCA_WME_ACBE_LEN +
564 WNI_CFG_EDCA_WME_ACVI_LEN +
565 WNI_CFG_EDCA_WME_ACVO_LEN +
566 + (QWLAN_HAL_CFG_INTEGER_PARAM * sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]567 /* malloc memory for all configs in one shot */
568 configParam = vos_mem_malloc(configParamSize);
569
570 if(NULL == configParam )
571 {
572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]573 "%s:configParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]574 VOS_ASSERT(0) ;
575 return VOS_STATUS_E_NOMEM;
576 }
577 vos_mem_set(configParam, configParamSize, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]578 wdiStartParams->pConfigBuffer = configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]579 tlvStruct = (tHalCfg *)configParam;
580 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]581 /* TODO: Remove Later */
582 /* QWLAN_HAL_CFG_STA_ID */
583 tlvStruct->type = QWLAN_HAL_CFG_STA_ID;
584 configDataValue = (tANI_U32*)((tANI_U8 *) tlvStruct + sizeof(tHalCfg));
585 if(wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8*)configDataValue, &strLength) !=
586 eSIR_SUCCESS)
587 {
588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
589 "Failed to get value for WNI_CFG_STA_ID");
590 goto handle_failure;
591 }
592 tlvStruct->length = strLength ;
593 /* calculate the pad bytes to have the CFG in aligned format */
594 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
595 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]596 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
597 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]598 /* QWLAN_HAL_CFG_CURRENT_TX_ANTENNA */
599 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
600 tlvStruct->length = sizeof(tANI_U32);
601 configDataValue = (tANI_U32 *)(tlvStruct + 1);
602 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_TX_ANTENNA, configDataValue )
603 != eSIR_SUCCESS)
604 {
605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
606 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
607 goto handle_failure;
608 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]609 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
610 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]611 /* QWLAN_HAL_CFG_CURRENT_RX_ANTENNA */
612 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
613 tlvStruct->length = sizeof(tANI_U32);
614 configDataValue = (tANI_U32 *)(tlvStruct + 1);
615 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_RX_ANTENNA, configDataValue) !=
616 eSIR_SUCCESS)
617 {
618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
619 "Failed to get value for WNI_CFG_CURRENT_RX_ANTENNA");
620 goto handle_failure;
621 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]622 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
623 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]624 /* QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE */
625 tlvStruct->type = QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
626 tlvStruct->length = sizeof(tANI_U32);
627 configDataValue = (tANI_U32 *)(tlvStruct + 1);
628 if(wlan_cfgGetInt(pMac, WNI_CFG_LOW_GAIN_OVERRIDE, configDataValue )
629 != eSIR_SUCCESS)
630 {
631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
632 "Failed to get value for WNI_CFG_LOW_GAIN_OVERRIDE");
633 goto handle_failure;
634 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]635 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
636 + sizeof(tHalCfg) + tlvStruct->length)) ;
637
638 /* QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN */
639 tlvStruct->type = QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
640 tlvStruct->length = sizeof(tANI_U32);
641 configDataValue = (tANI_U32 *)(tlvStruct + 1);
642 if(wlan_cfgGetInt(pMac, WNI_CFG_POWER_STATE_PER_CHAIN,
643 configDataValue ) != eSIR_SUCCESS)
644 {
645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
646 "Failed to get value for WNI_CFG_POWER_STATE_PER_CHAIN");
647 goto handle_failure;
648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]649 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
650 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]651 /* QWLAN_HAL_CFG_CAL_PERIOD */
652 tlvStruct->type = QWLAN_HAL_CFG_CAL_PERIOD;
653 tlvStruct->length = sizeof(tANI_U32);
654 configDataValue = (tANI_U32 *)(tlvStruct + 1);
655 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_PERIOD, configDataValue )
656 != eSIR_SUCCESS)
657 {
658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
659 "Failed to get value for WNI_CFG_CAL_PERIOD");
660 goto handle_failure;
661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]662 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
663 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]664 /* QWLAN_HAL_CFG_CAL_CONTROL */
665 tlvStruct->type = QWLAN_HAL_CFG_CAL_CONTROL ;
666 tlvStruct->length = sizeof(tANI_U32);
667 configDataValue = (tANI_U32 *)(tlvStruct + 1);
668 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_CONTROL, configDataValue )
669 != eSIR_SUCCESS)
670 {
671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
672 "Failed to get value for WNI_CFG_CAL_CONTROL");
673 goto handle_failure;
674 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]675 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
676 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]677 /* QWLAN_HAL_CFG_PROXIMITY */
678 tlvStruct->type = QWLAN_HAL_CFG_PROXIMITY ;
679 tlvStruct->length = sizeof(tANI_U32);
680 configDataValue = (tANI_U32 *)(tlvStruct + 1);
681 if(wlan_cfgGetInt(pMac, WNI_CFG_PROXIMITY, configDataValue )
682 != eSIR_SUCCESS)
683 {
684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
685 "Failed to get value for WNI_CFG_PROXIMITY");
686 goto handle_failure;
687 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]688 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
689 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]690 /* QWLAN_HAL_CFG_NETWORK_DENSITY */
691 tlvStruct->type = QWLAN_HAL_CFG_NETWORK_DENSITY ;
692 tlvStruct->length = sizeof(tANI_U32);
693 configDataValue = (tANI_U32 *)(tlvStruct + 1);
694 if(wlan_cfgGetInt(pMac, WNI_CFG_NETWORK_DENSITY, configDataValue )
695 != eSIR_SUCCESS)
696 {
697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
698 "Failed to get value for WNI_CFG_NETWORK_DENSITY");
699 goto handle_failure;
700 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]701 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
702 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]703 /* QWLAN_HAL_CFG_MAX_MEDIUM_TIME */
704 tlvStruct->type = QWLAN_HAL_CFG_MAX_MEDIUM_TIME ;
705 tlvStruct->length = sizeof(tANI_U32);
706 configDataValue = (tANI_U32 *)(tlvStruct + 1);
707 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MEDIUM_TIME, configDataValue ) !=
708 eSIR_SUCCESS)
709 {
710 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
711 "Failed to get value for WNI_CFG_MAX_MEDIUM_TIME");
712 goto handle_failure;
713 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]714 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
715 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]716 /* QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU */
717 tlvStruct->type = QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU ;
718 tlvStruct->length = sizeof(tANI_U32);
719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
720 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MPDUS_IN_AMPDU,
721 configDataValue ) != eSIR_SUCCESS)
722 {
723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
724 "Failed to get value for WNI_CFG_MAX_MPDUS_IN_AMPDU");
725 goto handle_failure;
726 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]727 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
728 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]729 /* QWLAN_HAL_CFG_RTS_THRESHOLD */
730 tlvStruct->type = QWLAN_HAL_CFG_RTS_THRESHOLD ;
731 tlvStruct->length = sizeof(tANI_U32);
732 configDataValue = (tANI_U32 *)(tlvStruct + 1);
733 if(wlan_cfgGetInt(pMac, WNI_CFG_RTS_THRESHOLD, configDataValue ) !=
734 eSIR_SUCCESS)
735 {
736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
737 "Failed to get value for WNI_CFG_RTS_THRESHOLD");
738 goto handle_failure;
739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]740 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
741 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]742 /* QWLAN_HAL_CFG_SHORT_RETRY_LIMIT */
743 tlvStruct->type = QWLAN_HAL_CFG_SHORT_RETRY_LIMIT ;
744 tlvStruct->length = sizeof(tANI_U32);
745 configDataValue = (tANI_U32 *)(tlvStruct + 1);
746 if(wlan_cfgGetInt(pMac, WNI_CFG_SHORT_RETRY_LIMIT, configDataValue ) !=
747 eSIR_SUCCESS)
748 {
749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
750 "Failed to get value for WNI_CFG_SHORT_RETRY_LIMIT");
751 goto handle_failure;
752 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]753 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
754 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]755 /* QWLAN_HAL_CFG_LONG_RETRY_LIMIT */
756 tlvStruct->type = QWLAN_HAL_CFG_LONG_RETRY_LIMIT ;
757 tlvStruct->length = sizeof(tANI_U32);
758 configDataValue = (tANI_U32 *)(tlvStruct + 1);
759 if(wlan_cfgGetInt(pMac, WNI_CFG_LONG_RETRY_LIMIT, configDataValue ) !=
760 eSIR_SUCCESS)
761 {
762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
763 "Failed to get value for WNI_CFG_LONG_RETRY_LIMIT");
764 goto handle_failure;
765 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]766 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
767 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]768 /* QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD */
769 tlvStruct->type = QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD ;
770 tlvStruct->length = sizeof(tANI_U32);
771 configDataValue = (tANI_U32 *)(tlvStruct + 1);
772 if(wlan_cfgGetInt(pMac, WNI_CFG_FRAGMENTATION_THRESHOLD,
773 configDataValue ) != eSIR_SUCCESS)
774 {
775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
776 "Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD");
777 goto handle_failure;
778 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]779 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
780 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]781 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO */
782 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO ;
783 tlvStruct->length = sizeof(tANI_U32);
784 configDataValue = (tANI_U32 *)(tlvStruct + 1);
785 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ZERO,
786 configDataValue ) != eSIR_SUCCESS)
787 {
788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
789 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ZERO");
790 goto handle_failure;
791 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]792 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
793 + sizeof(tHalCfg) + tlvStruct->length));
794
795 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE */
796 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE ;
797 tlvStruct->length = sizeof(tANI_U32);
798 configDataValue = (tANI_U32 *)(tlvStruct + 1);
799 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ONE,
800 configDataValue ) != eSIR_SUCCESS)
801 {
802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
803 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ONE");
804 goto handle_failure;
805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]806 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
807 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]808 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO */
809 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO ;
810 tlvStruct->length = sizeof(tANI_U32);
811 configDataValue = (tANI_U32 *)(tlvStruct + 1);
812 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_TWO,
813 configDataValue ) != eSIR_SUCCESS)
814 {
815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
816 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_TWO");
817 goto handle_failure;
818 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]819 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
820 + sizeof(tHalCfg) + tlvStruct->length));
821
822 /* QWLAN_HAL_CFG_FIXED_RATE */
823 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE ;
824 tlvStruct->length = sizeof(tANI_U32);
825 configDataValue = (tANI_U32 *)(tlvStruct + 1);
826 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE, configDataValue)
827 != eSIR_SUCCESS)
828 {
829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
830 "Failed to get value for WNI_CFG_FIXED_RATE");
831 goto handle_failure;
832 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]833 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
834 + sizeof(tHalCfg) + tlvStruct->length));
835
836 /* QWLAN_HAL_CFG_RETRYRATE_POLICY */
837 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_POLICY ;
838 tlvStruct->length = sizeof(tANI_U32);
839 configDataValue = (tANI_U32 *)(tlvStruct + 1);
840 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_POLICY, configDataValue )
841 != eSIR_SUCCESS)
842 {
843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
844 "Failed to get value for WNI_CFG_RETRYRATE_POLICY");
845 goto handle_failure;
846 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]847 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
848 + sizeof(tHalCfg) + tlvStruct->length));
849
850 /* QWLAN_HAL_CFG_RETRYRATE_SECONDARY */
851 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_SECONDARY ;
852 tlvStruct->length = sizeof(tANI_U32);
853 configDataValue = (tANI_U32 *)(tlvStruct + 1);
854 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_SECONDARY,
855 configDataValue ) != eSIR_SUCCESS)
856 {
857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
858 "Failed to get value for WNI_CFG_RETRYRATE_SECONDARY");
859 goto handle_failure;
860 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]861 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
862 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]863 /* QWLAN_HAL_CFG_RETRYRATE_TERTIARY */
864 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_TERTIARY ;
865 tlvStruct->length = sizeof(tANI_U32);
866 configDataValue = (tANI_U32 *)(tlvStruct + 1);
867 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_TERTIARY,
868 configDataValue ) != eSIR_SUCCESS)
869 {
870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
871 "Failed to get value for WNI_CFG_RETRYRATE_TERTIARY");
872 goto handle_failure;
873 }
874 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
875 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]876 /* QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION */
877 tlvStruct->type = QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION ;
878 tlvStruct->length = sizeof(tANI_U32);
879 configDataValue = (tANI_U32 *)(tlvStruct + 1);
880 if(wlan_cfgGetInt(pMac, WNI_CFG_FORCE_POLICY_PROTECTION,
881 configDataValue ) != eSIR_SUCCESS)
882 {
883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
884 "Failed to get value for WNI_CFG_FORCE_POLICY_PROTECTION");
885 goto handle_failure;
886 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]887 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
888 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]889 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ */
890 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ ;
891 tlvStruct->length = sizeof(tANI_U32);
892 configDataValue = (tANI_U32 *)(tlvStruct + 1);
893 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_24GHZ,
894 configDataValue ) != eSIR_SUCCESS)
895 {
896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
897 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_24GHZ");
898 goto handle_failure;
899 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
901 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]902 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ */
903 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ ;
904 tlvStruct->length = sizeof(tANI_U32);
905 configDataValue = (tANI_U32 *)(tlvStruct + 1);
906 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_5GHZ,
907 configDataValue ) != eSIR_SUCCESS)
908 {
909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
910 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_5GHZ");
911 goto handle_failure;
912 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]913 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
914 + sizeof(tHalCfg) + tlvStruct->length);
915
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]916 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ */
917 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ ;
918 tlvStruct->length = sizeof(tANI_U32);
919 configDataValue = (tANI_U32 *)(tlvStruct + 1);
920 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_24GHZ,
921 configDataValue ) != eSIR_SUCCESS)
922 {
923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
924 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_24GHZ");
925 goto handle_failure;
926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]927 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
928 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]929 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ */
930 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ ;
931 tlvStruct->length = sizeof(tANI_U32);
932 configDataValue = (tANI_U32 *)(tlvStruct + 1);
933 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_5GHZ,
934 configDataValue ) != eSIR_SUCCESS)
935 {
936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
937 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_5GHZ");
938 goto handle_failure;
939 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]940 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
941 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]942 /* QWLAN_HAL_CFG_MAX_BA_SESSIONS */
943 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_SESSIONS ;
944 tlvStruct->length = sizeof(tANI_U32);
945 configDataValue = (tANI_U32 *)(tlvStruct + 1);
946 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_SESSIONS, configDataValue ) !=
947 eSIR_SUCCESS)
948 {
949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
950 "Failed to get value for WNI_CFG_MAX_BA_SESSIONS");
951 goto handle_failure;
952 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]953 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
954 + sizeof(tHalCfg) + tlvStruct->length);
955
956 /* QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT */
957 tlvStruct->type = QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT ;
958 tlvStruct->length = sizeof(tANI_U32);
959 configDataValue = (tANI_U32 *)(tlvStruct + 1);
960 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
961 configDataValue ) != eSIR_SUCCESS)
962 {
963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
964 "Failed to get value for WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
965 goto handle_failure;
966 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]967 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
968 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]969 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER */
970 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER ;
971 tlvStruct->length = sizeof(tANI_U32);
972 configDataValue = (tANI_U32 *)(tlvStruct + 1);
973 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_BCN_FILTER,
974 configDataValue ) != eSIR_SUCCESS)
975 {
976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
977 "Failed to get value for WNI_CFG_PS_ENABLE_BCN_FILTER");
978 goto handle_failure;
979 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]980 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
981 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]982 /* QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR */
983 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR ;
984 tlvStruct->length = sizeof(tANI_U32);
985 configDataValue = (tANI_U32 *)(tlvStruct + 1);
986 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_RSSI_MONITOR,
987 configDataValue ) != eSIR_SUCCESS)
988 {
989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
990 "Failed to get value for WNI_CFG_PS_ENABLE_RSSI_MONITOR");
991 goto handle_failure;
992 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]993 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
994 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]995 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
996 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE ;
997 tlvStruct->length = sizeof(tANI_U32);
998 configDataValue = (tANI_U32 *)(tlvStruct + 1);
999 if(wlan_cfgGetInt(pMac, WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE,
1000 configDataValue ) != eSIR_SUCCESS)
1001 {
1002 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1003 "Failed to get value for WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE");
1004 goto handle_failure;
1005 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1006 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1007 + sizeof(tHalCfg) + tlvStruct->length);
1008
1009 /* QWLAN_HAL_CFG_STATS_PERIOD */
1010 tlvStruct->type = QWLAN_HAL_CFG_STATS_PERIOD ;
1011 tlvStruct->length = sizeof(tANI_U32);
1012 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1013 if(wlan_cfgGetInt(pMac, WNI_CFG_STATS_PERIOD, configDataValue ) !=
1014 eSIR_SUCCESS)
1015 {
1016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1017 "Failed to get value for WNI_CFG_STATS_PERIOD");
1018 goto handle_failure;
1019 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1020 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1021 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1022 /* QWLAN_HAL_CFG_CFP_MAX_DURATION */
1023 tlvStruct->type = QWLAN_HAL_CFG_CFP_MAX_DURATION ;
1024 tlvStruct->length = sizeof(tANI_U32);
1025 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1026 if(wlan_cfgGetInt(pMac, WNI_CFG_CFP_MAX_DURATION, configDataValue ) !=
1027 eSIR_SUCCESS)
1028 {
1029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1030 "Failed to get value for WNI_CFG_CFP_MAX_DURATION");
1031 goto handle_failure;
1032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1033 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1034 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1035 /* QWLAN_HAL_CFG_FRAME_TRANS_ENABLED */
1036 tlvStruct->type = QWLAN_HAL_CFG_FRAME_TRANS_ENABLED ;
1037 tlvStruct->length = sizeof(tANI_U32);
1038 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1039 vos_mem_copy(configDataValue, &wdaContext->frameTransRequired,
1040 sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1041 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1042 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1043 /* QWLAN_HAL_CFG_DTIM_PERIOD */
1044 tlvStruct->type = QWLAN_HAL_CFG_DTIM_PERIOD ;
1045 tlvStruct->length = sizeof(tANI_U32);
1046 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1047 if(wlan_cfgGetInt(pMac, WNI_CFG_DTIM_PERIOD, configDataValue)
1048 != eSIR_SUCCESS)
1049 {
1050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1051 "Failed to get value for WNI_CFG_DTIM_PERIOD");
1052 goto handle_failure;
1053 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1054 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1055 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1056 /* QWLAN_HAL_CFG_EDCA_WMM_ACBK */
1057 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBK ;
1058 strLength = WNI_CFG_EDCA_WME_ACBK_LEN;
1059 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1060 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBK, (tANI_U8 *)configDataValue,
1061 &strLength) != eSIR_SUCCESS)
1062 {
1063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1064 "Failed to get value for WNI_CFG_EDCA_WME_ACBK");
1065 goto handle_failure;
1066 }
1067 tlvStruct->length = strLength;
1068 /* calculate the pad bytes to have the CFG in aligned format */
1069 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1070 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1071 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1072 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1073 /* QWLAN_HAL_CFG_EDCA_WMM_ACBE */
1074 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBE ;
1075 strLength = WNI_CFG_EDCA_WME_ACBE_LEN;
1076 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1077 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBE, (tANI_U8 *)configDataValue,
1078 &strLength) != eSIR_SUCCESS)
1079 {
1080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1081 "Failed to get value for WNI_CFG_EDCA_WME_ACBE");
1082 goto handle_failure;
1083 }
1084 tlvStruct->length = strLength;
1085 /* calculate the pad bytes to have the CFG in aligned format */
1086 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1087 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1088 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1089 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1090 /* QWLAN_HAL_CFG_EDCA_WMM_ACVI */
1091 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVO ;
1092 strLength = WNI_CFG_EDCA_WME_ACVI_LEN;
1093 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1094 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVO, (tANI_U8 *)configDataValue,
1095 &strLength) != eSIR_SUCCESS)
1096 {
1097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1098 "Failed to get value for WNI_CFG_EDCA_WME_ACVI");
1099 goto handle_failure;
1100 }
1101 tlvStruct->length = strLength;
1102 /* calculate the pad bytes to have the CFG in aligned format */
1103 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1104 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1105 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1106 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1107 /* QWLAN_HAL_CFG_EDCA_WMM_ACVO */
1108 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVI ;
1109 strLength = WNI_CFG_EDCA_WME_ACVO_LEN;
1110 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1111 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVI, (tANI_U8 *)configDataValue,
1112 &strLength) != eSIR_SUCCESS)
1113 {
1114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1115 "Failed to get value for WNI_CFG_EDCA_WME_ACVO");
1116 goto handle_failure;
1117 }
1118 tlvStruct->length = strLength;
1119 /* calculate the pad bytes to have the CFG in aligned format */
1120 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1121 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1122 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1123 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1124 /* QWLAN_HAL_CFG_BA_THRESHOLD_HIGH */
1125 tlvStruct->type = QWLAN_HAL_CFG_BA_THRESHOLD_HIGH ;
1126 tlvStruct->length = sizeof(tANI_U32);
1127 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1128 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_THRESHOLD_HIGH, configDataValue)
1129 != eSIR_SUCCESS)
1130 {
1131 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1132 "Failed to get value for WNI_CFG_BA_THRESHOLD_HIGH");
1133 goto handle_failure;
1134 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1135 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1136 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1137 /* QWLAN_HAL_CFG_MAX_BA_BUFFERS */
1138 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_BUFFERS ;
1139 tlvStruct->length = sizeof(tANI_U32);
1140 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1141 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_BUFFERS, configDataValue)
1142 != eSIR_SUCCESS)
1143 {
1144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1145 "Failed to get value for WNI_CFG_MAX_BA_BUFFERS");
1146 goto handle_failure;
1147 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1148 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1149 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1150 /* QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE */
1151 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE ;
1152 tlvStruct->length = sizeof(tANI_U32);
1153 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1154 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_PS_POLL_VALUE, configDataValue)
1155 != eSIR_SUCCESS)
1156 {
1157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1158 "Failed to get value for WNI_CFG_DYNAMIC_PS_POLL_VALUE");
1159 goto handle_failure;
1160 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1161 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1162 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1163 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI */
1164 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI ;
1165 tlvStruct->length = sizeof(tANI_U32);
1166 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1167 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI, configDataValue)
1168 != eSIR_SUCCESS)
1169 {
1170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1171 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI");
1172 goto handle_failure;
1173 }
1174 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1175 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1176 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS */
1177 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS ;
1178 tlvStruct->length = sizeof(tANI_U32);
1179 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1180 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, configDataValue)
1181 != eSIR_SUCCESS)
1182 {
1183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1184 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS");
1185 goto handle_failure;
1186 }
1187 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1188 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1189 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI */
1190 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI ;
1191 tlvStruct->length = sizeof(tANI_U32);
1192 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1193 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI, configDataValue)
1194 != eSIR_SUCCESS)
1195 {
1196 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1197 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI");
1198 goto handle_failure;
1199 }
1200 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1201 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1202 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS */
1203 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS ;
1204 tlvStruct->length = sizeof(tANI_U32);
1205 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1206 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, configDataValue)
1207 != eSIR_SUCCESS)
1208 {
1209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1210 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS");
1211 goto handle_failure;
1212 }
1213 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1214 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1215 /* QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN */
1216 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN ;
1217 tlvStruct->length = sizeof(tANI_U32);
1218 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1219 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_WAKEUP_EN, configDataValue)
1220 != eSIR_SUCCESS)
1221 {
1222 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1223 "Failed to get value for WNI_CFG_TELE_BCN_WAKEUP_EN");
1224 goto handle_failure;
1225 }
1226 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1227 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1228 /* QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD */
1229 tlvStruct->type = QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD ;
1230 tlvStruct->length = sizeof(tANI_U32);
1231 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1232 if(wlan_cfgGetInt(pMac, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, configDataValue)
1233 != eSIR_SUCCESS)
1234 {
1235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1236 "Failed to get value for WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD");
1237 goto handle_failure;
1238 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1239 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1240 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1241 /*QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE*/
1242 tlvStruct->type = QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE ;
1243 tlvStruct->length = sizeof(tANI_U32);
1244 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1245 if(wlan_cfgGetInt(pMac, WNI_CFG_TX_PWR_CTRL_ENABLE, configDataValue)
1246 != eSIR_SUCCESS)
1247 {
1248 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1249 "Failed to get value for WNI_CFG_TX_PWR_CTRL_ENABLE");
1250 goto handle_failure;
1251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1252 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1253 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1254 /* QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP */
1255 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP ;
1256 tlvStruct->length = sizeof(tANI_U32);
1257 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1258 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_CLOSE_LOOP, configDataValue)
1259 != eSIR_SUCCESS)
1260 {
1261 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1262 "Failed to get value for WNI_CFG_ENABLE_CLOSE_LOOP");
1263 goto handle_failure;
1264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1265 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1266 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1267 /* [COEX] strictly speaking, the Coex parameters are not part of the WLAN_CFG_FILE binary,
1268 * but are from the WLAN_INI_FILE file. However, this is the only parameter download routine
1269 * into FW, so the parameters are added here.
1270 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1271 /* [COEX] QWLAN_HAL_CFG_BTC_EXECUTION_MODE */
1272 tlvStruct->type = QWLAN_HAL_CFG_BTC_EXECUTION_MODE ;
1273 tlvStruct->length = sizeof(tANI_U32);
1274 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1275 *configDataValue = pMac->btc.btcConfig.btcExecutionMode;
1276 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1277 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1278 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK */
1279 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK ;
1280 tlvStruct->length = sizeof(tANI_U32);
1281 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1282 *configDataValue = pMac->btc.btcConfig.btcConsBtSlotsToBlockDuringDhcp;
1283 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1284 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1285 /* [COEX] QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS */
1286 tlvStruct->type = QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS ;
1287 tlvStruct->length = sizeof(tANI_U32);
1288 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1289 *configDataValue = pMac->btc.btcConfig.btcA2DPBtSubIntervalsDuringDhcp;
1290 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1291 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1292 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT */
1293 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT ;
1294 tlvStruct->length = sizeof(tANI_U32);
1295 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1296 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqBt;
1297 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1298 + sizeof(tHalCfg) + tlvStruct->length) ;
1299
1300 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT */
1301 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT ;
1302 tlvStruct->length = sizeof(tANI_U32);
1303 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1304 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageBt;
1305 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1306 + sizeof(tHalCfg) + tlvStruct->length) ;
1307
1308 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT */
1309 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT ;
1310 tlvStruct->length = sizeof(tANI_U32);
1311 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1312 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnBt;
1313 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1314 + sizeof(tHalCfg) + tlvStruct->length) ;
1315
1316 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT */
1317 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT ;
1318 tlvStruct->length = sizeof(tANI_U32);
1319 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1320 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeBt;
1321 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1322 + sizeof(tHalCfg) + tlvStruct->length) ;
1323
1324 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN */
1325 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN ;
1326 tlvStruct->length = sizeof(tANI_U32);
1327 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1328 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqWlan;
1329 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1330 + sizeof(tHalCfg) + tlvStruct->length) ;
1331
1332 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN */
1333 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN ;
1334 tlvStruct->length = sizeof(tANI_U32);
1335 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1336 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageWlan;
1337 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1338 + sizeof(tHalCfg) + tlvStruct->length) ;
1339
1340 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN */
1341 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN ;
1342 tlvStruct->length = sizeof(tANI_U32);
1343 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1344 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnWlan;
1345 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1346 + sizeof(tHalCfg) + tlvStruct->length) ;
1347
1348 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN */
1349 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN ;
1350 tlvStruct->length = sizeof(tANI_U32);
1351 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1352 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeWlan;
1353 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1354 + sizeof(tHalCfg) + tlvStruct->length) ;
1355
1356 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT */
1357 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT ;
1358 tlvStruct->length = sizeof(tANI_U32);
1359 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1360 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenBt;
1361 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1362 + sizeof(tHalCfg) + tlvStruct->length) ;
1363
1364 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN */
1365 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN ;
1366 tlvStruct->length = sizeof(tANI_U32);
1367 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1368 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenWlan;
1369 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1370 + sizeof(tHalCfg) + tlvStruct->length) ;
1371
1372 /* [COEX] QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC */
1373 tlvStruct->type = QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC ;
1374 tlvStruct->length = sizeof(tANI_U32);
1375 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1376 *configDataValue = pMac->btc.btcConfig.btcMaxScoBlockPerc;
1377 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1378 + sizeof(tHalCfg) + tlvStruct->length) ;
1379
1380 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP */
1381 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP ;
1382 tlvStruct->length = sizeof(tANI_U32);
1383 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1384 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnA2dp;
1385 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1386 + sizeof(tHalCfg) + tlvStruct->length) ;
1387
1388 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO */
1389 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO ;
1390 tlvStruct->length = sizeof(tANI_U32);
1391 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1392 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnSco;
1393 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1394 + sizeof(tHalCfg) + tlvStruct->length) ;
1395
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]1396 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_VICTIM; i++)
1397 {
1398 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WAN_FREQ */
1399 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WAN_FREQ + i*4;
1400 tlvStruct->length = sizeof(tANI_U32);
1401 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1402 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWANFreq[i];
1403 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1404 + sizeof(tHalCfg) + tlvStruct->length) ;
1405
1406 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WLAN_FREQ */
1407 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WLAN_FREQ + i*4;
1408 tlvStruct->length = sizeof(tANI_U32);
1409 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1410 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWLANFreq[i];
1411 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1412 + sizeof(tHalCfg) + tlvStruct->length) ;
1413
1414 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG */
1415 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG + i*4;
1416 tlvStruct->length = sizeof(tANI_U32);
1417 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1418 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig[i];
1419 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1420 + sizeof(tHalCfg) + tlvStruct->length) ;
1421
1422 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG2 */
1423 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG2 + i*4;
1424 tlvStruct->length = sizeof(tANI_U32);
1425 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1426 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig2[i];
1427 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1428 + sizeof(tHalCfg) + tlvStruct->length) ;
1429 }
1430
1431 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF */
1432 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF ;
1433 tlvStruct->length = sizeof(tANI_U32);
1434 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1435 *configDataValue = pMac->btc.btcConfig.mwsCoexModemBackoff;
1436 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1437 + sizeof(tHalCfg) + tlvStruct->length) ;
1438
1439 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_CONFIG; i++)
1440 {
1441 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_CONFIGX */
1442 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_CONFIG1 + i;
1443 tlvStruct->length = sizeof(tANI_U32);
1444 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1445 *configDataValue = pMac->btc.btcConfig.mwsCoexConfig[i];
1446 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1447 + sizeof(tHalCfg) + tlvStruct->length) ;
1448 }
1449
1450 /* [COEX] QWLAN_HAL_CFG_SAR_POWER_BACKOFF */
1451 tlvStruct->type = QWLAN_HAL_CFG_SAR_POWER_BACKOFF ;
1452 tlvStruct->length = sizeof(tANI_U32);
1453 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1454 *configDataValue = pMac->btc.btcConfig.SARPowerBackoff;
1455 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1456 + sizeof(tHalCfg) + tlvStruct->length) ;
1457
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1458 /* QWLAN_HAL_CFG_WCNSS_API_VERSION */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1459 tlvStruct->type = QWLAN_HAL_CFG_WCNSS_API_VERSION ;
1460 tlvStruct->length = sizeof(tANI_U32);
1461 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1462 WDI_GetWcnssCompiledApiVersion(&wcnssCompiledApiVersion);
1463 *configDataValue = WLAN_HAL_CONSTRUCT_API_VERSION(wcnssCompiledApiVersion.major,
1464 wcnssCompiledApiVersion.minor,
1465 wcnssCompiledApiVersion.version,
1466 wcnssCompiledApiVersion.revision);
1467 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1468 + sizeof(tHalCfg) + tlvStruct->length) ;
1469
Jeff Johnsond13512a2012-07-17 11:42:19 -0700[diff] [blame]1470 /* QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT */
1471 tlvStruct->type = QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT ;
1472 tlvStruct->length = sizeof(tANI_U32);
1473 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1474 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT,
1475 configDataValue ) != eSIR_SUCCESS)
1476 {
1477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1478 "Failed to get value for WNI_CFG_AP_KEEP_ALIVE_TIMEOUT");
1479 goto handle_failure;
1480 }
1481
1482 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1483 + sizeof(tHalCfg) + tlvStruct->length) ;
1484 /* QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT */
1485 tlvStruct->type = QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT ;
1486 tlvStruct->length = sizeof(tANI_U32);
1487 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1488 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT,
1489 configDataValue ) != eSIR_SUCCESS)
1490 {
1491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1492 "Failed to get value for WNI_CFG_GO_KEEP_ALIVE_TIMEOUT");
1493 goto handle_failure;
1494 }
1495
1496 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1497 + sizeof(tHalCfg) + tlvStruct->length) ;
1498
1499 /* QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST */
1500 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST;
1501 tlvStruct->length = sizeof(tANI_U32);
1502 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1503 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MC_ADDR_LIST, configDataValue)
1504 != eSIR_SUCCESS)
1505 {
1506 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1507 "Failed to get value for WNI_CFG_ENABLE_MC_ADDR_LIST");
1508 goto handle_failure;
1509 }
1510
1511 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1512 + sizeof(tHalCfg) + tlvStruct->length) ;
1513
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]1514 /* QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION */
1515 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION ;
1516 tlvStruct->length = sizeof(tANI_U32);
1517 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1518 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION, configDataValue)
1519 != eSIR_SUCCESS)
1520 {
1521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1522 "Failed to get value for WNI_CFG_ENABLE_LPWR_IMG_TRANSITION");
1523 goto handle_failure;
1524 }
1525
1526 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1527 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]1528#ifdef WLAN_SOFTAP_VSTA_FEATURE
1529 tlvStruct->type = QWLAN_HAL_CFG_MAX_ASSOC_LIMIT;
1530 tlvStruct->length = sizeof(tANI_U32);
1531 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1532 if(wlan_cfgGetInt(pMac, WNI_CFG_ASSOC_STA_LIMIT, configDataValue)
1533 != eSIR_SUCCESS)
1534 {
1535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1536 "Failed to get value for WNI_CFG_ASSOC_STA_LIMIT");
1537 goto handle_failure;
1538 }
1539
1540 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1541 + sizeof(tHalCfg) + tlvStruct->length) ;
1542#endif
1543
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]1544 /* QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER */
1545 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER;
1546 tlvStruct->length = sizeof(tANI_U32);
1547 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1548
1549 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, configDataValue)
1550 != eSIR_SUCCESS)
1551 {
1552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1553 "Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
1554 goto handle_failure;
1555 }
1556
1557 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1558 + sizeof(tHalCfg) + tlvStruct->length) ;
1559
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1560/* QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT */
1561 tlvStruct->type = QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT ;
1562 tlvStruct->length = sizeof(tANI_U32);
1563 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1564 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_LINK_MONITOR_TIMEOUT,
1565 configDataValue ) != eSIR_SUCCESS)
1566 {
1567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1568 "Failed to get value for WNI_CFG_AP_LINK_MONITOR_TIMEOUT");
1569 goto handle_failure;
1570 }
1571
1572 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1573 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1574#ifdef FEATURE_WLAN_TDLS
1575 /* QWLAN_HAL_CFG_TDLS_PUAPSD_MASK */
1576 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_MASK;
1577 tlvStruct->length = sizeof(tANI_U32);
1578 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1579 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,
1580 configDataValue ) != eSIR_SUCCESS)
1581 {
1582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1583 "Failed to get value for WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK");
1584 goto handle_failure;
1585 }
1586 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1587 + sizeof(tHalCfg) + tlvStruct->length) ;
1588
1589 /* QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE */
1590 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE;
1591 tlvStruct->length = sizeof(tANI_U32);
1592 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1593 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_BUF_STA_ENABLED,
1594 configDataValue ) != eSIR_SUCCESS)
1595 {
1596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1597 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1598 goto handle_failure;
1599 }
1600 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1601 + sizeof(tHalCfg) + tlvStruct->length) ;
1602 /* QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME */
1603 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME;
1604 tlvStruct->length = sizeof(tANI_U32);
1605 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1606 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_PUAPSD_INACT_TIME,
1607 configDataValue ) != eSIR_SUCCESS)
1608 {
1609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1610 "Failed to get value for WNI_CFG_TDLS_PUAPSD_INACT_TIME");
1611 goto handle_failure;
1612 }
1613 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1614 + sizeof(tHalCfg) + tlvStruct->length) ;
1615 /* QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP */
1616 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP;
1617 tlvStruct->length = sizeof(tANI_U32);
1618 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1619 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,
1620 configDataValue ) != eSIR_SUCCESS)
1621 {
1622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1623 "Failed to get value for WNI_CFG_TDLS_RX_FRAME_THRESHOLD");
1624 goto handle_failure;
1625 }
1626 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1627 + sizeof(tHalCfg) + tlvStruct->length) ;
Naresh Jayaramf73f3762014-02-04 16:13:20 +0530[diff] [blame]1628 /* QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE */
1629 tlvStruct->type = QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE;
1630 tlvStruct->length = sizeof(tANI_U32);
1631 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1632 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_OFF_CHANNEL_ENABLED,
1633 configDataValue ) != eSIR_SUCCESS)
1634 {
1635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1636 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1637 goto handle_failure;
1638 }
1639 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1640 + sizeof(tHalCfg) + tlvStruct->length) ;
1641
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1642#endif
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1643
Sudhir Sattayappa Kohallida1be202013-07-11 12:04:30 -0700[diff] [blame]1644 /* QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN */
1645 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN_FEATURE ;
1646 tlvStruct->length = sizeof(tANI_U32);
1647 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1648 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,
1649 configDataValue ) != eSIR_SUCCESS)
1650 {
1651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1652 "Failed to get value for WNI_CFG_ENABLE_ADAPT_RX_DRAIN");
1653 goto handle_failure;
1654 }
1655
1656 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1657 + sizeof(tHalCfg) + tlvStruct->length) ;
Yue Ma0fd23872013-08-01 15:56:47 -0700[diff] [blame]1658
1659 /* QWLAN_HAL_CFG_FLEX_CONNECT_POWER_FACTOR */
1660 tlvStruct->type = QWLAN_HAL_CFG_FLEXCONNECT_POWER_FACTOR;
1661 tlvStruct->length = sizeof(tANI_U32);
1662 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1663 if(wlan_cfgGetInt(pMac, WNI_CFG_FLEX_CONNECT_POWER_FACTOR, configDataValue)
1664 != eSIR_SUCCESS)
1665 {
1666 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1667 "Failed to get value for WNI_CFG_FLEX_CONNECT_POWER_FACTOR");
1668 goto handle_failure;
1669 }
1670 tlvStruct = (tHalCfg *)(((tANI_U8 *) tlvStruct
1671 + sizeof(tHalCfg) + tlvStruct->length));
1672
Madan Mohan Koyyalamudica454572013-08-07 19:57:03 +0530[diff] [blame]1673 /* QWLAN_HAL_CFG_ANTENNA_DIVERSITY */
1674 tlvStruct->type = QWLAN_HAL_CFG_ANTENNA_DIVERSITY;
1675 tlvStruct->length = sizeof(tANI_U32);
1676 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1677 if (wlan_cfgGetInt(pMac, WNI_CFG_ANTENNA_DIVESITY,
1678 configDataValue ) != eSIR_SUCCESS)
1679 {
1680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1681 "Failed to get value for WNI_CFG_ANTENNA_DIVESITY");
1682 goto handle_failure;
1683 }
1684
1685 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1686 + sizeof(tHalCfg) + tlvStruct->length) ;
1687
Madan Mohan Koyyalamudi2558bc92013-08-24 16:54:31 +0530[diff] [blame]1688 /* QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT */
1689 tlvStruct->type = QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT ;
1690 tlvStruct->length = sizeof(tANI_U32);
1691 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1692 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_LINK_MONITOR_TIMEOUT,
1693 configDataValue ) != eSIR_SUCCESS)
1694 {
1695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1696 "Failed to get value for WNI_CFG_GO_LINK_MONITOR_TIMEOUT");
1697 goto handle_failure;
1698 }
1699 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1700 + sizeof(tHalCfg) + tlvStruct->length) ;
1701
Kiet Lam4bbd3cb2013-11-07 20:03:49 +0530[diff] [blame]1702 /* QWLAN_HAL_CFG_ATH_DISABLE */
1703 tlvStruct->type = QWLAN_HAL_CFG_ATH_DISABLE ;
1704 tlvStruct->length = sizeof(tANI_U32);
1705 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1706 if(wlan_cfgGetInt(pMac, WNI_CFG_ATH_DISABLE,
1707 configDataValue ) != eSIR_SUCCESS)
1708 {
1709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1710 "Failed to get value for WNI_CFG_ATH_DISABLE");
1711 goto handle_failure;
1712 }
1713 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1714 + sizeof(tHalCfg) + tlvStruct->length) ;
1715
c_hpothu6d7dc922013-12-02 12:36:41 +0530[diff] [blame]1716 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_WLAN_LEN */
1717 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1718 tlvStruct->length = sizeof(tANI_U32);
1719 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1720 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_WLAN_LEN,
1721 configDataValue ) != eSIR_SUCCESS)
1722 {
1723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1724 "Failed to get value for WNI_CFG_BTC_ACTIVE_WLAN_LEN");
1725 goto handle_failure;
1726 }
1727 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1728 + sizeof(tHalCfg) + tlvStruct->length) ;
1729
1730 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1731 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1732 tlvStruct->length = sizeof(tANI_U32);
1733 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1734 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_BT_LEN,
1735 configDataValue ) != eSIR_SUCCESS)
1736 {
1737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1738 "Failed to get value for WNI_CFG_BTC_ACTIVE_BT_LEN");
1739 goto handle_failure;
1740 }
1741 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1742 + sizeof(tHalCfg) + tlvStruct->length) ;
1743
1744 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN */
1745 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1746 tlvStruct->length = sizeof(tANI_U32);
1747 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1748 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,
1749 configDataValue ) != eSIR_SUCCESS)
1750 {
1751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1752 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN");
1753 goto handle_failure;
1754 }
1755 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1756 + sizeof(tHalCfg) + tlvStruct->length) ;
1757
1758 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1759 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1760 tlvStruct->length = sizeof(tANI_U32);
1761 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1762 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,
1763 configDataValue ) != eSIR_SUCCESS)
1764 {
1765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1766 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_BT_LEN");
1767 goto handle_failure;
1768 }
1769 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1770 + sizeof(tHalCfg) + tlvStruct->length) ;
1771
AnjaneeDevi Kapparapu50239e32014-01-07 18:09:33 +0530[diff] [blame]1772 /* QWLAN_HAL_CFG_ASD_PROBE_INTERVAL */
1773 tlvStruct->type = QWLAN_HAL_CFG_ASD_PROBE_INTERVAL ;
1774 tlvStruct->length = sizeof(tANI_U32);
1775 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1776 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_PROBE_INTERVAL,
1777 configDataValue ) != eSIR_SUCCESS)
1778 {
1779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1780 "Failed to get value for WNI_CFG_ASD_PROBE_INTERVAL");
1781 goto handle_failure;
1782 }
1783 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1784 + sizeof(tHalCfg) + tlvStruct->length) ;
1785
1786 /* QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD */
1787 tlvStruct->type = QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD ;
1788 tlvStruct->length = sizeof(tANI_U32);
1789 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1790 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_TRIGGER_THRESHOLD,
1791 configDataValue ) != eSIR_SUCCESS)
1792 {
1793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1794 "Failed to get value for WNI_CFG_ASD_TRIGGER_THRESHOLD");
1795 goto handle_failure;
1796 }
1797 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1798 + sizeof(tHalCfg) + tlvStruct->length) ;
1799
1800 /* QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD */
1801 tlvStruct->type = QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD ;
1802 tlvStruct->length = sizeof(tANI_U32);
1803 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1804 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD,
1805 configDataValue ) != eSIR_SUCCESS)
1806 {
1807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1808 "Failed to get value for WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD");
1809 goto handle_failure;
1810 }
1811 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1812 + sizeof(tHalCfg) + tlvStruct->length) ;
1813
Leela Venkata Kiran Kumar Reddy Chirala22c159b2013-12-23 18:19:13 -0800[diff] [blame]1814 /* QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO */
1815 tlvStruct->type = QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO ;
1816 tlvStruct->length = sizeof(tANI_U32);
1817 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1818 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CTS2S_DURING_SCO,
1819 configDataValue ) != eSIR_SUCCESS)
1820 {
1821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1822 "Failed to get value for WNI_CFG_BTC_CTS2S_DURING_SCO");
1823 goto handle_failure;
1824 }
1825 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1826 + sizeof(tHalCfg) + tlvStruct->length) ;
1827
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1828 /* QWLAN_HAL_CFG_RA_FILTER_ENABLE */
1829 tlvStruct->type = QWLAN_HAL_CFG_RA_FILTER_ENABLE ;
1830 tlvStruct->length = sizeof(tANI_U32);
1831 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1832
1833 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_FILTER_ENABLE,
1834 configDataValue ) != eSIR_SUCCESS)
1835 {
1836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1837 "Failed to get value for WNI_CFG_RA_FILTER_ENABLE");
1838 goto handle_failure;
1839 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1840 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1841 + sizeof(tHalCfg) + tlvStruct->length) ;
1842
1843 /* QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL */
1844 tlvStruct->type = QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL ;
1845 tlvStruct->length = sizeof(tANI_U32);
1846 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1847
1848 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_RATE_LIMIT_INTERVAL,
1849 configDataValue ) != eSIR_SUCCESS)
1850 {
1851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1852 "Failed to get value for WNI_CFG_RA_RATE_LIMIT_INTERVAL");
1853 goto handle_failure;
1854 }
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1855 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1856 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1857
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]1858 /* QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE */
1859 tlvStruct->type = QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE ;
1860 tlvStruct->length = sizeof(tANI_U32);
1861 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1862
1863 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE,
1864 configDataValue ) != eSIR_SUCCESS)
1865 {
1866 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1867 "Failed to get value for WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE");
1868 goto handle_failure;
1869 }
1870 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1871 + sizeof(tHalCfg) + tlvStruct->length) ;
1872
1873 /* QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE */
1874 tlvStruct->type = QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE ;
1875 tlvStruct->length = sizeof(tANI_U32);
1876 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1877
1878 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE,
1879 configDataValue ) != eSIR_SUCCESS)
1880 {
1881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1882 "Failed to get value for WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE");
1883 goto handle_failure;
1884 }
1885 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1886 + sizeof(tHalCfg) + tlvStruct->length) ;
1887
1888 /* QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD */
1889 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD ;
1890 tlvStruct->length = sizeof(tANI_U32);
1891 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1892
1893 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD,
1894 configDataValue ) != eSIR_SUCCESS)
1895 {
1896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1897 "Failed to get value for WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD");
1898 goto handle_failure;
1899 }
1900 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1901 + sizeof(tHalCfg) + tlvStruct->length) ;
1902
1903 /* QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD */
1904 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD ;
1905 tlvStruct->length = sizeof(tANI_U32);
1906 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1907
1908 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD,
1909 configDataValue ) != eSIR_SUCCESS)
1910 {
1911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1912 "Failed to get value for WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD");
1913 goto handle_failure;
1914 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1915 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1916 + sizeof(tHalCfg) + tlvStruct->length) ;
1917
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1918 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1919#ifdef WLAN_DEBUG
1920 {
1921 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1922 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1923 "****** Dumping CFG TLV ***** ");
1924 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
1925 {
1926 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1927 "%02x %02x %02x %02x %02x %02x %02x %02x",
1928 tlvStructStart[i],
1929 tlvStructStart[i+1],
1930 tlvStructStart[i+2],
1931 tlvStructStart[i+3],
1932 tlvStructStart[i+4],
1933 tlvStructStart[i+5],
1934 tlvStructStart[i+6],
1935 tlvStructStart[i+7]);
1936 }
1937 /* Dump the bytes in the last line*/
1938 for (; i < wdiStartParams->usConfigBufferLen; i++)
1939 {
1940 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1941 "%02x ",tlvStructStart[i]);
1942 }
1943 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
1944 "**************************** ");
1945 }
1946#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1947 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1948handle_failure:
1949 vos_mem_free(configParam);
1950 return VOS_STATUS_E_FAILURE;
1951}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1952/*
1953 * FUNCTION: WDA_wdiCompleteCB
1954 * call the voss call back function
1955 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1956void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1957{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1958 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
1959 tWDA_CbContext *wdaContext;
1960
1961 if(NULL == pWdaParams)
1962 {
1963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]1964 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1965 VOS_ASSERT(0) ;
1966 return ;
1967 }
1968
1969 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
1970
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1971 if (NULL == wdaContext)
1972 {
1973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]1974 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1975 return ;
1976 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1977
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1978 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1979 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1980 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1981 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1982 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1983 vos_mem_free(pWdaParams);
1984
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1985 if(WDI_STATUS_SUCCESS != status)
1986 {
1987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1988 "WDI stop callback returned failure" );
1989 VOS_ASSERT(0) ;
1990 }
1991 else
1992 {
1993 wdaContext->wdaState = WDA_STOP_STATE;
1994 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]1995
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]1996 /* FTM Driver stop procedure should be synced.
1997 * Stop and Close will happen on same context */
1998 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
1999 {
2000 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2001 {
2002 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2003 "%s: FTM Stop Event Set Fail", __func__);
2004 VOS_ASSERT(0);
2005 }
2006 }
2007
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2008 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2009 vos_WDAComplete_cback(wdaContext->pVosContext);
2010
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2011 return ;
2012}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2013/*
2014 * FUNCTION: WDA_stop
2015 * call WDI_stop
2016 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2017VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2018{
2019 WDI_Status wdiStatus;
2020 VOS_STATUS status = VOS_STATUS_SUCCESS;
2021 WDI_StopReqParamsType *wdiStopReq;
2022 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2023 tWDA_ReqParams *pWdaParams ;
2024
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2025 if (NULL == pWDA)
2026 {
2027 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2028 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2029 VOS_ASSERT(0);
2030 return VOS_STATUS_E_FAILURE;
2031 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2032 if (pWDA->wdiFailed == true)
2033 {
2034 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2035 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2036 return VOS_STATUS_E_ALREADY;
2037 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2038
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2039 /* FTM mode stay START_STATE */
2040 if( (WDA_READY_STATE != pWDA->wdaState) &&
2041 (WDA_INIT_STATE != pWDA->wdaState) &&
2042 (WDA_START_STATE != pWDA->wdaState) )
2043 {
2044 VOS_ASSERT(0);
2045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2046 wdiStopReq = (WDI_StopReqParamsType *)
2047 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2048 if(NULL == wdiStopReq)
2049 {
2050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2051 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2052 VOS_ASSERT(0);
2053 return VOS_STATUS_E_NOMEM;
2054 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2055
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2056 wdiStopReq->wdiStopReason = reason;
2057 wdiStopReq->wdiReqStatusCB = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2058
2059 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2060 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2061 {
2062 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2063 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2064 VOS_ASSERT(0);
2065 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2066 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2067 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2068
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2069 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2070 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2071 {
2072 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2073 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2074 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2075
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2076 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2077 pWdaParams->wdaMsgParam = NULL;
2078 pWdaParams->pWdaContext = pWDA;
2079
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2080 /* call WDI stop */
2081 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2082 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2083
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2084 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2085 {
2086 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2087 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2088 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2089 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2090 status = VOS_STATUS_E_FAILURE;
2091 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2092
2093 /* FTM Driver stop procedure should be synced.
2094 * Stop and Close will happen on same context */
2095 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2096 {
2097 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2098 WDI_RESPONSE_TIMEOUT);
2099 if (status != VOS_STATUS_SUCCESS)
2100 {
2101 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2102 "%s: FTM Stop Timepoout", __func__);
2103 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2104 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2105 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2106 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2107 return status;
2108}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2109/*
2110 * FUNCTION: WDA_close
2111 * call WDI_close and free the WDA context
2112 */
2113VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2114{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2115 VOS_STATUS status = VOS_STATUS_SUCCESS;
2116 WDI_Status wstatus;
2117 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2118 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2119 if (NULL == wdaContext)
2120 {
2121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2122 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2123 return VOS_STATUS_E_FAILURE;
2124 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2125 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2126 (WDA_STOP_STATE != wdaContext->wdaState))
2127 {
2128 VOS_ASSERT(0);
2129 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2130 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2131 wstatus = WDI_Close();
2132 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2133 {
2134 status = VOS_STATUS_E_FAILURE;
2135 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2136 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2137 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2138 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2139 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2140 {
2141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2142 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2143 status = VOS_STATUS_E_FAILURE;
2144 }
2145
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2146 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2147 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2148 {
2149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2150 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2151 status = VOS_STATUS_E_FAILURE;
2152 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2153 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2154 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2155 {
2156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2157 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2158 status = VOS_STATUS_E_FAILURE;
2159 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2160 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2161 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2162 {
2163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2164 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2165 status = VOS_STATUS_E_FAILURE;
2166 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2167 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2168 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2169 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2170 {
2171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2172 "error in WDA close " );
2173 status = VOS_STATUS_E_FAILURE;
2174 }
2175 return status;
2176}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2177/*
2178 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2179 * returns 1 if the compiled version is greater than or equal to the input version
2180 */
2181
2182uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2183{
2184 VOS_STATUS status = VOS_STATUS_SUCCESS;
2185 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2186 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2187 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2188 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2189 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2190 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2191 (compiledVersion.revision >= revision)))
2192 return 1;
2193 else
2194 return 0;
2195}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2196/*
2197 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2198 * returns 1 if the compiled version is greater than or equal to the input version
2199 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2200uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2201{
2202 VOS_STATUS status = VOS_STATUS_SUCCESS;
2203 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2204 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2205 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2206 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2207 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2208 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2209 (reportedVersion.revision >= revision)))
2210 return 1;
2211 else
2212 return 0;
2213}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2214/*
2215 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2216 * Returns the version of the WCNSS WLAN API with which the HOST
2217 * device driver was compiled
2218 */
2219VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2220 tSirVersionType *pVersion)
2221{
2222 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2223 if ((NULL == pvosGCtx) || (NULL == pVersion))
2224 {
2225 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2226 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2227 VOS_ASSERT(0);
2228 return VOS_STATUS_E_FAILURE;
2229 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2230 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2231 if (NULL == pWDA )
2232 {
2233 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2234 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2235 VOS_ASSERT(0);
2236 return VOS_STATUS_E_FAILURE;
2237 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2238 *pVersion = pWDA->wcnssWlanCompiledVersion;
2239 return VOS_STATUS_SUCCESS;
2240}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2241/*
2242 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2243 * Returns the version of the WCNSS WLAN API with which the WCNSS
2244 * device driver was compiled
2245 */
2246VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2247 tSirVersionType *pVersion)
2248{
2249 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2250 if ((NULL == pvosGCtx) || (NULL == pVersion))
2251 {
2252 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2253 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2254 VOS_ASSERT(0);
2255 return VOS_STATUS_E_FAILURE;
2256 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2257 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2258 if (NULL == pWDA )
2259 {
2260 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2261 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2262 VOS_ASSERT(0);
2263 return VOS_STATUS_E_FAILURE;
2264 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2265 *pVersion = pWDA->wcnssWlanReportedVersion;
2266 return VOS_STATUS_SUCCESS;
2267}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2268/*
2269 * FUNCTION: WDA_GetWcnssSoftwareVersion
2270 * Returns the WCNSS Software version string
2271 */
2272VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2273 tANI_U8 *pVersion,
2274 tANI_U32 versionBufferSize)
2275{
2276 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2277 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2278 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2279 if ((NULL == pvosGCtx) || (NULL == pVersion))
2280 {
2281 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2282 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2283 VOS_ASSERT(0);
2284 return VOS_STATUS_E_FAILURE;
2285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2286 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2287 if (NULL == pWDA )
2288 {
2289 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2290 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2291 VOS_ASSERT(0);
2292 return VOS_STATUS_E_FAILURE;
2293 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2294 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2295 return VOS_STATUS_SUCCESS;
2296}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2297/*
2298 * FUNCTION: WDA_GetWcnssHardwareVersion
2299 * Returns the WCNSS Hardware version string
2300 */
2301VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2302 tANI_U8 *pVersion,
2303 tANI_U32 versionBufferSize)
2304{
2305 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2306 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2307 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2308 if ((NULL == pvosGCtx) || (NULL == pVersion))
2309 {
2310 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2311 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2312 VOS_ASSERT(0);
2313 return VOS_STATUS_E_FAILURE;
2314 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2315 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2316 if (NULL == pWDA )
2317 {
2318 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2319 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2320 VOS_ASSERT(0);
2321 return VOS_STATUS_E_FAILURE;
2322 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2323 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2324 return VOS_STATUS_SUCCESS;
2325}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2326/*
2327 * FUNCTION: WDA_WniCfgDnld
2328 * Trigger CFG Download
2329 */
2330VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2331{
2332 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2333 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2334
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2335 if (NULL == pMac )
2336 {
2337 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2338 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2339 VOS_ASSERT(0);
2340 return VOS_STATUS_E_FAILURE;
2341 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2342 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2343 return vosStatus;
2344}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2345/* -----------------------------------------------------------------
2346 * WDI interface
2347 * -----------------------------------------------------------------
2348 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2349/*
2350 * FUNCTION: WDA_suspendDataTxCallback
2351 * call back function called from TL after suspend Transmission
2352 */
2353VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2354 v_U8_t* ucSTAId,
2355 VOS_STATUS vosStatus)
2356{
2357 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2359 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2360 if (NULL == pWDA )
2361 {
2362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2363 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2364 VOS_ASSERT(0);
2365 return VOS_STATUS_E_FAILURE;
2366 }
2367 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2368 {
2369 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2370 }
2371 else
2372 {
2373 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2374 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2375 /* Trigger the event to bring the WDA TL suspend function to come
2376 * out of wait*/
2377 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2378 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2379 {
2380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2381 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2382 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2383 /* If TL suspended had timedout before this callback was called, resume back
2384 * TL.*/
2385 if (pWDA->txSuspendTimedOut)
2386 {
2387 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2388 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2389 WDA_ResumeDataTx(pWDA);
2390 pWDA->txSuspendTimedOut = FALSE;
2391 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2392 return VOS_STATUS_SUCCESS;
2393}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2394/*
2395 * FUNCTION: WDA_suspendDataTx
2396 * Update TL to suspend the data Transmission
2397 */
2398VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2399{
2400 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2401 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2402
2403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2404 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2405 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2406 if (pWDA->txSuspendTimedOut)
2407 {
2408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2409 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2410 return status;
2411 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2412 /* Reset the event to be not signalled */
2413 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2414 if(!VOS_IS_STATUS_SUCCESS(status))
2415 {
2416 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2417 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2418 return VOS_STATUS_E_FAILURE;
2419 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2420 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2421 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2422 WDA_SuspendDataTxCallback);
2423 if(status != VOS_STATUS_SUCCESS)
2424 {
2425 return status;
2426 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2427 /* Wait for the event to be set by the TL, to get the response of
2428 * suspending the TX queues, this event should be set by the Callback
2429 * function called by TL*/
2430 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2431 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2432 if(!VOS_IS_STATUS_SUCCESS(status))
2433 {
2434 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2435 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2436 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2437 /* Set this flag to true when TL suspend times out, so that when TL
2438 * suspend eventually happens and calls the callback, TL can be resumed
2439 * right away by looking at this flag when true.*/
2440 pWDA->txSuspendTimedOut = TRUE;
2441 }
2442 else
2443 {
2444 pWDA->txSuspendTimedOut = FALSE;
2445 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2446 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2447 {
2448 status = VOS_STATUS_SUCCESS;
2449 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2450 return status;
2451}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2452/*
2453 * FUNCTION: WDA_resumeDataTx
2454 * Update TL to resume the data Transmission
2455 */
2456VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2457{
2458 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2459
2460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2461 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2462
2463 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2464 return status;
2465}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2466/*
2467 * FUNCTION: WDA_InitScanReqCallback
2468 * Trigger Init SCAN callback
2469 */
2470void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2471{
2472 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2473 tWDA_CbContext *pWDA;
2474 tInitScanParams *pWDA_ScanParam ;
2475 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2477 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2478 if(NULL == pWdaParams)
2479 {
2480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2481 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2482 VOS_ASSERT(0) ;
2483 return ;
2484 }
2485 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2486 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2487 if(NULL == pWDA_ScanParam)
2488 {
2489 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2490 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2491 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2492 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2493 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2494 return ;
2495 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2496 if(WDI_STATUS_SUCCESS != wdiStatus)
2497 {
2498 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2499 if(VOS_STATUS_SUCCESS != status)
2500 {
2501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2502 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2503 }
2504 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2505 /* free WDI command buffer */
2506 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2507 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2508
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2509
2510 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2511 /* without converting the Status to Failure or Success Just
2512 pass the same status to lim */
2513 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2514 /* send SCAN RSP message back to PE */
2515 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2516 return ;
2517}
2518
2519/*
2520 * FUNCTION: WDA_ProcessInitScanReq
2521 * Trigger Init SCAN in DAL
2522 */
2523VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2524 tInitScanParams *initScanParams)
2525{
2526 WDI_Status status = WDI_STATUS_SUCCESS ;
2527 WDI_InitScanReqParamsType *wdiInitScanParam =
2528 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2529 sizeof(WDI_InitScanReqParamsType)) ;
2530 tWDA_ReqParams *pWdaParams;
2531 tANI_U8 i = 0;
2532
2533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2534 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2535 if(NULL == wdiInitScanParam)
2536 {
2537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2538 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2539 VOS_ASSERT(0);
2540 return VOS_STATUS_E_NOMEM;
2541 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2542 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2543 if(NULL == pWdaParams)
2544 {
2545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2546 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2547 VOS_ASSERT(0);
2548 vos_mem_free(wdiInitScanParam);
2549 return VOS_STATUS_E_NOMEM;
2550 }
2551
2552 /* Copy init Scan params to WDI structure */
2553 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
2554 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
2555 sizeof(tSirMacAddr)) ;
2556 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
2557 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
2558 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2559 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
2560 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2561 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
2562 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2563 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
2564 {
2565 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2566 initScanParams->scanEntry.bssIdx[i] ;
2567 }
2568
2569 /* if Frame length, copy macMgmtHdr or WDI structure */
2570 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
2571 {
2572 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
2573 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
2574 }
2575 wdiInitScanParam->wdiReqStatusCB = NULL ;
2576
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2577 /* Store Init Req pointer, as this will be used for response */
2578 pWdaParams->pWdaContext = pWDA;
2579 pWdaParams->wdaMsgParam = initScanParams;
2580 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2581 /* first try to suspend TX */
2582 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2583 if(WDI_STATUS_SUCCESS != status)
2584 {
2585 goto handleWdiFailure;
2586 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2587 /* call DAL API to pass init scan request to DAL */
2588 status = WDI_InitScanReq(wdiInitScanParam,
2589 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2590 if(IS_WDI_STATUS_FAILURE(status))
2591 {
2592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2593 "error in WDA Init Scan, Resume Tx " );
2594 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2595 VOS_ASSERT(0) ;
2596
2597 goto handleWdiFailure;
2598 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2599 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2600handleWdiFailure:
2601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2602 "Failure in WDI Api, free all the memory " );
2603 /* free WDI command buffer */
2604 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2605 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2606 /* send Failure to PE */
2607 initScanParams->status = eSIR_FAILURE ;
2608 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2609 return CONVERT_WDI2VOS_STATUS(status) ;
2610}
2611
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2612/*
2613 * FUNCTION: WDA_StartScanReqCallback
2614 * send Start SCAN RSP back to PE
2615 */
2616void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
2617 void* pUserData)
2618{
2619 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2620 tWDA_CbContext *pWDA;
2621 tStartScanParams *pWDA_ScanParam;
2622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2623 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2624 if(NULL == pWdaParams)
2625 {
2626 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2627 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2628 VOS_ASSERT(0) ;
2629 return ;
2630 }
2631 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2632 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2633 if(NULL == pWDA_ScanParam)
2634 {
2635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2636 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2637 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2638 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2639 return ;
2640 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2641 if(NULL == pWdaParams->wdaWdiApiMsgParam)
2642 {
2643 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2644 "%s: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2645 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2646 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2647 return ;
2648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2649 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2650 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2651
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2652
2653 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2654 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2655 /* send SCAN RSP message back to PE */
2656 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2657 return ;
2658}
2659
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2660/*
2661 * FUNCTION: WDA_ProcessStartScanReq
2662 * Trigger start SCAN in WDI
2663 */
2664VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
2665 tStartScanParams *startScanParams)
2666{
2667 WDI_Status status = WDI_STATUS_SUCCESS;
2668 WDI_StartScanReqParamsType *wdiStartScanParams =
2669 (WDI_StartScanReqParamsType *)vos_mem_malloc(
2670 sizeof(WDI_StartScanReqParamsType)) ;
2671 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2673 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2674 if(NULL == wdiStartScanParams)
2675 {
2676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2677 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2678 VOS_ASSERT(0);
2679 return VOS_STATUS_E_NOMEM;
2680 }
2681 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2682 if(NULL == pWdaParams)
2683 {
2684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2685 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2686 VOS_ASSERT(0);
2687 vos_mem_free(wdiStartScanParams);
2688 return VOS_STATUS_E_NOMEM;
2689 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2690 /* Copy init Scan params to WDI structure */
2691 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
2692 wdiStartScanParams->wdiReqStatusCB = NULL ;
2693
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2694 /* Store Init Req pointer, as this will be used for response */
2695 /* store Params pass it to WDI */
2696 pWdaParams->pWdaContext = pWDA;
2697 pWdaParams->wdaMsgParam = startScanParams;
2698 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2699 /* call DAL API to pass init scan request to DAL */
2700 status = WDI_StartScanReq(wdiStartScanParams,
2701 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2702 /* failure returned by WDI API */
2703 if(IS_WDI_STATUS_FAILURE(status))
2704 {
2705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2706 "Failure in Start Scan WDI API, free all the memory "
2707 "It should be due to previous abort scan." );
2708 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2709 vos_mem_free(pWdaParams) ;
2710 startScanParams->status = eSIR_FAILURE ;
2711 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
2712 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2713 return CONVERT_WDI2VOS_STATUS(status) ;
2714}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2715/*
2716 * FUNCTION: WDA_EndScanReqCallback
2717 * END SCAN callback
2718 */
2719void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
2720{
2721 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2722 tWDA_CbContext *pWDA;
2723 tEndScanParams *endScanParam;
2724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2725 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2726 if(NULL == pWdaParams)
2727 {
2728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2729 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2730 VOS_ASSERT(0) ;
2731 return ;
2732 }
2733 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2734 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2735 if(NULL == endScanParam)
2736 {
2737 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2738 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2739 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2740 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2741 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2742 return ;
2743 }
2744
2745 /* Free WDI command buffer */
2746 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2747 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2748 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2749 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2750 /* send response back to PE */
2751 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
2752 return ;
2753}
2754
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2755/*
2756 * FUNCTION: WDA_ProcessEndScanReq
2757 * Trigger END SCAN in WDI
2758 */
2759VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
2760 tEndScanParams *endScanParams)
2761{
2762 WDI_Status status = WDI_STATUS_SUCCESS;
2763 WDI_EndScanReqParamsType *wdiEndScanParams =
2764 (WDI_EndScanReqParamsType *)vos_mem_malloc(
2765 sizeof(WDI_EndScanReqParamsType)) ;
2766 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2767 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2768 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2769 if(NULL == wdiEndScanParams)
2770 {
2771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2772 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2773 VOS_ASSERT(0);
2774 return VOS_STATUS_E_NOMEM;
2775 }
2776 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2777 if(NULL == pWdaParams)
2778 {
2779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2780 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2781 VOS_ASSERT(0);
2782 vos_mem_free(wdiEndScanParams);
2783 return VOS_STATUS_E_NOMEM;
2784 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2785 /* Copy init Scan params to WDI structure */
2786 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
2787 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2788 /* Store Init Req pointer, as this will be used for response */
2789 /* store Params pass it to WDI */
2790 pWdaParams->pWdaContext = pWDA;
2791 pWdaParams->wdaMsgParam = endScanParams;
2792 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2793 /* call DAL API to pass init scan request to DAL */
2794 status = WDI_EndScanReq(wdiEndScanParams,
2795 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2796 if(IS_WDI_STATUS_FAILURE(status))
2797 {
2798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2799 "Failure in End Scan WDI API, free all the memory "
2800 "It should be due to previous abort scan." );
2801 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2802 vos_mem_free(pWdaParams) ;
2803 endScanParams->status = eSIR_FAILURE ;
2804 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
2805 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2806 return CONVERT_WDI2VOS_STATUS(status) ;
2807}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2808/*
2809 * FUNCTION: WDA_FinishScanReqCallback
2810 * Trigger Finish SCAN callback
2811 */
2812void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2813{
2814 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2815 tWDA_CbContext *pWDA;
2816 tFinishScanParams *finishScanParam;
2817 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2819 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2820 if(NULL == pWdaParams)
2821 {
2822 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2823 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2824 VOS_ASSERT(0) ;
2825 return ;
2826 }
2827
2828 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2829 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2830 if(NULL == finishScanParam)
2831 {
2832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2833 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2834 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2835 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2836 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2837 return ;
2838 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2839 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2840 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2841 /*
2842 * Now Resume TX, if we reached here means, TX is already suspended, we
2843 * have to resume it unconditionaly
2844 */
2845 status = WDA_ResumeDataTx(pWDA) ;
2846
2847 if(VOS_STATUS_SUCCESS != status)
2848 {
2849 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2850 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2851 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2852 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2853 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
2854 return ;
2855}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2856/*
2857 * FUNCTION: WDA_ProcessFinshScanReq
2858 * Trigger Finish SCAN in WDI
2859 */
2860VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
2861 tFinishScanParams *finishScanParams)
2862{
2863 WDI_Status status = WDI_STATUS_SUCCESS;
2864 WDI_FinishScanReqParamsType *wdiFinishScanParams =
2865 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
2866 sizeof(WDI_FinishScanReqParamsType)) ;
2867 tWDA_ReqParams *pWdaParams ;
2868 tANI_U8 i = 0;
2869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2870 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2871 if(NULL == wdiFinishScanParams)
2872 {
2873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2874 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2875 VOS_ASSERT(0);
2876 return VOS_STATUS_E_NOMEM;
2877 }
2878 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2879 if(NULL == pWdaParams)
2880 {
2881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2882 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2883 VOS_ASSERT(0);
2884 vos_mem_free(wdiFinishScanParams);
2885 return VOS_STATUS_E_NOMEM;
2886 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2887 /* Copy init Scan params to WDI structure */
2888 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
2889 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
2890 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2891 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
2892 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
2893 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
2894 finishScanParams->frameLength ;
2895 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
2896 finishScanParams->currentOperChannel ;
2897 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
2898 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
2899 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2900 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
2901 {
2902 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
2903 finishScanParams->scanEntry.bssIdx[i] ;
2904 }
2905
2906
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2907 /* if Frame length, copy macMgmtHdr ro WDI structure */
2908 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
2909 {
2910 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
2911 &finishScanParams->macMgmtHdr,
2912 sizeof(WDI_MacMgmtHdr)) ;
2913 }
2914 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2915 /* Store Init Req pointer, as this will be used for response */
2916 /* store Params pass it to WDI */
2917 pWdaParams->pWdaContext = pWDA;
2918 pWdaParams->wdaMsgParam = finishScanParams;
2919 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2920 /* call DAL API to pass init scan request to DAL */
2921 status = WDI_FinishScanReq(wdiFinishScanParams,
2922 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2923
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2924
2925 /*
2926 * WDI API returns failure..
2927 */
2928 if(IS_WDI_STATUS_FAILURE( status))
2929 {
2930 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2931 "Failure in Finish Scan WDI API, free all the memory " );
2932 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2933 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2934 finishScanParams->status = eSIR_FAILURE ;
2935 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
2936 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2937 return CONVERT_WDI2VOS_STATUS(status) ;
2938}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2939/*---------------------------------------------------------------------
2940 * ASSOC API's
2941 *---------------------------------------------------------------------
2942 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2943/*
2944 * FUNCTION: WDA_JoinReqCallback
2945 * Trigger Init SCAN callback
2946 */
2947void WDA_JoinReqCallback(WDI_Status status, void* pUserData)
2948{
2949 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2950 tWDA_CbContext *pWDA;
2951 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2953 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2954 if(NULL == pWdaParams)
2955 {
2956 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2957 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2958 VOS_ASSERT(0) ;
2959 return ;
2960 }
2961 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2962 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2963 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
2964 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2965 /* reset macBSSID */
2966 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2967 /* reset macSTASelf */
2968 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2969 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2970 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2971 return ;
2972}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2973/*
2974 * FUNCTION: WDA_ProcessJoinReq
2975 * Trigger Join REQ in WDI
2976 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2977VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
2978 tSwitchChannelParams* joinReqParam)
2979{
2980 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2981 WDI_JoinReqParamsType *wdiJoinReqParam =
2982 (WDI_JoinReqParamsType *)vos_mem_malloc(
2983 sizeof(WDI_JoinReqParamsType)) ;
2984 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2986 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2987 if(NULL == wdiJoinReqParam)
2988 {
2989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2990 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2991 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]2992 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2993 return VOS_STATUS_E_NOMEM;
2994 }
2995 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2996 if(NULL == pWdaParams)
2997 {
2998 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2999 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3000 VOS_ASSERT(0);
3001 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3002 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3003 return VOS_STATUS_E_NOMEM;
3004 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3005
3006 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3007 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3008 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3009 {
3010 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3011 "%s: received join request when BSSID or self-STA is NULL "
3012 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3013 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3014 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3015 VOS_ASSERT(0);
3016 vos_mem_free(wdiJoinReqParam);
3017 vos_mem_free(pWdaParams);
3018 joinReqParam->status = eSIR_FAILURE ;
3019 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3020 return VOS_STATUS_E_INVAL;
3021 }
3022
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3023 /* copy the BSSID for pWDA */
3024 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3025 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3026 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3027 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3028 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3029 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3030#ifdef WLAN_FEATURE_VOWIFI
3031 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3032 joinReqParam->maxTxPower ;
3033#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3034 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3035 joinReqParam->localPowerConstraint ;
3036#endif
3037 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3038 joinReqParam->secondaryChannelOffset ;
3039 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3040
3041 wdiJoinReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3042 /* Store Init Req pointer, as this will be used for response */
3043 /* store Params pass it to WDI */
3044 pWdaParams->pWdaContext = pWDA;
3045 pWdaParams->wdaMsgParam = joinReqParam;
3046 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3047 status = WDI_JoinReq(wdiJoinReqParam,
3048 (WDI_JoinRspCb )WDA_JoinReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3049 if(IS_WDI_STATUS_FAILURE(status))
3050 {
3051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3052 "Failure in Join WDI API, free all the memory " );
3053 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3054 vos_mem_free(pWdaParams) ;
3055 joinReqParam->status = eSIR_FAILURE ;
3056 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3057 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3058 return CONVERT_WDI2VOS_STATUS(status) ;
3059}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3060/*
3061 * FUNCTION: WDA_SwitchChannelReqCallback
3062 * send Switch channel RSP back to PE
3063 */
3064void WDA_SwitchChannelReqCallback(
3065 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3066{
3067 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3068 tWDA_CbContext *pWDA;
3069 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3071 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3072 if(NULL == pWdaParams)
3073 {
3074 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3075 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3076 VOS_ASSERT(0) ;
3077 return ;
3078 }
3079 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3080 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3081
3082#ifdef WLAN_FEATURE_VOWIFI
3083 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3084#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3085 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3086 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3087 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3088 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3089 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3090 return ;
3091}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3092/*
3093 * FUNCTION: WDA_ProcessChannelSwitchReq
3094 * Request to WDI to switch channel REQ params.
3095 */
3096VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3097 tSwitchChannelParams *pSwitchChanParams)
3098{
3099 WDI_Status status = WDI_STATUS_SUCCESS ;
3100 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3101 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3102 sizeof(WDI_SwitchChReqParamsType)) ;
3103 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3105 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3106 if(NULL == wdiSwitchChanParam)
3107 {
3108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3109 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3110 VOS_ASSERT(0);
3111 return VOS_STATUS_E_NOMEM;
3112 }
3113 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3114 if(NULL == pWdaParams)
3115 {
3116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3117 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3118 VOS_ASSERT(0);
3119 vos_mem_free(wdiSwitchChanParam);
3120 return VOS_STATUS_E_NOMEM;
3121 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3122 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3123#ifndef WLAN_FEATURE_VOWIFI
3124 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3125 pSwitchChanParams->localPowerConstraint;
3126#endif
3127 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3128 pSwitchChanParams->secondaryChannelOffset;
3129 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3130 /* Store req pointer, as this will be used for response */
3131 /* store Params pass it to WDI */
3132 pWdaParams->pWdaContext = pWDA;
3133 pWdaParams->wdaMsgParam = pSwitchChanParams;
3134 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3135#ifdef WLAN_FEATURE_VOWIFI
3136 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3137 = pSwitchChanParams->maxTxPower;
3138 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3139 pSwitchChanParams ->selfStaMacAddr,
3140 sizeof(tSirMacAddr));
3141#endif
3142 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3143 pSwitchChanParams->bssId,
3144 sizeof(tSirMacAddr));
3145
3146 status = WDI_SwitchChReq(wdiSwitchChanParam,
3147 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3148 if(IS_WDI_STATUS_FAILURE(status))
3149 {
3150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3151 "Failure in process channel switch Req WDI API, free all the memory " );
3152 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3153 vos_mem_free(pWdaParams) ;
3154 pSwitchChanParams->status = eSIR_FAILURE ;
3155 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3156 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3157 return CONVERT_WDI2VOS_STATUS(status) ;
3158}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3159
3160/*
3161 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3162 * send Switch channel RSP back to PE
3163 */
3164void WDA_SwitchChannelReqCallback_V1(
3165 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3166 void* pUserData)
3167{
3168 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3169 tWDA_CbContext *pWDA;
3170 tSwitchChannelParams *pSwitchChanParams;
3171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3172 "<------ %s " ,__func__);
3173
3174 if (NULL == pWdaParams)
3175 {
3176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3177 "%s: pWdaParams received NULL", __func__);
3178 VOS_ASSERT(0);
3179 return ;
3180 }
3181 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3182 pSwitchChanParams =
3183 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3184 pSwitchChanParams->channelSwitchSrc =
3185 wdiSwitchChanRsp->channelSwitchSrc;
3186#ifdef WLAN_FEATURE_VOWIFI
3187 pSwitchChanParams->txMgmtPower =
3188 wdiSwitchChanRsp->ucTxMgmtPower;
3189#endif
3190 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3191 vos_mem_free(pWdaParams);
3192 pSwitchChanParams->status =
3193 wdiSwitchChanRsp->wdiStatus ;
3194 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3195 (void *)pSwitchChanParams , 0);
3196 return;
3197}
3198
3199/*
3200 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3201 * Request to WDI to switch channel REQ params.
3202 */
3203VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3204 tSwitchChannelParams *pSwitchChanParams)
3205{
3206 WDI_Status status = WDI_STATUS_SUCCESS ;
3207 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3208 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3209 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3210 tWDA_ReqParams *pWdaParams ;
3211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3212 "------> %s " ,__func__);
3213 if (NULL == wdiSwitchChanParam)
3214 {
3215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3216 "%s: VOS MEM Alloc Failure", __func__);
3217 VOS_ASSERT(0);
3218 return VOS_STATUS_E_NOMEM;
3219 }
3220 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3221 if (NULL == pWdaParams)
3222 {
3223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3224 "%s: VOS MEM Alloc Failure", __func__);
3225 VOS_ASSERT(0);
3226 vos_mem_free(wdiSwitchChanParam);
3227 return VOS_STATUS_E_NOMEM;
3228 }
3229 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3230 pSwitchChanParams->channelSwitchSrc;
3231
3232 wdiSwitchChanParam->wdiChInfo.ucChannel =
3233 pSwitchChanParams->channelNumber;
3234#ifndef WLAN_FEATURE_VOWIFI
3235 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3236 pSwitchChanParams->localPowerConstraint;
3237#endif
3238 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3239 pSwitchChanParams->secondaryChannelOffset;
3240 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3241 /* Store req pointer, as this will be used for response */
3242 /* store Params pass it to WDI */
3243 pWdaParams->pWdaContext = pWDA;
3244 pWdaParams->wdaMsgParam = pSwitchChanParams;
3245 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3246#ifdef WLAN_FEATURE_VOWIFI
3247 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3248 pSwitchChanParams->maxTxPower;
3249 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3250 pSwitchChanParams ->selfStaMacAddr,
3251 sizeof(tSirMacAddr));
3252#endif
3253 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3254 pSwitchChanParams->bssId,
3255 sizeof(tSirMacAddr));
3256
3257 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3258 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3259 pWdaParams);
3260 if (IS_WDI_STATUS_FAILURE(status))
3261 {
3262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3263 "Failure in process channel switch Req WDI "
3264 "API, free all the memory " );
3265 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3266 vos_mem_free(pWdaParams) ;
3267 pSwitchChanParams->status = eSIR_FAILURE ;
3268 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3269 (void *)pSwitchChanParams, 0) ;
3270 }
3271 return CONVERT_WDI2VOS_STATUS(status) ;
3272}
3273
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3274/*
3275 * FUNCTION: WDA_ConfigBssReqCallback
3276 * config BSS Req Callback, called by WDI
3277 */
3278void WDA_ConfigBssReqCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
3279 ,void* pUserData)
3280{
3281 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3282 tWDA_CbContext *pWDA;
3283 tAddBssParams *configBssReqParam;
3284 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3285 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3286 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3287 if(NULL == pWdaParams)
3288 {
3289 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3290 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3291 VOS_ASSERT(0) ;
3292 return ;
3293 }
3294 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3295 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3296 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3297 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3298 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3299 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3300 {
3301 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3302 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3303 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3304 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3305 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3306
3307 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3308 {
3309 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3310 {
3311 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3312 staConfigBssParam->staType = STA_ENTRY_BSSID;
3313 }
3314 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3315 (staConfigBssParam->staType == STA_ENTRY_SELF))
3316 {
3317 /* This is the 1st add BSS Req for the BTAMP STA */
3318 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3319 staConfigBssParam->staType = STA_ENTRY_BSSID;
3320 }
3321 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3322 (staConfigBssParam->staType == STA_ENTRY_PEER))
3323 {
3324 /* This is the 2nd ADD BSS Request that is sent
3325 * on the BTAMP STA side. The Sta type is
3326 * set to STA_ENTRY_PEER here.*/
3327 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3328 }
3329 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3330 (staConfigBssParam->staType == STA_ENTRY_SELF))
3331 {
3332 /* statype is already set by PE.
3333 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3334 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3335 staConfigBssParam->staType = STA_ENTRY_BSSID;
3336 }
3337 else
3338 {
3339 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3340 staConfigBssParam->staType = STA_ENTRY_PEER;
3341 }
3342 }
3343 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3344 {
3345 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3346 staConfigBssParam->staType = STA_ENTRY_SELF;
3347 }
3348 else
3349 {
3350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3351 "Invalid operation mode specified");
3352 VOS_ASSERT(0);
3353 }
3354
3355 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3356 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3357 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3358 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3359 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3360 sizeof(tSirMacAddr));
3361 staConfigBssParam->txChannelWidthSet =
3362 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3363 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3364 staConfigBssParam->htCapable)
3365 {
3366 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3367 wdiConfigBssRsp->ucBSSIdx;
3368 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3369 WDA_VALID_STA_INDEX ;
3370 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3371 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3372 wdiConfigBssRsp->ucBSSIdx,
3373 wdiConfigBssRsp->ucSTAIdx))
3374 {
3375 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3376 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3377 VOS_ASSERT(0) ;
3378 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3379 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3380 {
3381 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3382 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3383 VOS_ASSERT(0) ;
3384 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3385#ifdef WLAN_FEATURE_VOWIFI
3386 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3387#endif
3388 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3389 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3390 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3391 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3392 return ;
3393}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3394/*
3395 * FUNCTION: WDA_UpdateEdcaParamsForAC
3396 * Update WDI EDCA params with PE edca params
3397 */
3398void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3399 WDI_EdcaParamRecord *wdiEdcaParam,
3400 tSirMacEdcaParamRecord *macEdcaParam)
3401{
3402 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3403 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3404 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3405 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3406 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3407 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3408}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3409/*
3410 * FUNCTION: WDA_ProcessConfigBssReq
3411 * Configure BSS before starting Assoc with AP
3412 */
3413VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3414 tAddBssParams* configBssReqParam)
3415{
3416 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3417 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3418 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3420 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3421 if (NULL == configBssReqParam)
3422 {
3423 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3424 "%s: configBssReqParam is NULL", __func__);
3425 return VOS_STATUS_E_INVAL;
3426 }
3427
3428 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3429 sizeof(WDI_ConfigBSSReqParamsType)) ;
3430
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3431 if(NULL == wdiConfigBssReqParam)
3432 {
3433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3434 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3435 VOS_ASSERT(0);
3436 return VOS_STATUS_E_NOMEM;
3437 }
3438 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3439 if(NULL == pWdaParams)
3440 {
3441 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3442 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3443 VOS_ASSERT(0);
3444 vos_mem_free(wdiConfigBssReqParam);
3445 return VOS_STATUS_E_NOMEM;
3446 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3447 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3448 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3449 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3450 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3451 configBssReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3452 /* Store Init Req pointer, as this will be used for response */
3453 /* store Params pass it to WDI */
3454 pWdaParams->pWdaContext = pWDA;
3455 pWdaParams->wdaMsgParam = configBssReqParam;
3456 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3457 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
3458 (WDI_ConfigBSSRspCb )WDA_ConfigBssReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3459 if(IS_WDI_STATUS_FAILURE(status))
3460 {
3461 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3462 "Failure in Config BSS WDI API, free all the memory " );
3463 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3464 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3465 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3466 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
3467 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3468 return CONVERT_WDI2VOS_STATUS(status) ;
3469}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3470#ifdef ENABLE_HAL_COMBINED_MESSAGES
3471/*
3472 * FUNCTION: WDA_PostAssocReqCallback
3473 * Post ASSOC req callback, send RSP back to PE
3474 */
3475void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
3476 void* pUserData)
3477{
3478 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
3479 tPostAssocParams *postAssocReqParam =
3480 (tPostAssocParams *)pWDA->wdaMsgParam ;
3481 /*STA context within the BSS Params*/
3482 tAddStaParams *staPostAssocParam =
3483 &postAssocReqParam->addBssParams.staContext ;
3484 /*STA Params for self STA*/
3485 tAddStaParams *selfStaPostAssocParam =
3486 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3487 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3488 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3489 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3490 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3491 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
3492 {
3493 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
3494 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
3495 sizeof(tSirMacAddr)) ;
3496 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
3497 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
3498 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3499 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
3500 }
3501 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3502 pWDA->wdaWdiApiMsgParam = NULL;
3503 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3504 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3505 return ;
3506}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3507/*
3508 * FUNCTION: WDA_ProcessPostAssocReq
3509 * Trigger POST ASSOC processing in WDI
3510 */
3511VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
3512 tPostAssocParams *postAssocReqParam)
3513{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3514 WDI_Status status = WDI_STATUS_SUCCESS ;
3515
3516 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
3517 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
3518 sizeof(WDI_PostAssocReqParamsType)) ;
3519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3520 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3521
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3522 if(NULL == wdiPostAssocReqParam)
3523 {
3524 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3525 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3526 VOS_ASSERT(0);
3527 return VOS_STATUS_E_NOMEM;
3528 }
3529
3530 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
3531 {
3532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3533 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3534 VOS_ASSERT(0);
3535 return VOS_STATUS_E_FAILURE;
3536 }
3537
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3538 /* update BSS params into WDI structure */
3539 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
3540 &postAssocReqParam->addBssParams) ;
3541 /* update STA params into WDI structure */
3542 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
3543 &postAssocReqParam->addStaParams) ;
3544
3545 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
3546 postAssocReqParam->addBssParams.highPerformance;
3547 WDA_UpdateEdcaParamsForAC(pWDA,
3548 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
3549 &postAssocReqParam->addBssParams.acbe);
3550 WDA_UpdateEdcaParamsForAC(pWDA,
3551 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
3552 &postAssocReqParam->addBssParams.acbk);
3553 WDA_UpdateEdcaParamsForAC(pWDA,
3554 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
3555 &postAssocReqParam->addBssParams.acvi);
3556 WDA_UpdateEdcaParamsForAC(pWDA,
3557 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
3558 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3559 /* Store Init Req pointer, as this will be used for response */
3560 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3561 /* store Params pass it to WDI */
3562 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3563 status = WDI_PostAssocReq(wdiPostAssocReqParam,
3564 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3565 if(IS_WDI_STATUS_FAILURE(status))
3566 {
3567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3568 "Failure in Post Assoc WDI API, free all the memory " );
3569 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
3570 pWDA->wdaWdiApiMsgParam = NULL;
3571 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3572 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3573 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
3574 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3575 return CONVERT_WDI2VOS_STATUS(status) ;
3576}
3577#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3578/*
3579 * FUNCTION: WDA_AddStaReqCallback
3580 * ADD STA req callback, send RSP back to PE
3581 */
3582void WDA_AddStaReqCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
3583 void* pUserData)
3584{
3585 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3586 tWDA_CbContext *pWDA;
3587 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3589 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3590 if(NULL == pWdaParams)
3591 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3592 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]3593 VOS_ASSERT(0) ;
3594 return ;
3595 }
3596 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3597 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3598 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3599 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3600 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
3601 {
3602 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
3603 /*TODO: UMAC structure doesn't have these fields*/
3604 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
3605 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
3606 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
3607 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
3608 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
3609 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3610#ifdef FEATURE_WLAN_TDLS
3611 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
3612 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
3613#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3614 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]3615#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3616 {
3617 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
3618 wdiConfigStaRsp->ucBssIdx;
3619 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
3620 WDA_VALID_STA_INDEX ;
3621 }
3622 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
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: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3626 VOS_ASSERT(0) ;
3627 return ;
3628 }
3629 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3630 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3631 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3632 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3633 return ;
3634}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3635/*
3636 * FUNCTION: WDA_ConfigStaReq
3637 * Trigger Config STA processing in WDI
3638 */
3639VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
3640 tAddStaParams *addStaReqParam)
3641{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3642 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3643 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
3644 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
3645 sizeof(WDI_ConfigSTAReqParamsType)) ;
3646 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3647 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3648 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3649 if(NULL == wdiConfigStaReqParam)
3650 {
3651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3652 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3653 VOS_ASSERT(0);
3654 return VOS_STATUS_E_NOMEM;
3655 }
3656 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3657 if(NULL == pWdaParams)
3658 {
3659 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3660 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3661 VOS_ASSERT(0);
3662 vos_mem_free(wdiConfigStaReqParam);
3663 return VOS_STATUS_E_NOMEM;
3664 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3665 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3666 /* update STA params into WDI structure */
3667 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
3668 addStaReqParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3669 /* Store Init Req pointer, as this will be used for response */
3670 /* store Params pass it to WDI */
3671 pWdaParams->pWdaContext = pWDA;
3672 pWdaParams->wdaMsgParam = addStaReqParam;
3673 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3674 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
3675 (WDI_ConfigSTARspCb )WDA_AddStaReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3676 if(IS_WDI_STATUS_FAILURE(status))
3677 {
3678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3679 "Failure in Config STA WDI API, free all the memory " );
3680 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3681 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3682 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3683 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
3684 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3685 return CONVERT_WDI2VOS_STATUS(status) ;
3686}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3687/*
3688 * FUNCTION: WDA_DelBSSReqCallback
3689 * Dens DEL BSS RSP back to PE
3690 */
3691void WDA_DelBSSReqCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
3692 void* pUserData)
3693{
3694 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3695 tWDA_CbContext *pWDA;
3696 tDeleteBssParams *delBssReqParam;
3697 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3698 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3699 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3700 if(NULL == pWdaParams)
3701 {
3702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3703 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3704 VOS_ASSERT(0) ;
3705 return ;
3706 }
3707 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3708 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3709 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3710 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
3711 {
3712 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
3713 sizeof(tSirMacAddr)) ;
3714 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3715 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
3716 {
3717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3718 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3719 VOS_ASSERT(0) ;
3720 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3721 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
3722 {
3723 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3724 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3725 VOS_ASSERT(0) ;
3726 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3727 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
3728 {
3729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3730 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3731 VOS_ASSERT(0) ;
3732 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3733
3734 WLANTL_StartForwarding(staIdx,0,0);
3735
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3736 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3737 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3738 /* reset the the system role*/
3739 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
3740
3741 /* Reset the BA related information */
3742 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
3743 {
3744 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
3745 {
3746 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
3747 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
3748 /* Reset framesTxed counters here */
3749 for(tid = 0; tid < STACFG_MAX_TC; tid++)
3750 {
3751 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
3752 }
3753 }
3754 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3755 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3756 return ;
3757}
3758
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3759/*
3760 * FUNCTION: WDA_ProcessDelBssReq
3761 * Init DEL BSS req with WDI
3762 */
3763VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
3764 tDeleteBssParams *delBssParam)
3765{
3766 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3767 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
3768 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
3769 sizeof(WDI_DelBSSReqParamsType)) ;
3770 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3772 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3773 if(NULL == wdiDelBssReqParam)
3774 {
3775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3776 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3777 VOS_ASSERT(0);
3778 return VOS_STATUS_E_NOMEM;
3779 }
3780 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3781 if(NULL == pWdaParams)
3782 {
3783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3784 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3785 VOS_ASSERT(0);
3786 vos_mem_free(wdiDelBssReqParam);
3787 return VOS_STATUS_E_NOMEM;
3788 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3789 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
3790 wdiDelBssReqParam->wdiReqStatusCB = NULL ;
3791
3792 /* Store Init Req pointer, as this will be used for response */
3793 /* store Params pass it to WDI */
3794 pWdaParams->pWdaContext = pWDA;
3795 pWdaParams->wdaMsgParam = delBssParam;
3796 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3797 status = WDI_DelBSSReq(wdiDelBssReqParam,
3798 (WDI_DelBSSRspCb )WDA_DelBSSReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3799 if(IS_WDI_STATUS_FAILURE(status))
3800 {
3801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3802 "Failure in Del BSS WDI API, free all the memory " );
3803 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3804 vos_mem_free(pWdaParams) ;
3805 delBssParam->status = eSIR_FAILURE ;
3806 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
3807 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3808 return CONVERT_WDI2VOS_STATUS(status) ;
3809}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3810/*
3811 * FUNCTION: WDA_DelSTAReqCallback
3812 * Dens DEL STA RSP back to PE
3813 */
3814void WDA_DelSTAReqCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
3815 void* pUserData)
3816{
3817 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3818 tWDA_CbContext *pWDA;
3819 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3820 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3821 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3822 if(NULL == pWdaParams)
3823 {
3824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3825 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3826 VOS_ASSERT(0) ;
3827 return ;
3828 }
3829 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3830 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3831 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3832 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
3833 {
3834 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
3835 {
3836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3837 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3838 VOS_ASSERT(0) ;
3839 }
3840 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]3841 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3842 }
3843 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3844 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3845 /*Reset the BA information corresponding to this STAIdx */
3846 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
3847 WDA_INVALID_STA_INDEX;
3848 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
3849
3850 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3851 return ;
3852}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3853/*
3854 * FUNCTION: WDA_ProcessDelStaReq
3855 * Init DEL STA req with WDI
3856 */
3857VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
3858 tDeleteStaParams *delStaParam)
3859{
3860 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3861 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
3862 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
3863 sizeof(WDI_DelSTAReqParamsType)) ;
3864 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3866 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3867 if(NULL == wdiDelStaReqParam)
3868 {
3869 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3870 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3871 VOS_ASSERT(0);
3872 return VOS_STATUS_E_NOMEM;
3873 }
3874 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3875 if(NULL == pWdaParams)
3876 {
3877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3878 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3879 VOS_ASSERT(0);
3880 vos_mem_free(wdiDelStaReqParam);
3881 return VOS_STATUS_E_NOMEM;
3882 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3883 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
3884 wdiDelStaReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3885 /* Store Init Req pointer, as this will be used for response */
3886 /* store Params pass it to WDI */
3887 pWdaParams->pWdaContext = pWDA;
3888 pWdaParams->wdaMsgParam = delStaParam;
3889 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3890 status = WDI_DelSTAReq(wdiDelStaReqParam,
3891 (WDI_DelSTARspCb )WDA_DelSTAReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3892 if(IS_WDI_STATUS_FAILURE(status))
3893 {
3894 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3895 "Failure in Del STA WDI API, free all the memory status = %d",
3896 status );
3897 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3898 vos_mem_free(pWdaParams) ;
3899 delStaParam->status = eSIR_FAILURE ;
3900 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
3901 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3902 return CONVERT_WDI2VOS_STATUS(status) ;
3903}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3904void WDA_ProcessAddStaSelfRsp(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
3905{
3906 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3907 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3908 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3909 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3910 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3911 if(NULL == pWdaParams)
3912 {
3913 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3914 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3915 VOS_ASSERT(0) ;
3916 return ;
3917 }
3918 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3919 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3920 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3921 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3922 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
3923 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
3924 pwdiAddSTASelfRsp->macSelfSta,
3925 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3926 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
3927 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
3928 if (pAddStaSelfRsp->status == eSIR_FAILURE)
3929 {
3930 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
3931 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
3932 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3933 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3934 return ;
3935}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3936
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3937/*
3938 * FUNCTION: WDA_ProcessAddStaSelfReq
3939 *
3940 */
3941VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
3942{
3943 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3944 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3945 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
3946 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
3947 sizeof(WDI_AddSTASelfReqParamsType)) ;
3948 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3950 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3951 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3952 if( NULL == wdiAddStaSelfReq )
3953 {
3954 VOS_ASSERT( 0 );
3955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3956 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3957 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
3958 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3959 return( VOS_STATUS_E_NOMEM );
3960 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3961 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3962 if( NULL == pWdaParams )
3963 {
3964 VOS_ASSERT( 0 );
3965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3966 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3967 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
3968 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3969 vos_mem_free(wdiAddStaSelfReq) ;
3970 return( VOS_STATUS_E_NOMEM );
3971 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3972 wdiAddStaSelfReq->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3973 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]3974 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3975 /* Store Init Req pointer, as this will be used for response */
3976 /* store Params pass it to WDI */
3977 pWdaParams->pWdaContext = pWDA;
3978 pWdaParams->wdaMsgParam = pAddStaSelfReq;
3979 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3980 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq, WDA_ProcessAddStaSelfRsp, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3981
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3982 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3983 {
3984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3985 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3986 wstatus );
3987 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3988 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3989 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]3990 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
3991 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3992 pAddStaSelfReq->status = eSIR_FAILURE ;
3993 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
3994 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]3995 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3996}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3997/*
3998 * FUNCTION: WDA_DelSTASelfRespCallback
3999 *
4000 */
4001void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4002 wdiDelStaSelfRspParams , void* pUserData)
4003{
4004 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4005 tWDA_CbContext *pWDA;
4006 tDelStaSelfParams *delStaSelfParams;
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: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4013 VOS_ASSERT(0);
4014 return;
4015 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4016 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4017 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4018 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4019 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4020
4021 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4022 vos_mem_free(pWdaParams) ;
4023
4024 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4025 return ;
4026}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4027/*
4028 * FUNCTION: WDA_DelSTASelfReqCallback
4029 *
4030 */
4031void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4032 void* pUserData)
4033{
4034 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4035 tWDA_CbContext *pWDA;
4036 tDelStaSelfParams *delStaSelfParams;
4037
4038 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4039 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4040 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4041
4042 if (NULL == pWdaParams)
4043 {
4044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4045 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4046 VOS_ASSERT(0);
4047 return;
4048 }
4049
4050 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4051 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4052
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4053 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4054
4055 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4056 {
4057 VOS_ASSERT(0);
4058 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4059 vos_mem_free(pWdaParams) ;
4060 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4061 }
4062
4063 return ;
4064}
4065
4066/*
4067 * FUNCTION: WDA_DelSTASelfReq
4068 * Trigger Config STA processing in WDI
4069 */
4070VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4071 tDelStaSelfParams* pDelStaSelfReqParam)
4072{
4073 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4074 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4075 tWDA_ReqParams *pWdaParams = NULL;
4076 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4077 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4078 sizeof(WDI_DelSTASelfReqParamsType)) ;
4079
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4080 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4081 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4082 if( NULL == wdiDelStaSelfReq )
4083 {
4084 VOS_ASSERT( 0 );
4085 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4086 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4087 return( VOS_STATUS_E_NOMEM );
4088 }
4089
4090 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4091 if( NULL == pWdaParams )
4092 {
4093 VOS_ASSERT( 0 );
4094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4095 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4096 vos_mem_free(wdiDelStaSelfReq) ;
4097 return( VOS_STATUS_E_NOMEM );
4098 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4099 pWdaParams->pWdaContext = pWDA;
4100 /* Store param pointer as passed in by caller */
4101 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4102 /* store Params pass it to WDI */
4103 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4104 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4105 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4106
4107 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4108 wdiDelStaSelfReq->pUserData = pWdaParams;
4109
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4110 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4111 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4112
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4113 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4114 {
4115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4116 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4117 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4118 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4119 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4120 vos_mem_free(pWdaParams) ;
4121 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4122 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4123 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4124 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4125}
4126
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4127/*
4128 * FUNCTION: WDA_SendMsg
4129 * Send Message back to PE
4130 */
4131void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4132 void *pBodyptr, tANI_U32 bodyVal)
4133{
4134 tSirMsgQ msg = {0} ;
4135 tANI_U32 status = VOS_STATUS_SUCCESS ;
4136 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4137 msg.type = msgType;
4138 msg.bodyval = bodyVal;
4139 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4140 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4141 if (VOS_STATUS_SUCCESS != status)
4142 {
4143 if(NULL != pBodyptr)
4144 {
4145 vos_mem_free(pBodyptr);
4146 }
4147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4148 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4149 VOS_ASSERT(0) ;
4150 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4151 return ;
4152}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4153/*
4154 * FUNCTION: WDA_UpdateBSSParams
4155 * Translated WDA/PE BSS info into WDI BSS info..
4156 */
4157void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4158 WDI_ConfigBSSReqInfoType *wdiBssParams,
4159 tAddBssParams *wdaBssParams)
4160{
4161 v_U8_t keyIndex = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4162 /* copy bssReq Params to WDI structure */
4163 vos_mem_copy(wdiBssParams->macBSSID,
4164 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4165 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4166 sizeof(tSirMacAddr)) ;
4167 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4168 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4169 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4170 wdiBssParams->ucShortSlotTimeSupported =
4171 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4172 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4173 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4174 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4175 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4176 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4177
4178 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4179 wdiBssParams->ucTXOPProtectionFullSupport =
4180 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4181 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4182 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4183 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4184 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4185 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4186 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4187 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4188
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4189 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4190
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4191 /* copy SSID into WDI structure */
4192 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4193 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4194 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4195 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4196 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4197 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4198#ifdef WLAN_FEATURE_VOWIFI
4199 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4200#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4201 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4202 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4203#ifdef WLAN_FEATURE_VOWIFI_11R
4204 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4205 if(wdiBssParams->bExtSetStaKeyParamValid)
4206 {
4207 /* copy set STA key params to WDI structure */
4208 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4209 wdaBssParams->extSetStaKeyParam.staIdx;
4210 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4211 wdaBssParams->extSetStaKeyParam.encType;
4212 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4213 wdaBssParams->extSetStaKeyParam.wepType;
4214 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4215 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4216 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4217 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4218 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4219 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4220 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4221 {
4222 WDA_GetWepKeysFromCfg( pWDA,
4223 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4224 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4225 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4226 }
4227 else
4228 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4229 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4230 keyIndex++)
4231 {
4232 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
4233 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
4234 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
4235 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
4236 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
4237 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4238 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
4239 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4240 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
4241 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
4242 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
4243 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
4244 vos_mem_copy(wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
4245 wdaBssParams->extSetStaKeyParam.key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4246 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4247 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
4248 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4249 }
4250 }
4251 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
4252 }
4253 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
4254 {
4255 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
4256 sizeof(wdaBssParams->extSetStaKeyParam) );
4257 }
4258#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4259#ifdef WLAN_FEATURE_11AC
4260 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
4261 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
4262#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4263
4264 return ;
4265}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4266/*
4267 * FUNCTION: WDA_UpdateSTAParams
4268 * Translated WDA/PE BSS info into WDI BSS info..
4269 */
4270void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
4271 WDI_ConfigStaReqInfoType *wdiStaParams,
4272 tAddStaParams *wdaStaParams)
4273{
4274 tANI_U8 i = 0;
4275 /* Update STA params */
4276 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
4277 sizeof(tSirMacAddr)) ;
4278 wdiStaParams->usAssocId = wdaStaParams->assocId;
4279 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]4280 wdiStaParams->staIdx = wdaStaParams->staIdx;
4281
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4282 wdiStaParams->ucShortPreambleSupported =
4283 wdaStaParams->shortPreambleSupported;
4284 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
4285 sizeof(tSirMacAddr)) ;
4286 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
4287
4288 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
4289
4290 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
4291 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
4292 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
4293 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
4294 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
4295 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
4296 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
4297
4298 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
4299 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4300 wdiStaParams->wdiSupportedRates.opRateMode =
4301 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4302 for(i = 0;i < WDI_NUM_11B_RATES;i++)
4303 {
4304 wdiStaParams->wdiSupportedRates.llbRates[i] =
4305 wdaStaParams->supportedRates.llbRates[i];
4306 }
4307 for(i = 0;i < WDI_NUM_11A_RATES;i++)
4308 {
4309 wdiStaParams->wdiSupportedRates.llaRates[i] =
4310 wdaStaParams->supportedRates.llaRates[i];
4311 }
4312 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
4313 {
4314 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
4315 wdaStaParams->supportedRates.aniLegacyRates[i];
4316 }
4317 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
4318 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4319#ifdef WLAN_FEATURE_11AC
4320 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
4321 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
4322 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
4323 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
4324#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4325 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
4326 {
4327 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
4328 wdaStaParams->supportedRates.supportedMCSSet[i];
4329 }
4330 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
4331 wdaStaParams->supportedRates.rxHighestDataRate;
4332
4333 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
4334
4335 wdiStaParams->wdiAction = wdaStaParams->updateSta;
4336
4337 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
4338 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
4339 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
4340
4341 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
4342 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
4343 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
4344 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4345 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4346#ifdef WLAN_FEATURE_11AC
4347 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
4348 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]4349 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]4350 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
4351 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
4352 * must be set by default */
4353 if ( wdiStaParams->vhtTxMUBformeeCapable )
4354 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4355#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]4356 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
4357 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4358 return ;
4359}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4360/*
4361 * -------------------------------------------------------------------------
4362 * CFG update to WDI
4363 * -------------------------------------------------------------------------
4364 */
4365
4366 /*
4367 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
4368 * Convert the WNI CFG ID to HAL CFG ID
4369 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]4370static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4371{
4372 switch(wniCfgId)
4373 {
4374 case WNI_CFG_STA_ID:
4375 return QWLAN_HAL_CFG_STA_ID;
4376 case WNI_CFG_CURRENT_TX_ANTENNA:
4377 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
4378 case WNI_CFG_CURRENT_RX_ANTENNA:
4379 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
4380 case WNI_CFG_LOW_GAIN_OVERRIDE:
4381 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
4382 case WNI_CFG_POWER_STATE_PER_CHAIN:
4383 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
4384 case WNI_CFG_CAL_PERIOD:
4385 return QWLAN_HAL_CFG_CAL_PERIOD;
4386 case WNI_CFG_CAL_CONTROL:
4387 return QWLAN_HAL_CFG_CAL_CONTROL;
4388 case WNI_CFG_PROXIMITY:
4389 return QWLAN_HAL_CFG_PROXIMITY;
4390 case WNI_CFG_NETWORK_DENSITY:
4391 return QWLAN_HAL_CFG_NETWORK_DENSITY;
4392 case WNI_CFG_MAX_MEDIUM_TIME:
4393 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
4394 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
4395 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
4396 case WNI_CFG_RTS_THRESHOLD:
4397 return QWLAN_HAL_CFG_RTS_THRESHOLD;
4398 case WNI_CFG_SHORT_RETRY_LIMIT:
4399 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
4400 case WNI_CFG_LONG_RETRY_LIMIT:
4401 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
4402 case WNI_CFG_FRAGMENTATION_THRESHOLD:
4403 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
4404 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
4405 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
4406 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
4407 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
4408 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
4409 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
4410 case WNI_CFG_FIXED_RATE:
4411 return QWLAN_HAL_CFG_FIXED_RATE;
4412 case WNI_CFG_RETRYRATE_POLICY:
4413 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
4414 case WNI_CFG_RETRYRATE_SECONDARY:
4415 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
4416 case WNI_CFG_RETRYRATE_TERTIARY:
4417 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
4418 case WNI_CFG_FORCE_POLICY_PROTECTION:
4419 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
4420 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
4421 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
4422 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
4423 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
4424 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
4425 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
4426 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
4427 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
4428 case WNI_CFG_MAX_BA_SESSIONS:
4429 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
4430 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
4431 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
4432 case WNI_CFG_PS_ENABLE_BCN_FILTER:
4433 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
4434 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
4435 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
4436 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
4437 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
4438 case WNI_CFG_STATS_PERIOD:
4439 return QWLAN_HAL_CFG_STATS_PERIOD;
4440 case WNI_CFG_CFP_MAX_DURATION:
4441 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
4442#if 0 /*This is not part of CFG*/
4443 case WNI_CFG_FRAME_TRANS_ENABLED:
4444 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
4445#endif
4446 case WNI_CFG_DTIM_PERIOD:
4447 return QWLAN_HAL_CFG_DTIM_PERIOD;
4448 case WNI_CFG_EDCA_WME_ACBK:
4449 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
4450 case WNI_CFG_EDCA_WME_ACBE:
4451 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
4452 case WNI_CFG_EDCA_WME_ACVI:
4453 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
4454 case WNI_CFG_EDCA_WME_ACVO:
4455 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
4456#if 0
4457 case WNI_CFG_TELE_BCN_WAKEUP_EN:
4458 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
4459 case WNI_CFG_TELE_BCN_TRANS_LI:
4460 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
4461 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
4462 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
4463 case WNI_CFG_TELE_BCN_MAX_LI:
4464 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
4465 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
4466 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
4467#endif
4468 case WNI_CFG_ENABLE_CLOSE_LOOP:
4469 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]4470 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
4471 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4472 default:
4473 {
4474 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4475 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4476 wniCfgId);
4477 return VOS_STATUS_E_INVAL;
4478 }
4479 }
4480}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4481/*
4482 * FUNCTION: WDA_UpdateCfgCallback
4483 *
4484 */
4485void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
4486{
4487 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4488 WDI_UpdateCfgReqParamsType *wdiCfgParam =
4489 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4491 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4492 /*
4493 * currently there is no response message is expected between PE and
4494 * WDA, Failure return from WDI is a ASSERT condition
4495 */
4496 if(WDI_STATUS_SUCCESS != wdiStatus)
4497 {
4498 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4499 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4500 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
4501 }
4502
4503 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
4504 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4505 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4506 return ;
4507}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4508/*
4509 * FUNCTION: WDA_UpdateCfg
4510 *
4511 */
4512VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
4513{
4514
4515 WDI_Status status = WDI_STATUS_SUCCESS ;
4516 tANI_U32 val =0;
4517 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
4518 tHalCfg *configData;
4519 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
4520 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4522 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4523 if (NULL == pMac )
4524 {
4525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4526 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4527 return VOS_STATUS_E_FAILURE;
4528 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4529 if(WDA_START_STATE != pWDA->wdaState)
4530 {
4531 return VOS_STATUS_E_FAILURE;
4532 }
4533
4534 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
4535 {
4536 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4537 "%s:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4538 VOS_ASSERT(0);
4539 return VOS_STATUS_E_FAILURE;
4540 }
4541
4542 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
4543 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4544 if(NULL == wdiCfgReqParam)
4545 {
4546 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4547 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4548 VOS_ASSERT(0);
4549 return VOS_STATUS_E_NOMEM;
4550 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4551 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
4552 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4553 if(NULL == wdiCfgReqParam->pConfigBuffer)
4554 {
4555 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4556 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4557 vos_mem_free(wdiCfgReqParam);
4558 VOS_ASSERT(0);
4559 return VOS_STATUS_E_NOMEM;
4560 }
4561
4562 /*convert the WNI CFG Id to HAL CFG Id*/
4563 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
4564 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
4565
4566 /*TODO: revisit this for handling string parameters */
4567 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
4568 &val) != eSIR_SUCCESS)
4569 {
4570 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4571 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4572 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
4573 vos_mem_free(wdiCfgReqParam);
4574 return eSIR_FAILURE;
4575 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4576 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
4577 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
4578 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
4579 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
4580 wdiCfgReqParam->wdiReqStatusCB = NULL ;
4581
4582 /* store Params pass it to WDI */
4583 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4584#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
4585 status = WDI_UpdateCfgReq(wdiCfgReqParam,
4586 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4587 if(IS_WDI_STATUS_FAILURE(status))
4588 {
4589 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4590 "Failure in Update CFG WDI API, free all the memory " );
4591 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4592 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4593 pWDA->wdaWdiCfgApiMsgParam = NULL;
4594 /* Failure is not expected */
4595 VOS_ASSERT(0) ;
4596 }
4597#else
4598 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
4599 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
4600 pWDA->wdaWdiCfgApiMsgParam = NULL;
4601#endif
4602 return CONVERT_WDI2VOS_STATUS(status) ;
4603}
4604
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4605VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
4606 v_U8_t *pDefaultKeyId,
4607 v_U8_t *pNumKeys,
4608 WDI_KeysType *pWdiKeys )
4609{
4610 v_U32_t i, j, defKeyId = 0;
4611 v_U32_t val = SIR_MAC_KEY_LENGTH;
4612 VOS_STATUS status = WDI_STATUS_SUCCESS;
4613 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4614 if (NULL == pMac )
4615 {
4616 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4617 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4618 return VOS_STATUS_E_FAILURE;
4619 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4620 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
4621 &defKeyId ))
4622 {
4623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4624 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
4625 }
4626
4627 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4628 /* Need to extract ALL of the configured WEP Keys */
4629 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
4630 {
4631 val = SIR_MAC_KEY_LENGTH;
4632 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
4633 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
4634 pWdiKeys[j].key,
4635 &val ))
4636 {
4637 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]4638 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4639 }
4640 else
4641 {
4642 pWdiKeys[j].keyId = (tANI_U8) i;
4643 /*
4644 * Actually, a DC (Don't Care) because
4645 * this is determined (and set) by PE/MLME
4646 */
4647 pWdiKeys[j].unicast = 0;
4648 /*
4649 * Another DC (Don't Care)
4650 */
4651 pWdiKeys[j].keyDirection = eSIR_TX_RX;
4652 /* Another DC (Don't Care). Unused for WEP */
4653 pWdiKeys[j].paeRole = 0;
4654 /* Determined from wlan_cfgGetStr() above.*/
4655 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4656 j++;
4657 *pNumKeys = (tANI_U8) j;
4658 }
4659 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4660 return status;
4661}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4662/*
4663 * FUNCTION: WDA_SetBssKeyReqCallback
4664 * send SET BSS key RSP back to PE
4665 */
4666void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
4667{
4668 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4669 tWDA_CbContext *pWDA;
4670 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4672 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4673 if(NULL == pWdaParams)
4674 {
4675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4676 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4677 VOS_ASSERT(0) ;
4678 return ;
4679 }
4680 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4681 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4682 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4683 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4684 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4685 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4686 return ;
4687}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4688/*
4689 * FUNCTION: WDA_ProcessSetBssKeyReq
4690 * Request to WDI for programming the BSS key( key for
4691 * broadcast/multicast frames Encryption)
4692 */
4693VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
4694 tSetBssKeyParams *setBssKeyParams )
4695{
4696 WDI_Status status = WDI_STATUS_SUCCESS ;
4697 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
4698 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
4699 sizeof(WDI_SetBSSKeyReqParamsType)) ;
4700 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4701 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4703 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4704 if(NULL == wdiSetBssKeyParam)
4705 {
4706 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4707 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4708 VOS_ASSERT(0);
4709 return VOS_STATUS_E_NOMEM;
4710 }
4711 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4712 if(NULL == pWdaParams)
4713 {
4714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4715 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4716 VOS_ASSERT(0);
4717 vos_mem_free(wdiSetBssKeyParam);
4718 return VOS_STATUS_E_NOMEM;
4719 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4720 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4721 /* copy set BSS params to WDI structure */
4722 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
4723 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
4724 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4725 if(setBssKeyParams->encType != eSIR_ED_NONE)
4726 {
4727 if( setBssKeyParams->numKeys == 0 &&
4728 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
4729 setBssKeyParams->encType == eSIR_ED_WEP104))
4730 {
4731 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4732 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
4733 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
4734 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
4735 }
4736 else
4737 {
4738 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
4739 {
4740 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
4741 setBssKeyParams->key[keyIndex].keyId;
4742 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
4743 setBssKeyParams->key[keyIndex].unicast;
4744 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
4745 setBssKeyParams->key[keyIndex].keyDirection;
4746 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
4747 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4748 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
4749 setBssKeyParams->key[keyIndex].paeRole;
4750 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
4751 setBssKeyParams->key[keyIndex].keyLength;
4752 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
4753 setBssKeyParams->key[keyIndex].key,
4754 SIR_MAC_MAX_KEY_LENGTH);
4755 }
4756 }
4757 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4758 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
4759 setBssKeyParams->singleTidRc;
4760 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4761 /* Store set key pointer, as this will be used for response */
4762 /* store Params pass it to WDI */
4763 pWdaParams->pWdaContext = pWDA;
4764 pWdaParams->wdaMsgParam = setBssKeyParams;
4765 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4766 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
4767 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
4768
4769 if(IS_WDI_STATUS_FAILURE(status))
4770 {
4771 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4772 "Failure in Set BSS Key Req WDI API, free all the memory " );
4773 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4774 vos_mem_free(pWdaParams) ;
4775 setBssKeyParams->status = eSIR_FAILURE ;
4776 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
4777 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4778 return CONVERT_WDI2VOS_STATUS(status) ;
4779}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4780/*
4781 * FUNCTION: WDA_RemoveBssKeyReqCallback
4782 * send SET BSS key RSP back to PE
4783 */
4784void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
4785{
4786 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4787 tWDA_CbContext *pWDA;
4788 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4790 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4791 if(NULL == pWdaParams)
4792 {
4793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4794 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4795 VOS_ASSERT(0) ;
4796 return ;
4797 }
4798 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4799 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4800 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4801 vos_mem_free(pWdaParams) ;
4802
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4803 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4804 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4805 return ;
4806}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4807/*
4808 * FUNCTION: WDA_ProcessRemoveBssKeyReq
4809 * Request to WDI to remove the BSS key( key for broadcast/multicast
4810 * frames Encryption)
4811 */
4812VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
4813 tRemoveBssKeyParams *removeBssKeyParams )
4814{
4815 WDI_Status status = WDI_STATUS_SUCCESS ;
4816 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
4817 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
4818 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
4819 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4820 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4821 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4822 if(NULL == wdiRemoveBssKeyParam)
4823 {
4824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4825 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4826 VOS_ASSERT(0);
4827 return VOS_STATUS_E_NOMEM;
4828 }
4829 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4830 if(NULL == pWdaParams)
4831 {
4832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4833 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4834 VOS_ASSERT(0);
4835 vos_mem_free(wdiRemoveBssKeyParam);
4836 return VOS_STATUS_E_NOMEM;
4837 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4838 /* copy Remove BSS key params to WDI structure*/
4839 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
4840 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
4841 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
4842 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
4843 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4844 /* Store remove key pointer, as this will be used for response */
4845 /* store Params pass it to WDI */
4846 pWdaParams->pWdaContext = pWDA;
4847 pWdaParams->wdaMsgParam = removeBssKeyParams;
4848 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4849 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
4850 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4851 if(IS_WDI_STATUS_FAILURE(status))
4852 {
4853 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4854 "Failure in Remove BSS Key Req WDI API, free all the memory " );
4855 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4856 vos_mem_free(pWdaParams) ;
4857 removeBssKeyParams->status = eSIR_FAILURE ;
4858 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
4859 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4860 return CONVERT_WDI2VOS_STATUS(status) ;
4861}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4862/*
4863 * FUNCTION: WDA_SetBssKeyReqCallback
4864 * send SET BSS key RSP back to PE
4865 */
4866void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
4867{
4868 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4869 tWDA_CbContext *pWDA;
4870 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4872 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4873 if(NULL == pWdaParams)
4874 {
4875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4876 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4877 VOS_ASSERT(0) ;
4878 return ;
4879 }
4880 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4881 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4882 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4883 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4884 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4885 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4886 return ;
4887}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4888/*
4889 * FUNCTION: WDA_ProcessSetStaKeyReq
4890 * Request to WDI for programming the STA key( key for Unicast frames
4891 * Encryption)
4892 */
4893VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
4894 tSetStaKeyParams *setStaKeyParams )
4895{
4896 WDI_Status status = WDI_STATUS_SUCCESS ;
4897 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
4898 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
4899 sizeof(WDI_SetSTAKeyReqParamsType)) ;
4900 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4901 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4903 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4904 if(NULL == wdiSetStaKeyParam)
4905 {
4906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4907 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4908 VOS_ASSERT(0);
4909 return VOS_STATUS_E_NOMEM;
4910 }
4911 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4912 if(NULL == pWdaParams)
4913 {
4914 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4915 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4916 VOS_ASSERT(0);
4917 vos_mem_free(wdiSetStaKeyParam);
4918 return VOS_STATUS_E_NOMEM;
4919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4920 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4921 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4922 /* copy set STA key params to WDI structure */
4923 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
4924 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
4925 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
4926 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4927 if(setStaKeyParams->encType != eSIR_ED_NONE)
4928 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4929 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4930 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
4931 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4932 {
4933 WDA_GetWepKeysFromCfg( pWDA,
4934 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
4935 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
4936 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
4937 }
4938 else
4939 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4940 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4941 keyIndex++)
4942 {
4943 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
4944 setStaKeyParams->key[keyIndex].keyId;
4945 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
4946 setStaKeyParams->key[keyIndex].unicast;
4947 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
4948 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4949 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
4950 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
4951 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
4952 setStaKeyParams->key[keyIndex].paeRole;
4953 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
4954 setStaKeyParams->key[keyIndex].keyLength;
4955 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
4956 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
4957 /* set default index to index which have key direction as WDI_TX_DEFAULT */
4958 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
4959 {
4960 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
4961 }
4962 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4963 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
4964 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4965 }
4966 }
4967 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
4968 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4969 /* Store set key pointer, as this will be used for response */
4970 /* store Params pass it to WDI */
4971 pWdaParams->pWdaContext = pWDA;
4972 pWdaParams->wdaMsgParam = setStaKeyParams;
4973 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4974 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
4975 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4976 if(IS_WDI_STATUS_FAILURE(status))
4977 {
4978 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4979 "Failure in set STA Key Req WDI API, free all the memory " );
4980 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4981 vos_mem_free(pWdaParams) ;
4982 setStaKeyParams->status = eSIR_FAILURE ;
4983 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
4984 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4985 return CONVERT_WDI2VOS_STATUS(status) ;
4986}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4987/*
4988 * FUNCTION: WDA_SetBcastStaKeyReqCallback
4989 * send SET Bcast STA key RSP back to PE
4990 */
4991void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
4992{
4993 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4994 tWDA_CbContext *pWDA;
4995 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4996 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4997 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4998 if(NULL == pWdaParams)
4999 {
5000 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5001 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5002 VOS_ASSERT(0) ;
5003 return ;
5004 }
5005 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5006 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5007 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5008 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5009 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5010 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5011 return ;
5012}
5013
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5014/*
5015 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
5016 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
5017 * Encryption)
5018 */
5019VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
5020 tSetStaKeyParams *setStaKeyParams )
5021{
5022 WDI_Status status = WDI_STATUS_SUCCESS ;
5023 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5024 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5025 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5026 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5027 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5029 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5030 if(NULL == wdiSetStaKeyParam)
5031 {
5032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5033 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5034 VOS_ASSERT(0);
5035 return VOS_STATUS_E_NOMEM;
5036 }
5037 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5038 if(NULL == pWdaParams)
5039 {
5040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5041 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5042 VOS_ASSERT(0);
5043 vos_mem_free(wdiSetStaKeyParam);
5044 return VOS_STATUS_E_NOMEM;
5045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5046 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5047 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5048 /* copy set STA key params to WDI structure */
5049 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5050 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5051 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5052 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5053 if(setStaKeyParams->encType != eSIR_ED_NONE)
5054 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5055 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
5056 keyIndex++)
5057 {
5058 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
5059 setStaKeyParams->key[keyIndex].keyId;
5060 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
5061 setStaKeyParams->key[keyIndex].unicast;
5062 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
5063 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5064 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
5065 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5066 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
5067 setStaKeyParams->key[keyIndex].paeRole;
5068 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
5069 setStaKeyParams->key[keyIndex].keyLength;
5070 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
5071 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
5072 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5073 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
5074 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5075 }
5076 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5077 /* Store set key pointer, as this will be used for response */
5078 /* store Params pass it to WDI */
5079 pWdaParams->pWdaContext = pWDA;
5080 pWdaParams->wdaMsgParam = setStaKeyParams;
5081 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5082 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
5083 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5084 if(IS_WDI_STATUS_FAILURE(status))
5085 {
5086 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5087 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
5088 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5089 vos_mem_free(pWdaParams) ;
5090 setStaKeyParams->status = eSIR_FAILURE ;
5091 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
5092 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5093 return CONVERT_WDI2VOS_STATUS(status) ;
5094}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5095/*
5096 * FUNCTION: WDA_RemoveStaKeyReqCallback
5097 * send SET BSS key RSP back to PE
5098 */
5099void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
5100{
5101 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5102 tWDA_CbContext *pWDA;
5103 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5105 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5106 if(NULL == pWdaParams)
5107 {
5108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5109 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5110 VOS_ASSERT(0) ;
5111 return ;
5112 }
5113 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5114 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5115 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5116 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5117 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5118 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5119 return ;
5120}
5121
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5122/*
5123 * FUNCTION: WDA_ProcessRemoveStaKeyReq
5124 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
5125 */
5126VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
5127 tRemoveStaKeyParams *removeStaKeyParams )
5128{
5129 WDI_Status status = WDI_STATUS_SUCCESS ;
5130 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
5131 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
5132 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
5133 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5134 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5135 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5136 if(NULL == wdiRemoveStaKeyParam)
5137 {
5138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5139 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5140 VOS_ASSERT(0);
5141 return VOS_STATUS_E_NOMEM;
5142 }
5143 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5144 if(NULL == pWdaParams)
5145 {
5146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5147 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5148 VOS_ASSERT(0);
5149 vos_mem_free(wdiRemoveStaKeyParam);
5150 return VOS_STATUS_E_NOMEM;
5151 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5152 /* copy remove STA key params to WDI structure*/
5153 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
5154 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
5155 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
5156 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
5157 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5158 /* Store remove key pointer, as this will be used for response */
5159 /* store Params pass it to WDI */
5160 pWdaParams->pWdaContext = pWDA;
5161 pWdaParams->wdaMsgParam = removeStaKeyParams;
5162 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5163 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
5164 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5165 if(IS_WDI_STATUS_FAILURE(status))
5166 {
5167 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5168 "Failure in remove STA Key Req WDI API, free all the memory " );
5169 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5170 vos_mem_free(pWdaParams) ;
5171 removeStaKeyParams->status = eSIR_FAILURE ;
5172 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
5173 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5174 return CONVERT_WDI2VOS_STATUS(status) ;
5175}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5176/*
5177 * FUNCTION: WDA_IsHandleSetLinkStateReq
5178 * Update the WDA state and return the status to handle this message or not
5179 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5180WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
5181 tWDA_CbContext *pWDA,
5182 tLinkStateParams *linkStateParams)
5183{
5184 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5185 switch(linkStateParams->state)
5186 {
5187 case eSIR_LINK_PREASSOC_STATE:
5188 case eSIR_LINK_BTAMP_PREASSOC_STATE:
5189 /*
5190 * set the WDA state to PRE ASSOC
5191 * copy the BSSID into pWDA to use it in join request and return,
5192 * No need to handle these messages.
5193 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5194 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
5195 {
5196 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5197 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5198 }
5199 else
5200 {
5201 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5202 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5203 VOS_ASSERT(0);
5204 }
5205
5206 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
5207 {
5208 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5209 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5210 }
5211 else
5212 {
5213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5214 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5215 VOS_ASSERT(0);
5216 }
5217
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5218 /* UMAC is issuing the setlink state with PREASSOC twice (before set
5219 *channel and after ) so reset the WDA state to ready when the second
5220 * time UMAC issue the link state with PREASSOC
5221 */
5222 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
5223 {
5224 /* RESET WDA state back to WDA_READY_STATE */
5225 pWDA->wdaState = WDA_READY_STATE;
5226 }
5227 else
5228 {
5229 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
5230 }
5231 //populate linkState info in WDACbCtxt
5232 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5233 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5234 default:
5235 if(pWDA->wdaState != WDA_READY_STATE)
5236 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5237 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
5238 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
5239 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
5240 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
5241 *the ASSERT in WDA_Stop during module unload.*/
5242 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
5243 {
5244 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5245 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5246 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5247 else
5248 {
5249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5250 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]5251 status = WDA_IGNORE_SET_LINK_STATE;
5252 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5253 }
5254 break;
5255 }
5256
5257 return status;
5258}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5259/*
5260 * FUNCTION: WDA_SetLinkStateCallback
5261 * call back function for set link state from WDI
5262 */
5263void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
5264{
5265 tWDA_CbContext *pWDA;
5266 tLinkStateParams *linkStateParams;
5267 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5269 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5270 if(NULL == pWdaParams)
5271 {
5272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5273 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5274 VOS_ASSERT(0) ;
5275 return ;
5276 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5277 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5278 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5279 /*
5280 * In STA mode start the BA activity check timer after association
5281 * and in AP mode start BA activity check timer after BSS start */
5282 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
5283 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]5284 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
5285 ((status == WDI_STATUS_SUCCESS) &&
5286 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5287 {
5288 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5289 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5290 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5291 /*
5292 * No respone required for WDA_SET_LINK_STATE so free the request
5293 * param here
5294 */
5295 if( pWdaParams != NULL )
5296 {
5297 if( pWdaParams->wdaWdiApiMsgParam != NULL )
5298 {
5299 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5300 }
5301 vos_mem_free(pWdaParams);
5302 }
5303 return ;
5304}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5305/*
5306 * FUNCTION: WDA_ProcessSetLinkState
5307 * Request to WDI to set the link status.
5308 */
5309VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
5310 tLinkStateParams *linkStateParams)
5311{
5312 WDI_Status status = WDI_STATUS_SUCCESS ;
5313 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
5314 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
5315 sizeof(WDI_SetLinkReqParamsType)) ;
5316 tWDA_ReqParams *pWdaParams ;
5317 tpAniSirGlobal pMac;
5318 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
5319
5320 if(NULL == pMac)
5321 {
5322 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5323 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5324 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]5325 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5326 return VOS_STATUS_E_FAILURE;
5327 }
5328
5329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5330 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5331 if(NULL == wdiSetLinkStateParam)
5332 {
5333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5334 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5335 VOS_ASSERT(0);
5336 return VOS_STATUS_E_NOMEM;
5337 }
5338 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5339 if(NULL == pWdaParams)
5340 {
5341 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5342 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5343 VOS_ASSERT(0);
5344 vos_mem_free(wdiSetLinkStateParam);
5345 return VOS_STATUS_E_NOMEM;
5346 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5347 if(WDA_IGNORE_SET_LINK_STATE ==
5348 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
5349 {
5350 status = WDI_STATUS_E_FAILURE;
5351 }
5352 else
5353 {
5354 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
5355 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5356 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
5357 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5358 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
5359 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5360 pWdaParams->pWdaContext = pWDA;
5361 /* Store remove key pointer, as this will be used for response */
5362 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5363 /* store Params pass it to WDI */
5364 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
5365 /* Stop Timer only other than GO role and concurrent session */
5366 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]5367 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5368 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
5369 {
5370 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
5371 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5372 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
5373 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5374 if(IS_WDI_STATUS_FAILURE(status))
5375 {
5376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5377 "Failure in set link state Req WDI API, free all the memory " );
5378 }
5379 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5380 if(IS_WDI_STATUS_FAILURE(status))
5381 {
5382 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5383 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5384 vos_mem_free(pWdaParams);
5385 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5386 return CONVERT_WDI2VOS_STATUS(status) ;
5387}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5388/*
5389 * FUNCTION: WDA_GetStatsReqParamsCallback
5390 * send the response to PE with Stats received from WDI
5391 */
5392void WDA_GetStatsReqParamsCallback(
5393 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
5394 void* pUserData)
5395{
5396 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5397 tAniGetPEStatsRsp *pGetPEStatsRspParams;
5398
5399 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5400 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5401 pGetPEStatsRspParams =
5402 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
5403 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
5404
5405 if(NULL == pGetPEStatsRspParams)
5406 {
5407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5408 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5409 VOS_ASSERT(0);
5410 return;
5411 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5412 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
5413 pGetPEStatsRspParams->msgType = wdiGetStatsRsp->usMsgType;
5414 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
5415 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5416
5417 //Fill the Session Id Properly in PE
5418 pGetPEStatsRspParams->sessionId = 0;
5419 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5420 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5421 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
5422 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5423 vos_mem_copy( pGetPEStatsRspParams + 1,
5424 wdiGetStatsRsp + 1,
5425 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5426 /* send response to UMAC*/
5427 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP, pGetPEStatsRspParams , 0) ;
5428
5429 return;
5430}
5431
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5432/*
5433 * FUNCTION: WDA_ProcessGetStatsReq
5434 * Request to WDI to get the statistics
5435 */
5436VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
5437 tAniGetPEStatsReq *pGetStatsParams)
5438{
5439 WDI_Status status = WDI_STATUS_SUCCESS ;
5440 WDI_GetStatsReqParamsType wdiGetStatsParam;
5441 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5442 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5443 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5444 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
5445 pGetStatsParams->staId;
5446 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
5447 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5448 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5449 status = WDI_GetStatsReq(&wdiGetStatsParam,
5450 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5451 if(IS_WDI_STATUS_FAILURE(status))
5452 {
5453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5454 "Failure in Get Stats Req WDI API, free all the memory " );
5455 pGetPEStatsRspParams =
5456 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
5457 if(NULL == pGetPEStatsRspParams)
5458 {
5459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5460 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5461 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5462 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5463 return VOS_STATUS_E_NOMEM;
5464 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5465 pGetPEStatsRspParams->msgType = WDA_GET_STATISTICS_RSP;
5466 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
5467 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
5468 pGetPEStatsRspParams->rc = eSIR_FAILURE;
5469 WDA_SendMsg(pWDA, WDA_GET_STATISTICS_RSP,
5470 (void *)pGetPEStatsRspParams, 0) ;
5471 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5472 /* Free the request message */
5473 vos_mem_free(pGetStatsParams);
5474 return CONVERT_WDI2VOS_STATUS(status);
5475}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5476
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]5477#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5478/*
5479 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
5480 * send the response to PE with roam Rssi received from WDI
5481 */
5482void WDA_GetRoamRssiReqParamsCallback(
5483 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
5484 void* pUserData)
5485{
5486 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5487 tWDA_CbContext *pWDA = NULL;
5488 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5489 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
5490 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5491 "<------ %s " ,__func__);
5492 if(NULL == pWdaParams)
5493 {
5494 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5495 "%s: pWdaParams received NULL", __func__);
5496 VOS_ASSERT(0) ;
5497 return ;
5498 }
5499 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5500 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
5501
5502 if(NULL == pGetRoamRssiReqParams)
5503 {
5504 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5505 "%s: pGetRoamRssiReqParams received NULL", __func__);
5506 VOS_ASSERT(0);
5507 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5508 vos_mem_free(pWdaParams);
5509 return ;
5510 }
5511 pGetRoamRssiRspParams =
5512 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5513
5514 if(NULL == pGetRoamRssiRspParams)
5515 {
5516 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5517 "%s: VOS MEM Alloc Failure", __func__);
5518 VOS_ASSERT(0);
5519 return;
5520 }
5521 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
5522 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5523 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5524 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
5525 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
5526
5527 /* Assign get roam rssi req (backup) in to the response */
5528 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
5529
5530 /* free WDI command buffer */
5531 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5532 vos_mem_free(pWdaParams) ;
5533
5534 /* send response to UMAC*/
5535 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
5536
5537 return;
5538}
5539
5540
5541
5542/*
5543 * FUNCTION: WDA_ProcessGetRoamRssiReq
5544 * Request to WDI to get the statistics
5545 */
5546VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
5547 tAniGetRssiReq *pGetRoamRssiParams)
5548{
5549 WDI_Status status = WDI_STATUS_SUCCESS ;
5550 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
5551 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
5552 tWDA_ReqParams *pWdaParams = NULL;
5553
5554 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5555 "------> %s " ,__func__);
5556 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
5557 pGetRoamRssiParams->staId;
5558 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
5559
5560 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5561 if(NULL == pWdaParams)
5562 {
5563 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5564 "%s: VOS MEM Alloc Failure", __func__);
5565 VOS_ASSERT(0);
5566 return VOS_STATUS_E_NOMEM;
5567 }
5568
5569 /* Store Init Req pointer, as this will be used for response */
5570 pWdaParams->pWdaContext = pWDA;
5571
5572 /* Take Get roam Rssi req backup as it stores the callback to be called after
5573 receiving the response */
5574 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
5575 pWdaParams->wdaWdiApiMsgParam = NULL;
5576
5577 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
5578 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
5579 if(IS_WDI_STATUS_FAILURE(status))
5580 {
5581 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5582 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
5583 pGetRoamRssiRspParams =
5584 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
5585 if(NULL == pGetRoamRssiRspParams)
5586 {
5587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5588 "%s: VOS MEM Alloc Failure", __func__);
5589 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]5590 vos_mem_free(pGetRoamRssiParams);
5591 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]5592 return VOS_STATUS_E_NOMEM;
5593 }
5594 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
5595 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
5596 pGetRoamRssiRspParams->rssi = 0;
5597 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
5598 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
5599 (void *)pGetRoamRssiRspParams, 0) ;
5600 }
5601 return CONVERT_WDI2VOS_STATUS(status);
5602}
5603#endif
5604
5605
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5606/*
5607 * FUNCTION: WDA_UpdateEDCAParamCallback
5608 * call back function for Update EDCA params from WDI
5609 */
5610void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
5611{
5612 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5613 tEdcaParams *pEdcaParams;
5614
5615 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5616 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5617 if(NULL == pWdaParams)
5618 {
5619 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5620 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5621 VOS_ASSERT(0) ;
5622 return ;
5623 }
5624 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5625 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5626 vos_mem_free(pWdaParams);
5627 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5628 return ;
5629}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5630/*
5631 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
5632 * Request to WDI to Update the EDCA params.
5633 */
5634VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
5635 tEdcaParams *pEdcaParams)
5636{
5637 WDI_Status status = WDI_STATUS_SUCCESS ;
5638 WDI_UpdateEDCAParamsType *wdiEdcaParam =
5639 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
5640 sizeof(WDI_UpdateEDCAParamsType)) ;
5641 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5643 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5644 if(NULL == wdiEdcaParam)
5645 {
5646 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5647 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5648 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5649 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5650 return VOS_STATUS_E_NOMEM;
5651 }
5652 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5653 if(NULL == pWdaParams)
5654 {
5655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5656 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5657 VOS_ASSERT(0);
5658 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5659 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5660 return VOS_STATUS_E_NOMEM;
5661 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5662 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]5663 /*
5664 Since firmware is not using highperformance flag, we have removed
5665 this flag from wdiEDCAInfo structure to match sizeof the structure
5666 between host and firmware.In future if we are planning to use
5667 highperformance flag then Please define this flag in wdiEDCAInfo
5668 structure, update it here and send it to firmware. i.e.
5669 Following is the original line which we removed as part of the fix
5670 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
5671 pEdcaParams->highPerformance;
5672 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5673 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
5674 &pEdcaParams->acbe);
5675 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
5676 &pEdcaParams->acbk);
5677 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
5678 &pEdcaParams->acvi);
5679 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
5680 &pEdcaParams->acvo);
5681 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5682 pWdaParams->pWdaContext = pWDA;
5683 /* Store remove key pointer, as this will be used for response */
5684 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5685 /* store Params pass it to WDI */
5686 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5687 status = WDI_UpdateEDCAParams(wdiEdcaParam,
5688 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5689 if(IS_WDI_STATUS_FAILURE(status))
5690 {
5691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5692 "Failure in Update EDCA Params WDI API, free all the memory " );
5693 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5694 vos_mem_free(pWdaParams);
5695 vos_mem_free(pEdcaParams);
5696 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5697 return CONVERT_WDI2VOS_STATUS(status) ;
5698}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5699/*
5700 * FUNCTION: WDA_AddBAReqCallback
5701 * send ADD BA RSP back to PE
5702 */
5703void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
5704 void* pUserData)
5705{
5706 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5707 tWDA_CbContext *pWDA;
5708 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5710 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5711 if(NULL == pWdaParams)
5712 {
5713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5714 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5715 VOS_ASSERT(0) ;
5716 return ;
5717 }
5718 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5719 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5720 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5721 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5722 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5723 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5724 return ;
5725}
5726
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5727/*
5728 * FUNCTION: WDA_ProcessAddBAReq
5729 * Request to WDI to Update the ADDBA REQ params.
5730 */
5731VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
5732 tANI_U16 baSessionID, tANI_U8 staIdx, tAddBAParams *pAddBAReqParams)
5733{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5734 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5735 WDI_AddBAReqParamsType *wdiAddBAReqParam =
5736 (WDI_AddBAReqParamsType *)vos_mem_malloc(
5737 sizeof(WDI_AddBAReqParamsType)) ;
5738 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5739 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5740 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5741 if(NULL == wdiAddBAReqParam)
5742 {
5743 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5744 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5745 VOS_ASSERT(0);
5746 return VOS_STATUS_E_NOMEM;
5747 }
5748 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5749 if(NULL == pWdaParams)
5750 {
5751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5752 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5753 VOS_ASSERT(0);
5754 vos_mem_free(wdiAddBAReqParam);
5755 return VOS_STATUS_E_NOMEM;
5756 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5757 do
5758 {
5759 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5760 wdiAddBaInfo->ucSTAIdx = staIdx ;
5761 wdiAddBaInfo->ucBaSessionID = baSessionID ;
5762 wdiAddBaInfo->ucWinSize = WDA_BA_MAX_WINSIZE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5763 } while(0) ;
5764 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5765 pWdaParams->pWdaContext = pWDA;
5766 /* store Params pass it to WDI */
5767 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
5768 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5769 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
5770 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5771
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5772 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5773 {
5774 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5775 "Failure in ADD BA REQ Params WDI API, free all the memory" );
5776 status = CONVERT_WDI2VOS_STATUS(wstatus);
5777 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5778 vos_mem_free(pWdaParams);
5779 pAddBAReqParams->status = eSIR_FAILURE;
5780 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5781 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5782 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5783}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5784/*
5785 * FUNCTION: WDA_AddBASessionReqCallback
5786 * send ADD BA SESSION RSP back to PE/(or TL)
5787 */
5788void WDA_AddBASessionReqCallback(
5789 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
5790{
5791 VOS_STATUS status = VOS_STATUS_SUCCESS ;
5792 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5793 tWDA_CbContext *pWDA;
5794 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5796 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5797 if(NULL == pWdaParams)
5798 {
5799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5800 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5801 VOS_ASSERT(0) ;
5802 return ;
5803 }
5804 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5805 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5806 if( NULL == pAddBAReqParams )
5807 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5808 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5809 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5810 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]5811 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5812 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5813 return ;
5814 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5815 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5816 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5817 /*
5818 * if WDA in update TL state, update TL with BA session parama and send
5819 * another request to HAL(/WDI) (ADD_BA_REQ)
5820 */
5821
5822 if((VOS_STATUS_SUCCESS ==
5823 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
5824 (WDA_BA_UPDATE_TL_STATE == pWDA->wdaState))
5825 {
5826 /* Update TL with BA info received from HAL/WDI */
5827 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
5828 wdiAddBaSession->usBaSessionID,
5829 wdiAddBaSession->ucSTAIdx,
5830 wdiAddBaSession->ucBaTID,
5831 wdiAddBaSession->ucBaBufferSize,
5832 wdiAddBaSession->ucWinSize,
5833 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5834 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
5835 wdiAddBaSession->ucSTAIdx, pAddBAReqParams) ;
5836 }
5837 else
5838 {
5839 pAddBAReqParams->status =
5840 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
5841
5842 /* Setting Flag to indicate that Set BA is success */
5843 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
5844 {
5845 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
5846 tANI_U8 tid = wdiAddBaSession->ucBaTID;
5847 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
5848 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5849 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5850 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5851 /*Reset the WDA state to READY */
5852 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5853 return ;
5854}
5855
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5856/*
5857 * FUNCTION: WDA_ProcessAddBASessionReq
5858 * Request to WDI to Update the ADDBA REQ params.
5859 */
5860VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
5861 tAddBAParams *pAddBAReqParams)
5862{
5863 WDI_Status status = WDI_STATUS_SUCCESS ;
5864 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
5865 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
5866 sizeof(WDI_AddBASessionReqParamsType)) ;
5867 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5868 WLANTL_STAStateType tlSTAState = 0;
5869
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5871 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5872 if(NULL == wdiAddBASessionReqParam)
5873 {
5874 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5875 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5876 VOS_ASSERT(0);
5877 return VOS_STATUS_E_NOMEM;
5878 }
5879 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5880 if(NULL == pWdaParams)
5881 {
5882 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5883 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5884 VOS_ASSERT(0);
5885 vos_mem_free(wdiAddBASessionReqParam);
5886 return VOS_STATUS_E_NOMEM;
5887 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5888 /*
5889 * Populate ADD BA parameters and pass these paarmeters to WDI.
5890 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
5891 * the state to track if these is BA recipient case or BA initiator
5892 * case.
5893 */
5894 do
5895 {
5896 WDI_AddBASessionReqinfoType *wdiBAInfoType =
5897 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
5898 /* vos_mem_copy(wdiBAInfoType->macBSSID,
5899 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
5900 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
5901 vos_mem_copy(wdiBAInfoType->macPeerAddr,
5902 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5903 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5904 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
5905 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
5906 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
5907 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
5908 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5909 /* check the BA direction and update state accordingly */
5910 (eBA_RECIPIENT == wdiBAInfoType->ucBaDirection)
5911 ? (pWDA->wdaState = WDA_BA_UPDATE_TL_STATE)
5912 : (pWDA->wdaState = WDA_BA_UPDATE_LIM_STATE);
5913
5914 }while(0) ;
5915 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5916 pWdaParams->pWdaContext = pWDA;
5917 /* Store ADD BA pointer, as this will be used for response */
5918 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
5919 /* store Params pass it to WDI */
5920 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5921
5922 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
5923 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
5924 */
5925 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
5926 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
5927 {
5928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5929 "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]5930 status = WDI_STATUS_E_NOT_ALLOWED;
5931 pAddBAReqParams->status =
5932 CONVERT_WDI2SIR_STATUS(status) ;
5933 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
5934 /*Reset the WDA state to READY */
5935 pWDA->wdaState = WDA_READY_STATE;
5936 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
5937 vos_mem_free(pWdaParams);
5938
5939 return CONVERT_WDI2VOS_STATUS(status) ;
5940 }
5941
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5942 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
5943 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5944 if(IS_WDI_STATUS_FAILURE(status))
5945 {
5946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5947 "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]5948 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5949 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]5950 pAddBAReqParams->status =
5951 CONVERT_WDI2SIR_STATUS(status) ;
5952 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]5953 /*Reset the WDA state to READY */
5954 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5955 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5956 vos_mem_free(pWdaParams);
5957 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5958 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5959}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5960/*
5961 * FUNCTION: WDA_DelBANotifyTL
5962 * send DEL BA IND to TL
5963 */
5964void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
5965 tDelBAParams *pDelBAReqParams)
5966{
5967 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
5968 //tSirMsgQ msg;
5969 vos_msg_t vosMsg;
5970 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5971 if(NULL == pDelBAInd)
5972 {
5973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5974 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5975 VOS_ASSERT(0) ;
5976 return;
5977 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5978 pDelBAInd->mesgType = WDA_DELETEBA_IND;
5979 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
5980 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
5981 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5982
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5983
5984 vosMsg.type = WDA_DELETEBA_IND;
5985 vosMsg.bodyptr = pDelBAInd;
5986 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
5987 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
5988 {
5989 vosStatus = VOS_STATUS_E_BADMSG;
5990 }
5991}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5992/*
5993 * FUNCTION: WDA_DelBAReqCallback
5994 * send DEL BA RSP back to PE
5995 */
5996void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
5997{
5998 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5999 tWDA_CbContext *pWDA;
6000 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6002 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6003 if(NULL == pWdaParams)
6004 {
6005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6006 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6007 VOS_ASSERT(0) ;
6008 return ;
6009 }
6010 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6011 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6012 /* Notify TL about DEL BA in case of recipinet */
6013 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
6014 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
6015 {
6016 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
6017 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6018 /*
6019 * No respone required for WDA_DELBA_IND so just free the request
6020 * param here
6021 */
6022 vos_mem_free(pDelBAReqParams);
6023 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6024 vos_mem_free(pWdaParams);
6025 return ;
6026}
6027
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6028/*
6029 * FUNCTION: WDA_ProcessDelBAReq
6030 * Request to WDI to Update the DELBA REQ params.
6031 */
6032VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
6033 tDelBAParams *pDelBAReqParams)
6034{
6035 WDI_Status status = WDI_STATUS_SUCCESS ;
6036 WDI_DelBAReqParamsType *wdiDelBAReqParam =
6037 (WDI_DelBAReqParamsType *)vos_mem_malloc(
6038 sizeof(WDI_DelBAReqParamsType)) ;
6039 tWDA_ReqParams *pWdaParams ;
6040 tANI_U16 staIdx = 0;
6041 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6042 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6043 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6044 if(NULL == wdiDelBAReqParam)
6045 {
6046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6047 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6048 VOS_ASSERT(0);
6049 return VOS_STATUS_E_NOMEM;
6050 }
6051 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6052 if(NULL == pWdaParams)
6053 {
6054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6055 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6056 VOS_ASSERT(0);
6057 vos_mem_free(wdiDelBAReqParam);
6058 return VOS_STATUS_E_NOMEM;
6059 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6060 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
6061 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
6062 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
6063 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6064 pWdaParams->pWdaContext = pWDA;
6065 /* Store DEL BA pointer, as this will be used for response */
6066 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6067 /* store Params pass it to WDI */
6068 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6069 /* if BA exchange over the air is failed, clear this tid in BaBitmap
6070 * maintained in WDA, so that WDA can retry for another BA session
6071 */
6072 staIdx = pDelBAReqParams->staIdx;
6073 tid = pDelBAReqParams->baTID;
6074 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6075 status = WDI_DelBAReq(wdiDelBAReqParam,
6076 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6077 if(IS_WDI_STATUS_FAILURE(status))
6078 {
6079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6080 "Failure in DEL BA REQ Params WDI API, free all the memory " );
6081 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6082 vos_mem_free(pWdaParams->wdaMsgParam);
6083 vos_mem_free(pWdaParams);
6084 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6085 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6086}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6087
6088/*
6089 * FUNCTION: WDA_UpdateChReqCallback
6090 *
6091 */
6092void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
6093{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6094 tWDA_ReqParams *pWdaParams;
6095 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6096 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6097 WDI_UpdateChannelReqinfoType *pChanInfoType;
6098 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6099
6100 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6101 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6102 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6103 {
6104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6105 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6106 VOS_ASSERT(0);
6107 return;
6108 }
6109
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]6110 pWdaParams = (tWDA_ReqParams *)pUserData;
6111 pwdiUpdateChReqParam =
6112 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
6113 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6114 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
6115 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]6116 /*
6117 * currently there is no response message is expected between PE and
6118 * WDA, Failure return from WDI is a ASSERT condition
6119 */
6120 vos_mem_free(pChanInfoType);
6121 vos_mem_free(pChanList);
6122 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6123 vos_mem_free(pWdaParams);
6124
6125 return;
6126}
6127
6128/*
6129 * FUNCTION: WDA_ProcessUpdateChannelList
6130 * Request to WDI to Update the ChannelList params.
6131 */
6132VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
6133 tSirUpdateChanList *pChanList)
6134{
6135 WDI_Status status = WDI_STATUS_SUCCESS;
6136 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
6137 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
6138 WDI_UpdateChannelReqinfoType *pChanInfoType;
6139 tWDA_ReqParams *pWdaParams;
6140 wpt_uint8 i;
6141
6142 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6143 "------> %s " ,__func__);
6144 if(NULL == pChanList)
6145 {
6146 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6147 "%s: NULL pChanList", __func__);
6148 VOS_ASSERT(0);
6149 return VOS_STATUS_E_INVAL;
6150 }
6151
6152 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
6153 {
6154 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6155 "Update channel list capability Not Supported");
6156 vos_mem_free(pChanList);
6157 return VOS_STATUS_E_INVAL;
6158 }
6159
6160 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
6161 sizeof(WDI_UpdateChReqParamsType));
6162 if(NULL == pwdiUpdateChReqParam)
6163 {
6164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6165 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
6166 __func__);
6167 VOS_ASSERT(0);
6168 vos_mem_free(pChanList);
6169 return VOS_STATUS_E_NOMEM;
6170 }
6171 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
6172 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
6173 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
6174 pChanList->numChan);
6175 if(NULL == pChanInfoType)
6176 {
6177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6178 "%s: VOS MEM Alloc Failure", __func__);
6179 VOS_ASSERT(0);
6180 vos_mem_free(pChanList);
6181 vos_mem_free(pwdiUpdateChReqParam);
6182 return VOS_STATUS_E_NOMEM;
6183 }
6184 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
6185 * pChanList->numChan);
6186 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
6187
6188 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
6189 if(NULL == pWdaParams)
6190 {
6191 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6192 "%s: VOS MEM Alloc Failure", __func__);
6193 VOS_ASSERT(0);
6194 vos_mem_free(pChanList);
6195 vos_mem_free(pChanInfoType);
6196 vos_mem_free(pwdiUpdateChReqParam);
6197 return VOS_STATUS_E_NOMEM;
6198 }
6199 pwdiUpdateChanReqType->numchan = pChanList->numChan;
6200
6201 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
6202 {
6203 pChanInfoType->mhz =
6204 vos_chan_to_freq(pChanList->chanParam[i].chanId);
6205
6206 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
6207 pChanInfoType->band_center_freq2 = 0;
6208
6209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6210 "chan[%d] = %u", i, pChanInfoType->mhz);
6211 if (pChanList->chanParam[i].dfsSet)
6212 {
6213 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
6214 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6215 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
6216 pChanList->chanParam[i].dfsSet);
6217 }
6218
6219 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
6220 {
6221 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
6222 }
6223 else
6224 {
6225 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
6226 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
6227 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
6228 }
6229
6230 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6231 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
6232
6233 pChanInfoType++;
6234 }
6235
6236 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
6237 pWdaParams->pWdaContext = pWDA;
6238 pWdaParams->wdaMsgParam = (void *)pChanList;
6239 /* store Params pass it to WDI */
6240 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
6241 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
6242 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
6243 if(IS_WDI_STATUS_FAILURE(status))
6244 {
6245 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6246 "Failure in Update Channel REQ Params WDI API, free all the memory");
6247 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
6248 vos_mem_free(pwdiUpdateChReqParam);
6249 vos_mem_free(pWdaParams->wdaMsgParam);
6250 vos_mem_free(pWdaParams);
6251 }
6252 return CONVERT_WDI2VOS_STATUS(status);
6253}
6254
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6255/*
6256 * FUNCTION: WDA_AddTSReqCallback
6257 * send ADD TS RSP back to PE
6258 */
6259void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
6260{
6261 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6262 tWDA_CbContext *pWDA;
6263 tAddTsParams *pAddTsReqParams;
6264
6265 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6266 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6267 if(NULL == pWdaParams)
6268 {
6269 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6270 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6271 VOS_ASSERT(0) ;
6272 return ;
6273 }
6274 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6275 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
6276 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6277 vos_mem_free(pWdaParams);
6278
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6279 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6280 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6281 return ;
6282}
6283
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6284/*
6285 * FUNCTION: WDA_ProcessAddTSReq
6286 * Request to WDI to Update the ADD TS REQ params.
6287 */
6288VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
6289 tAddTsParams *pAddTsReqParams)
6290{
6291 WDI_Status status = WDI_STATUS_SUCCESS ;
6292 WDI_AddTSReqParamsType *wdiAddTSReqParam =
6293 (WDI_AddTSReqParamsType *)vos_mem_malloc(
6294 sizeof(WDI_AddTSReqParamsType)) ;
6295 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6296 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6297 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6298 if(NULL == wdiAddTSReqParam)
6299 {
6300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6301 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6302 VOS_ASSERT(0);
6303 return VOS_STATUS_E_NOMEM;
6304 }
6305 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6306 if(NULL == pWdaParams)
6307 {
6308 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6309 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6310 VOS_ASSERT(0);
6311 vos_mem_free(wdiAddTSReqParam);
6312 return VOS_STATUS_E_NOMEM;
6313 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6314 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
6315 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6316 //TS IE
6317 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
6318 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
6319 pAddTsReqParams->tspec.length;
6320
6321 //TS IE : TS INFO : TRAFFIC
6322 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
6323 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
6324 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
6325 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
6326 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
6327 pAddTsReqParams->tspec.tsinfo.traffic.psb;
6328 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
6329 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
6330 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
6331 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
6332 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
6333 pAddTsReqParams->tspec.tsinfo.traffic.direction;
6334 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
6335 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
6336 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
6337 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
6338
6339 //TS IE : TS INFO : SCHEDULE
6340 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
6341 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
6342 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
6343 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6344 //TS IE
6345 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
6346 pAddTsReqParams->tspec.nomMsduSz;
6347 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
6348 pAddTsReqParams->tspec.maxMsduSz;
6349 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
6350 pAddTsReqParams->tspec.minSvcInterval;
6351 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
6352 pAddTsReqParams->tspec.maxSvcInterval;
6353 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
6354 pAddTsReqParams->tspec.inactInterval;
6355 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
6356 pAddTsReqParams->tspec.suspendInterval;
6357 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
6358 pAddTsReqParams->tspec.svcStartTime;
6359 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
6360 pAddTsReqParams->tspec.minDataRate;
6361 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
6362 pAddTsReqParams->tspec.meanDataRate;
6363 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
6364 pAddTsReqParams->tspec.peakDataRate;
6365 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
6366 pAddTsReqParams->tspec.maxBurstSz;
6367 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
6368 pAddTsReqParams->tspec.delayBound;
6369 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
6370 pAddTsReqParams->tspec.minPhyRate;
6371 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
6372 pAddTsReqParams->tspec.surplusBw;
6373 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
6374 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6375 /* TODO: tAddTsParams doesn't have the following fields */
6376#if 0
6377 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
6378 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
6379 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
6380 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
6381#endif
6382 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
6383
6384 pWdaParams->pWdaContext = pWDA;
6385 /* Store ADD TS pointer, as this will be used for response */
6386 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6387 /* store Params pass it to WDI */
6388 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6389 status = WDI_AddTSReq(wdiAddTSReqParam,
6390 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6391 if(IS_WDI_STATUS_FAILURE(status))
6392 {
6393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6394 "Failure in ADD TS REQ Params WDI API, free all the memory " );
6395 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6396 vos_mem_free(pWdaParams);
6397 pAddTsReqParams->status = eSIR_FAILURE ;
6398 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
6399 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6400 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6401}
6402
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6403/*
6404 * FUNCTION: WDA_DelTSReqCallback
6405 * send DEL TS RSP back to PE
6406 */
6407void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
6408{
6409 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6411 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6412 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6413 vos_mem_free(pWdaParams->wdaMsgParam) ;
6414 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6415 /*
6416 * No respone required for WDA_DEL_TS_REQ so just free the request
6417 * param here
6418 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6419 return ;
6420}
6421
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6422/*
6423 * FUNCTION: WDA_ProcessDelTSReq
6424 * Request to WDI to Update the DELTS REQ params.
6425 */
6426VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
6427 tDelTsParams *pDelTSReqParams)
6428{
6429 WDI_Status status = WDI_STATUS_SUCCESS ;
6430 WDI_DelTSReqParamsType *wdiDelTSReqParam =
6431 (WDI_DelTSReqParamsType *)vos_mem_malloc(
6432 sizeof(WDI_DelTSReqParamsType)) ;
6433 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6434 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6435 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6436 if(NULL == wdiDelTSReqParam)
6437 {
6438 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6439 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6440 VOS_ASSERT(0);
6441 return VOS_STATUS_E_NOMEM;
6442 }
6443 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6444 if(NULL == pWdaParams)
6445 {
6446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6447 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6448 VOS_ASSERT(0);
6449 vos_mem_free(wdiDelTSReqParam);
6450 return VOS_STATUS_E_NOMEM;
6451 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6452 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
6453 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
6454 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
6455 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
6456 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6457 pWdaParams->pWdaContext = pWDA;
6458 /* Store DEL TS pointer, as this will be used for response */
6459 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6460 /* store Params pass it to WDI */
6461 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6462 status = WDI_DelTSReq(wdiDelTSReqParam,
6463 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6464 if(IS_WDI_STATUS_FAILURE(status))
6465 {
6466 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6467 "Failure in DEL TS REQ Params WDI API, free all the memory " );
6468 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6469 vos_mem_free(pWdaParams->wdaMsgParam);
6470 vos_mem_free(pWdaParams);
6471 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6472 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6473}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6474/*
6475 * FUNCTION: WDA_UpdateBeaconParamsCallback
6476 * Free the memory. No need to send any response to PE in this case
6477 */
6478void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
6479{
6480 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6482 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6483 if(NULL == pWdaParams)
6484 {
6485 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6486 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6487 VOS_ASSERT(0) ;
6488 return ;
6489 }
6490 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6491 vos_mem_free(pWdaParams->wdaMsgParam) ;
6492 vos_mem_free(pWdaParams);
6493 /*
6494 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
6495 * param here
6496 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6497 return ;
6498}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6499/*
6500 * FUNCTION: WDA_ProcessUpdateBeaconParams
6501 * Request to WDI to send the beacon parameters to HAL to update the Hardware
6502 */
6503VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
6504 tUpdateBeaconParams *pUpdateBeaconParams)
6505{
6506 WDI_Status status = WDI_STATUS_SUCCESS ;
6507 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
6508 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
6509 sizeof(WDI_UpdateBeaconParamsType)) ;
6510 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6511 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6512 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6513 if(NULL == wdiUpdateBeaconParams)
6514 {
6515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6516 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6517 VOS_ASSERT(0);
6518 return VOS_STATUS_E_NOMEM;
6519 }
6520 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6521 if(NULL == pWdaParams)
6522 {
6523 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6524 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6525 VOS_ASSERT(0);
6526 vos_mem_free(wdiUpdateBeaconParams);
6527 return VOS_STATUS_E_NOMEM;
6528 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6529 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
6530 pUpdateBeaconParams->bssIdx;
6531 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
6532 pUpdateBeaconParams->fShortPreamble;
6533 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
6534 pUpdateBeaconParams->fShortSlotTime;
6535 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
6536 pUpdateBeaconParams->beaconInterval;
6537 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
6538 pUpdateBeaconParams->llaCoexist;
6539 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
6540 pUpdateBeaconParams->llbCoexist;
6541 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
6542 pUpdateBeaconParams->llgCoexist;
6543 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
6544 pUpdateBeaconParams->ht20MhzCoexist;
6545 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
6546 pUpdateBeaconParams->llnNonGFCoexist;
6547 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
6548 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
6549 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
6550 pUpdateBeaconParams->fRIFSMode;
6551 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
6552 pUpdateBeaconParams->paramChangeBitmap;
6553 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
6554
6555 pWdaParams->pWdaContext = pWDA;
6556 /* Store UpdateBeacon Req pointer, as this will be used for response */
6557 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6558 /* store Params pass it to WDI */
6559 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6560 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
6561 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
6562 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6563 if(IS_WDI_STATUS_FAILURE(status))
6564 {
6565 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6566 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
6567 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6568 vos_mem_free(pWdaParams->wdaMsgParam);
6569 vos_mem_free(pWdaParams);
6570 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6571 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6572}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6573#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6574/*
6575 * FUNCTION: WDA_TSMStatsReqCallback
6576 * send TSM Stats RSP back to PE
6577 */
6578void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
6579{
6580 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6581 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6582 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
6583 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6584
6585 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6586 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6587 if(NULL == pWdaParams)
6588 {
6589 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6590 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6591 VOS_ASSERT(0) ;
6592 return ;
6593 }
6594 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6595 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
6596
6597 if(NULL == pGetTsmStatsReqParams)
6598 {
6599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6600 "%s: pGetTsmStatsReqParams received NULL", __func__);
6601 VOS_ASSERT(0);
6602 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6603 vos_mem_free(pWdaParams);
6604 return;
6605 }
6606
6607 pTsmRspParams =
6608 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6609 if( NULL == pTsmRspParams )
6610 {
6611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6612 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6613 VOS_ASSERT( 0 );
6614 return ;
6615 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6616 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
6617 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
6618 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
6619
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6620 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
6621 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
6622 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
6623 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
6624 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
6625 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
6626 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
6627 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
6628 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
6629 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6630
6631 /* Assign get tsm stats req req (backup) in to the response */
6632 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
6633
6634 /* free WDI command buffer */
6635 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6636 vos_mem_free(pWdaParams);
6637
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6638 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6639 return ;
6640}
6641
6642
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6643/*
6644 * FUNCTION: WDA_ProcessTsmStatsReq
6645 * Request to WDI to get the TSM Stats params.
6646 */
6647VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6648 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6649{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6650 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6651 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6652 tWDA_ReqParams *pWdaParams = NULL;
6653 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
6654
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6656 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6657 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
6658 sizeof(WDI_TSMStatsReqParamsType));
6659 if(NULL == wdiTSMReqParam)
6660 {
6661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6662 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6663 VOS_ASSERT(0);
6664 return VOS_STATUS_E_NOMEM;
6665 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6666 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6667 if(NULL == pWdaParams)
6668 {
6669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6670 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6671 VOS_ASSERT(0);
6672 vos_mem_free(wdiTSMReqParam);
6673 return VOS_STATUS_E_NOMEM;
6674 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6675 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
6676 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
6677 pTsmStats->bssId,
6678 sizeof(wpt_macAddr));
6679 wdiTSMReqParam->wdiReqStatusCB = NULL ;
6680
6681 pWdaParams->pWdaContext = pWDA;
6682 /* Store TSM Stats pointer, as this will be used for response */
6683 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6684 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6685 status = WDI_TSMStatsReq(wdiTSMReqParam,
6686 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6687 if(IS_WDI_STATUS_FAILURE(status))
6688 {
6689 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6690 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]6691 vos_mem_free(pWdaParams);
6692
6693 pGetTsmStatsRspParams =
6694 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
6695 if(NULL == pGetTsmStatsRspParams)
6696 {
6697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6698 "%s: VOS MEM Alloc Failure", __func__);
6699 VOS_ASSERT(0);
6700 vos_mem_free(pTsmStats);
6701 return VOS_STATUS_E_NOMEM;
6702 }
6703 pGetTsmStatsRspParams->staId = pTsmStats->staId;
6704 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
6705 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
6706
6707 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6708 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6709 return CONVERT_WDI2VOS_STATUS(status) ;
6710}
6711#endif
6712/*
6713 * FUNCTION: WDA_SendBeaconParamsCallback
6714 * No need to send any response to PE in this case
6715 */
6716void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
6717{
6718
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6720 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6721 return ;
6722}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6723/*
6724 * FUNCTION: WDA_ProcessSendBeacon
6725 * Request to WDI to send the beacon template to HAL to update the TPE memory and
6726 * start beacon trasmission
6727 */
6728VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
6729 tSendbeaconParams *pSendbeaconParams)
6730{
6731 WDI_Status status = WDI_STATUS_SUCCESS ;
6732 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6733 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6734 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6735 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
6736 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
6737 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
6738 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6739 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
6740 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]6741 /* p2pIeOffset should be atleast greater than timIeOffset */
6742 if ((pSendbeaconParams->p2pIeOffset != 0) &&
6743 (pSendbeaconParams->p2pIeOffset <
6744 pSendbeaconParams->timIeOffset))
6745 {
6746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6747 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
6748 VOS_ASSERT( 0 );
6749 return WDI_STATUS_E_FAILURE;
6750 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6751 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
6752 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6753 /* Copy the beacon template to local buffer */
6754 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
6755 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
6756 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
6757
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6758 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
6759 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6760 if(IS_WDI_STATUS_FAILURE(status))
6761 {
6762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6763 "Failure in SEND BEACON REQ Params WDI API" );
6764 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6765 vos_mem_free(pSendbeaconParams);
6766 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6767}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6768/*
6769 * FUNCTION: WDA_UpdateProbeRspParamsCallback
6770 * No need to send any response to PE in this case
6771 */
6772void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
6773{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6774 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6775 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6776 return ;
6777}
6778
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6779/*
6780 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
6781 * Request to WDI to send the probe response template to HAL to update the TPE memory and
6782 * send probe response
6783 */
6784VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
6785 tSendProbeRespParams *pSendProbeRspParams)
6786{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6787 WDI_Status status = WDI_STATUS_SUCCESS;
6788 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
6789 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6790 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6791 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6792
6793 if (!wdiSendProbeRspParam)
6794 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
6795
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6796 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6797 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6798 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6799 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6800 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6801 /* Copy the Probe Response template to local buffer */
6802 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6803 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6804 pSendProbeRspParams->pProbeRespTemplate,
6805 pSendProbeRspParams->probeRespTemplateLen);
6806 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6807 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6808 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
6809 WDI_PROBE_REQ_BITMAP_IE_LEN);
6810
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6811 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6812
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6813 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6814 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6815 if(IS_WDI_STATUS_FAILURE(status))
6816 {
6817 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6818 "Failure in SEND Probe RSP Params WDI API" );
6819 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6820 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]6821 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6822 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6823}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6824#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6825/*
6826 * FUNCTION: WDA_SetMaxTxPowerCallBack
6827 * send the response to PE with power value received from WDI
6828 */
6829void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
6830 void* pUserData)
6831{
6832 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6833 tWDA_CbContext *pWDA = NULL;
6834 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
6835
6836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6837 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6838 if(NULL == pWdaParams)
6839 {
6840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6841 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6842 VOS_ASSERT(0) ;
6843 return ;
6844 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6845 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6846 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6847 if( NULL == pMaxTxPowerParams )
6848 {
6849 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6850 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6851 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6852 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6853 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6854 return ;
6855 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6856
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6857
6858 /*need to free memory for the pointers used in the
6859 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6860 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6861 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6862 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6863
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6864
6865 /* send response to UMAC*/
6866 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
6867
6868 return;
6869}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6870/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6871 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6872 * Request to WDI to send set Max Tx Power Request
6873 */
6874 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
6875 tMaxTxPowerParams *MaxTxPowerParams)
6876{
6877 WDI_Status status = WDI_STATUS_SUCCESS;
6878 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
6879 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]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 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6883
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6884 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
6885 sizeof(WDI_SetMaxTxPowerParamsType));
6886 if(NULL == wdiSetMaxTxPowerParams)
6887 {
6888 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6889 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6890 VOS_ASSERT(0);
6891 return VOS_STATUS_E_NOMEM;
6892 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6893 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6894 if(NULL == pWdaParams)
6895 {
6896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6897 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6898 vos_mem_free(wdiSetMaxTxPowerParams);
6899 VOS_ASSERT(0);
6900 return VOS_STATUS_E_NOMEM;
6901 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6902 /* Copy.Max.Tx.Power Params to WDI structure */
6903 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
6904 MaxTxPowerParams->bssId,
6905 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6906 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
6907 MaxTxPowerParams->selfStaMacAddr,
6908 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6909 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
6910 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6911 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6912 pWdaParams->pWdaContext = pWDA;
6913 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6914 /* store Params pass it to WDI */
6915 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6916 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
6917 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6918 if(IS_WDI_STATUS_FAILURE(status))
6919 {
6920 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6921 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
6922 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6923 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]6924 /* send response to UMAC*/
6925 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6926 }
6927 return CONVERT_WDI2VOS_STATUS(status);
6928
6929}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6930#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]6931
6932/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]6933 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
6934 * send the response to PE with power value received from WDI
6935 */
6936void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
6937 *pwdiSetMaxTxPowerPerBandRsp,
6938 void* pUserData)
6939{
6940 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6941 tWDA_CbContext *pWDA = NULL;
6942 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
6943
6944 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6945 "<------ %s ", __func__);
6946 if (NULL == pWdaParams)
6947 {
6948 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6949 "%s: pWdaParams received NULL", __func__);
6950 VOS_ASSERT(0);
6951 return ;
6952 }
6953 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
6954 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
6955 if ( NULL == pMxTxPwrPerBandParams )
6956 {
6957 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6958 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
6959 VOS_ASSERT(0);
6960 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6961 vos_mem_free(pWdaParams);
6962 return;
6963 }
6964
6965 /*need to free memory for the pointers used in the
6966 WDA Process.Set Max Tx Power Req function*/
6967 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6968 vos_mem_free(pWdaParams);
6969 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
6970
6971 /* send response to UMAC*/
6972 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
6973 pMxTxPwrPerBandParams, 0);
6974
6975 return;
6976}
6977
6978/*
6979 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
6980 * Request to WDI to send set Max Tx Power Per band Request
6981 */
6982 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
6983 tMaxTxPowerPerBandParams
6984 *MaxTxPowerPerBandParams)
6985{
6986 WDI_Status status = WDI_STATUS_SUCCESS;
6987 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
6988 tWDA_ReqParams *pWdaParams = NULL;
6989
6990 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6991 "------> %s ", __func__);
6992
6993 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
6994 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
6995
6996 if (NULL == wdiSetMxTxPwrPerBandParams)
6997 {
6998 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6999 "%s: VOS MEM Alloc Failure", __func__);
7000 VOS_ASSERT(0);
7001 return VOS_STATUS_E_NOMEM;
7002 }
7003 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7004 if (NULL == pWdaParams)
7005 {
7006 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7007 "%s: VOS MEM Alloc Failure", __func__);
7008 vos_mem_free(wdiSetMxTxPwrPerBandParams);
7009 VOS_ASSERT(0);
7010 return VOS_STATUS_E_NOMEM;
7011 }
7012 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
7013 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
7014 MaxTxPowerPerBandParams->bandInfo;
7015 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
7016 MaxTxPowerPerBandParams->power;
7017 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
7018 pWdaParams->pWdaContext = pWDA;
7019 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
7020 /* store Params pass it to WDI */
7021 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
7022 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
7023 WDA_SetMaxTxPowerPerBandCallBack,
7024 pWdaParams);
7025 if (IS_WDI_STATUS_FAILURE(status))
7026 {
7027 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7028 "Failure in SET MAX TX Power REQ Params WDI API,"
7029 " free all the memory");
7030 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7031 vos_mem_free(pWdaParams);
7032 /* send response to UMAC*/
7033 WDA_SendMsg(pWDA,
7034 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
7035 MaxTxPowerPerBandParams, 0);
7036 }
7037 return CONVERT_WDI2VOS_STATUS(status);
7038}
7039
7040/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]7041 * FUNCTION: WDA_SetTxPowerCallBack
7042 * send the response to PE with power value received from WDI
7043 */
7044void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7045 void* pUserData)
7046{
7047 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7048 tWDA_CbContext *pWDA = NULL;
7049 tSirSetTxPowerReq *pTxPowerParams = NULL;
7050
7051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7052 "<------ %s ", __func__);
7053 if(NULL == pWdaParams)
7054 {
7055 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7056 "%s: pWdaParams received NULL", __func__);
7057 VOS_ASSERT(0) ;
7058 return ;
7059 }
7060 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7061 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
7062 if(NULL == pTxPowerParams)
7063 {
7064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7065 "%s: pTxPowerParams received NULL " ,__func__);
7066 VOS_ASSERT(0);
7067 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7068 vos_mem_free(pWdaParams);
7069 return ;
7070 }
7071
7072 /*need to free memory for the pointers used in the
7073 WDA Process.Set Max Tx Power Req function*/
7074 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7075 vos_mem_free(pWdaParams);
7076
7077 /* send response to UMAC*/
7078 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
7079 return;
7080}
7081
7082/*
7083 * FUNCTION: WDA_ProcessSetTxPowerReq
7084 * Request to WDI to send set Tx Power Request
7085 */
7086 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
7087 tSirSetTxPowerReq *txPowerParams)
7088{
7089 WDI_Status status = WDI_STATUS_SUCCESS;
7090 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
7091 tWDA_ReqParams *pWdaParams = NULL;
7092
7093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7094 "------> %s ", __func__);
7095
7096 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
7097 sizeof(WDI_SetTxPowerParamsType));
7098 if(NULL == wdiSetTxPowerParams)
7099 {
7100 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7101 "%s: VOS MEM Alloc Failure", __func__);
7102 VOS_ASSERT(0);
7103 return VOS_STATUS_E_NOMEM;
7104 }
7105 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7106 if(NULL == pWdaParams)
7107 {
7108 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7109 "%s: VOS MEM Alloc Failure", __func__);
7110 vos_mem_free(wdiSetTxPowerParams);
7111 VOS_ASSERT(0);
7112 return VOS_STATUS_E_NOMEM;
7113 }
7114 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
7115 txPowerParams->bssIdx;
7116 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
7117 txPowerParams->mwPower;
7118 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
7119 pWdaParams->pWdaContext = pWDA;
7120 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
7121 /* store Params pass it to WDI */
7122 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
7123 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
7124 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
7125 if(IS_WDI_STATUS_FAILURE(status))
7126 {
7127 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7128 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
7129 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7130 vos_mem_free(pWdaParams);
7131 /* send response to UMAC*/
7132 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
7133 }
7134 return CONVERT_WDI2VOS_STATUS(status);
7135}
7136
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7137/*
7138 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7139 * Free the memory. No need to send any response to PE in this case
7140 */
7141void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
7142{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7143 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7144
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7145 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7146 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7147
7148 if(NULL == pWdaParams)
7149 {
7150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7151 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7152 VOS_ASSERT(0) ;
7153 return ;
7154 }
7155
7156 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7157 vos_mem_free(pWdaParams->wdaMsgParam) ;
7158 vos_mem_free(pWdaParams);
7159
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7160 /*
7161 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
7162 * so just free the request param here
7163 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7164 return ;
7165}
7166
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7167/*
7168 * FUNCTION: WDA_ProcessSetP2PGONOAReq
7169 * Request to WDI to set the P2P Group Owner Notice of Absence Req
7170 */
7171VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
7172 tP2pPsParams *pP2pPsConfigParams)
7173{
7174 WDI_Status status = WDI_STATUS_SUCCESS ;
7175 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
7176 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
7177 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7178 tWDA_ReqParams *pWdaParams = NULL;
7179
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7180 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7181 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7182 if(NULL == wdiSetP2PGONOAReqParam)
7183 {
7184 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7185 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7186 VOS_ASSERT(0);
7187 return VOS_STATUS_E_NOMEM;
7188 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7189
7190 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7191 if(NULL == pWdaParams)
7192 {
7193 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7194 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7195 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7196 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7197 VOS_ASSERT(0);
7198 return VOS_STATUS_E_NOMEM;
7199 }
7200
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7201 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
7202 pP2pPsConfigParams->opp_ps;
7203 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
7204 pP2pPsConfigParams->ctWindow;
7205 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
7206 pP2pPsConfigParams->count;
7207 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
7208 pP2pPsConfigParams->duration;
7209 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
7210 pP2pPsConfigParams->interval;
7211 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
7212 pP2pPsConfigParams->single_noa_duration;
7213 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
7214 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7215
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7216 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
7217 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7218 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
7219
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7220 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7221 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
7222 pWdaParams->pWdaContext = pWDA;
7223
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7224 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7225 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
7226
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7227 if(IS_WDI_STATUS_FAILURE(status))
7228 {
7229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7230 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7231 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7232 vos_mem_free(pWdaParams->wdaMsgParam);
7233 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7234 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7235 return CONVERT_WDI2VOS_STATUS(status);
7236
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7237}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7238
7239#ifdef FEATURE_WLAN_TDLS
7240/*
7241 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
7242 * Free the memory. No need to send any response to PE in this case
7243 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7244void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
7245 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7246{
7247 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7248 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7249 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7250
7251
7252 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7253 "<------ %s " ,__func__);
7254 if(NULL == pWdaParams)
7255 {
7256 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7257 "%s: pWdaParams received NULL", __func__);
7258 VOS_ASSERT(0) ;
7259 return ;
7260 }
7261 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
7262
7263 if(NULL == pWdaParams)
7264 {
7265 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7266 "%s: pWdaParams received NULL", __func__);
7267 VOS_ASSERT(0) ;
7268 return ;
7269 }
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7270 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
7271 if( NULL == pTdlsLinkEstablishParams )
7272 {
7273 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7274 "%s: pTdlsLinkEstablishParams "
7275 "received NULL " ,__func__);
7276 VOS_ASSERT(0);
7277 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7278 vos_mem_free(pWdaParams);
7279 return ;
7280 }
7281 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
7282 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7283 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7284 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7285 /* send response to UMAC*/
7286 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
7287
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7288 return ;
7289}
7290
7291VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
7292 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
7293{
7294 WDI_Status status = WDI_STATUS_SUCCESS ;
7295 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
7296 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
7297 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
7298 tWDA_ReqParams *pWdaParams = NULL;
7299 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7300 "------> %s " ,__func__);
7301 if(NULL == wdiSetTDLSLinkEstablishReqParam)
7302 {
7303 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7304 "%s: VOS MEM Alloc Failure", __func__);
7305 VOS_ASSERT(0);
7306 return VOS_STATUS_E_NOMEM;
7307 }
7308 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7309 if(NULL == pWdaParams)
7310 {
7311 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7312 "%s: VOS MEM Alloc Failure", __func__);
7313 vos_mem_free(pTdlsLinkEstablishParams);
7314 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
7315 VOS_ASSERT(0);
7316 return VOS_STATUS_E_NOMEM;
7317 }
7318 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7319 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7320 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7321 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7322 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7323 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7324 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7325 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7326 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]7327 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]7328 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
7329 pTdlsLinkEstablishParams->isOffChannelSupported;
7330
7331 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
7332 pTdlsLinkEstablishParams->validChannels,
7333 pTdlsLinkEstablishParams->validChannelsLen);
7334
7335 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
7336 pTdlsLinkEstablishParams->validChannelsLen;
7337
7338 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
7339 pTdlsLinkEstablishParams->validOperClasses,
7340 pTdlsLinkEstablishParams->validOperClassesLen);
7341 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
7342 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]7343
7344 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
7345 /* Store msg pointer from PE, as this will be used for response */
7346 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
7347 /* store Params pass it to WDI */
7348 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
7349 pWdaParams->pWdaContext = pWDA;
7350
7351 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
7352 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
7353 WDA_SetTDLSLinkEstablishReqParamsCallback,
7354 pWdaParams);
7355 if(IS_WDI_STATUS_FAILURE(status))
7356 {
7357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7358 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
7359 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7360 vos_mem_free(pWdaParams->wdaMsgParam);
7361 vos_mem_free(pWdaParams);
7362 }
7363 return CONVERT_WDI2VOS_STATUS(status);
7364}
7365#endif
7366
7367
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7368#ifdef WLAN_FEATURE_VOWIFI_11R
7369/*
7370 * FUNCTION: WDA_AggrAddTSReqCallback
7371 * send ADD AGGREGATED TS RSP back to PE
7372 */
7373void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
7374{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7375 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
7376 tWDA_CbContext *pWDA;
7377 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7378 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7379 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7380 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7381 if(NULL == pWdaParams)
7382 {
7383 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7384 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7385 VOS_ASSERT(0) ;
7386 return ;
7387 }
7388
7389 pWDA = pWdaParams->pWdaContext;
7390 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7391
7392 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7393 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7394 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7395 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7396 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7397
7398 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7399 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7400 return ;
7401}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7402/*
7403 * FUNCTION: WDA_ProcessAddTSReq
7404 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
7405 */
7406VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
7407 tAggrAddTsParams *pAggrAddTsReqParams)
7408{
7409 WDI_Status status = WDI_STATUS_SUCCESS ;
7410 int i;
7411 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7412 tWDA_ReqParams *pWdaParams = NULL;
7413
7414
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7416 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7417 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
7418 sizeof(WDI_AggrAddTSReqParamsType)) ;
7419 if(NULL == wdiAggrAddTSReqParam)
7420 {
7421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7422 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7423 VOS_ASSERT(0);
7424 return VOS_STATUS_E_NOMEM;
7425 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7426
7427
7428 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7429 if(NULL == pWdaParams)
7430 {
7431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7432 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7433 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]7434 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7435 VOS_ASSERT(0);
7436 return VOS_STATUS_E_NOMEM;
7437 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7438 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
7439 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
7440 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7441 for( i = 0; i < WDI_MAX_NO_AC; i++ )
7442 {
7443 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
7444 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
7445 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7446 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
7447 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
7448 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
7449 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
7450 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
7451 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
7452 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
7453 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
7454 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
7455 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
7456 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
7457 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
7458 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
7459 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
7460 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
7461 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7462 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
7463 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7464 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
7465 pAggrAddTsReqParams->tspec[i].nomMsduSz;
7466 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
7467 pAggrAddTsReqParams->tspec[i].maxMsduSz;
7468 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
7469 pAggrAddTsReqParams->tspec[i].minSvcInterval;
7470 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
7471 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
7472 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
7473 pAggrAddTsReqParams->tspec[i].inactInterval;
7474 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
7475 pAggrAddTsReqParams->tspec[i].suspendInterval;
7476 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
7477 pAggrAddTsReqParams->tspec[i].svcStartTime;
7478 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
7479 pAggrAddTsReqParams->tspec[i].minDataRate;
7480 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
7481 pAggrAddTsReqParams->tspec[i].meanDataRate;
7482 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
7483 pAggrAddTsReqParams->tspec[i].peakDataRate;
7484 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
7485 pAggrAddTsReqParams->tspec[i].maxBurstSz;
7486 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
7487 pAggrAddTsReqParams->tspec[i].delayBound;
7488 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
7489 pAggrAddTsReqParams->tspec[i].minPhyRate;
7490 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
7491 pAggrAddTsReqParams->tspec[i].surplusBw;
7492 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
7493 pAggrAddTsReqParams->tspec[i].mediumTime;
7494 }
7495
7496 /* TODO: tAggrAddTsParams doesn't have the following fields */
7497#if 0
7498 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7499 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
7500 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7501 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7502#endif
7503 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
7504
7505 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7506 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7507 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7508 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
7509
7510 pWdaParams->pWdaContext = pWDA;
7511
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7512 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7513 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
7514
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7515 if(IS_WDI_STATUS_FAILURE(status))
7516 {
7517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7518 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7519 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7520 vos_mem_free(pWdaParams);
7521
7522 /* send the failure response back to PE*/
7523 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
7524 {
7525 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
7526 }
7527
7528 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
7529 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7530 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7531 return CONVERT_WDI2VOS_STATUS(status) ;
7532}
7533#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7534/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7535 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7536 * send Enter IMPS RSP back to PE
7537 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7538void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7539{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7540 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7541 tWDA_CbContext *pWDA;
7542
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7543 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7544 "<------ %s status=%d" ,__func__,status);
7545 if(NULL == pWdaParams)
7546 {
7547 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7548 "%s: pWdaParams received NULL", __func__);
7549 VOS_ASSERT(0);
7550 return;
7551 }
7552
7553 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7554
7555 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7556 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7557 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7558 return ;
7559}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7560
7561
7562/*
7563 * FUNCTION: WDA_EnterImpsReqCallback
7564 * Free memory and send Enter IMPS RSP back to PE.
7565 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
7566 */
7567void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7568{
7569 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7570 tWDA_CbContext *pWDA;
7571
7572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7573 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7574
7575 if(NULL == pWdaParams)
7576 {
7577 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7578 "%s: pWdaParams received NULL", __func__);
7579 VOS_ASSERT(0);
7580 return;
7581 }
7582
7583 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7584
7585 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7586 {
7587 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7588 vos_mem_free(pWdaParams);
7589 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7590 CONVERT_WDI2SIR_STATUS(wdiStatus));
7591 }
7592
7593 return;
7594}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7595/*
7596 * FUNCTION: WDA_ProcessEnterImpsReq
7597 * Request to WDI to Enter IMPS power state.
7598 */
7599VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
7600{
7601 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7602 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
7603 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7605 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7606
7607
7608 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
7609 if (NULL == wdiEnterImpsReqParams)
7610 {
7611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7612 "%s: VOS MEM Alloc Failure", __func__);
7613 VOS_ASSERT(0);
7614 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
7615 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7616 return VOS_STATUS_E_NOMEM;
7617 }
7618
7619 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7620 if (NULL == pWdaParams)
7621 {
7622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7623 "%s: VOS MEM Alloc Failure", __func__);
7624 VOS_ASSERT(0);
7625 vos_mem_free(wdiEnterImpsReqParams);
7626 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
7627 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
7628 return VOS_STATUS_E_NOMEM;
7629 }
7630
7631 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
7632 wdiEnterImpsReqParams->pUserData = pWdaParams;
7633
7634 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
7635 pWdaParams->wdaMsgParam = NULL;
7636 pWdaParams->pWdaContext = pWDA;
7637
7638 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
7639 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
7640 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7641 if(IS_WDI_STATUS_FAILURE(status))
7642 {
7643 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7644 "Failure in Enter IMPS REQ WDI API, free all the memory " );
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]7645 vos_mem_free(wdiEnterImpsReqParams);
7646 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7647 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7649 return CONVERT_WDI2VOS_STATUS(status) ;
7650}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7651/*
7652 * FUNCTION: WDA_ExitImpsReqCallback
7653 * send Exit IMPS RSP back to PE
7654 */
7655void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
7656{
7657 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7659 "<------ %s " ,__func__);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7660 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7661 return ;
7662}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7663/*
7664 * FUNCTION: WDA_ProcessExitImpsReq
7665 * Request to WDI to Exit IMPS power state.
7666 */
7667VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
7668{
7669 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7670 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7671 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7672 status = WDI_ExitImpsReq((WDI_ExitImpsRspCb)WDA_ExitImpsReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7673 if(IS_WDI_STATUS_FAILURE(status))
7674 {
7675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7676 "Failure in Exit IMPS REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7677 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7678 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7679 return CONVERT_WDI2VOS_STATUS(status) ;
7680}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7681/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7682 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7683 * send Enter BMPS RSP back to PE
7684 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7685void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7686{
7687 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7688 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7689 tEnterBmpsParams *pEnterBmpsRspParams;
7690
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7692 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7693 if(NULL == pWdaParams)
7694 {
7695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7696 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7697 VOS_ASSERT(0) ;
7698 return ;
7699 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7700
7701 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7702 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
7703
7704 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7705 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7706
7707 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7708 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7709 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
7710
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7711 return ;
7712}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7713/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7714 * FUNCTION: WDA_EnterBmpsReqCallback
7715 * Free memory and send Enter BMPS RSP back to PE.
7716 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
7717 */
7718void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7719{
7720 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7721 tWDA_CbContext *pWDA;
7722 tEnterBmpsParams *pEnterBmpsRspParams;
7723
7724 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7725 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7726
7727 if(NULL == pWdaParams)
7728 {
7729 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7730 "%s: pWdaParams received NULL", __func__);
7731 VOS_ASSERT(0);
7732 return;
7733 }
7734
7735 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7736 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
7737 pEnterBmpsRspParams->status = wdiStatus;
7738
7739 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7740 {
7741 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7742 vos_mem_free(pWdaParams);
7743 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
7744 }
7745
7746 return;
7747}
7748/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7749 * FUNCTION: WDA_ProcessEnterBmpsReq
7750 * Request to WDI to Enter BMPS power state.
7751 */
7752VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
7753 tEnterBmpsParams *pEnterBmpsReqParams)
7754{
7755 WDI_Status status = WDI_STATUS_SUCCESS;
7756 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
7757 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7758 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7759 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7760 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
7761 {
7762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7763 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7764 VOS_ASSERT(0);
7765 return VOS_STATUS_E_FAILURE;
7766 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7767 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
7768 if (NULL == wdiEnterBmpsReqParams)
7769 {
7770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7771 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7772 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7773 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
7774 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7775 return VOS_STATUS_E_NOMEM;
7776 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7777 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7778 if (NULL == pWdaParams)
7779 {
7780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7781 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7782 VOS_ASSERT(0);
7783 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7784 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
7785 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7786 return VOS_STATUS_E_NOMEM;
7787 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7788 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
7789 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
7790 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
7791 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7792 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7793 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
7794 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
7795 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7796 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
7797 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7798
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7799 /* Store param pointer as passed in by caller */
7800 /* store Params pass it to WDI */
7801 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7802 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7803 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7804 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7805 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7806 if (IS_WDI_STATUS_FAILURE(status))
7807 {
7808 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7809 "Failure in Enter BMPS REQ WDI API, free all the memory" );
7810 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]7811 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7812 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7813 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7814 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7815 return CONVERT_WDI2VOS_STATUS(status);
7816}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7817
7818
7819static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
7820 WDI_Status wdiStatus,
7821 tExitBmpsParams *pExitBmpsReqParams)
7822{
7823 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
7824
7825 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
7826}
7827
7828
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7829/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7830 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7831 * send Exit BMPS RSP back to PE
7832 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7833void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7834{
7835 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7836 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7837 tExitBmpsParams *pExitBmpsRspParams;
7838
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7840 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7841 if(NULL == pWdaParams)
7842 {
7843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7844 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7845 VOS_ASSERT(0) ;
7846 return ;
7847 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7848
7849 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7850 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
7851
7852 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7853 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7854
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7855 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7856 vos_mem_free(pWdaParams) ;
7857
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7858 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7859 return ;
7860}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7861/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7862 * FUNCTION: WDA_ExitBmpsReqCallback
7863 * Free memory and send Exit BMPS RSP back to PE.
7864 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
7865 */
7866void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
7867{
7868 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7869 tWDA_CbContext *pWDA;
7870 tExitBmpsParams *pExitBmpsRspParams;
7871
7872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7873 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7874
7875 if(NULL == pWdaParams)
7876 {
7877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7878 "%s: pWdaParams received NULL", __func__);
7879 VOS_ASSERT(0);
7880 return;
7881 }
7882
7883 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7884 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
7885 pExitBmpsRspParams->status = wdiStatus;
7886
7887 if(IS_WDI_STATUS_FAILURE(wdiStatus))
7888 {
7889 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7890 vos_mem_free(pWdaParams);
7891 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
7892 }
7893
7894 return;
7895}
7896/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7897 * FUNCTION: WDA_ProcessExitBmpsReq
7898 * Request to WDI to Exit BMPS power state.
7899 */
7900VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
7901 tExitBmpsParams *pExitBmpsReqParams)
7902{
7903 WDI_Status status = WDI_STATUS_SUCCESS ;
7904 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
7905 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
7906 sizeof(WDI_ExitBmpsReqParamsType)) ;
7907 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7909 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7910 if(NULL == wdiExitBmpsReqParams)
7911 {
7912 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7913 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7914 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7915 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7916 return VOS_STATUS_E_NOMEM;
7917 }
7918 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7919 if(NULL == pWdaParams)
7920 {
7921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7922 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7923 VOS_ASSERT(0);
7924 vos_mem_free(wdiExitBmpsReqParams);
7925 return VOS_STATUS_E_NOMEM;
7926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7927 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7928
7929 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
7930
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7931 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
7932 wdiExitBmpsReqParams->pUserData = pWdaParams;
7933
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7934 /* Store param pointer as passed in by caller */
7935 /* store Params pass it to WDI */
7936 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
7937 pWdaParams->pWdaContext = pWDA;
7938 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7939 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7940 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7941 if(IS_WDI_STATUS_FAILURE(status))
7942 {
7943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7944 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7945 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7946 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]7947 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7948 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7949 return CONVERT_WDI2VOS_STATUS(status) ;
7950}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7951/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7952 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7953 * send Enter UAPSD RSP back to PE
7954 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7955void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7956{
7957 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7958 tWDA_CbContext *pWDA;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7959 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7960 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7961 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7962 if(NULL == pWdaParams)
7963 {
7964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7965 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7966 VOS_ASSERT(0) ;
7967 return ;
7968 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7969
7970 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
7971 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
7972
7973 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7974 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7975
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7976 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7977 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]7978 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7979 return ;
7980}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7981/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]7982 * FUNCTION: WDA_EnterUapsdReqCallback
7983 * Free memory and send Enter UAPSD RSP back to PE.
7984 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
7985 */
7986void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
7987{
7988 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7989 tWDA_CbContext *pWDA;
7990 tUapsdParams *pEnterUapsdRsqParams;
7991
7992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7993 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
7994
7995 if(NULL == pWdaParams)
7996 {
7997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7998 "%s: pWdaParams received NULL", __func__);
7999 VOS_ASSERT(0);
8000 return;
8001 }
8002
8003 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8004 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
8005 pEnterUapsdRsqParams->status = wdiStatus;
8006
8007 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8008 {
8009 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8010 vos_mem_free(pWdaParams);
8011 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
8012 }
8013
8014 return;
8015}
8016/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8017 * FUNCTION: WDA_ProcessEnterUapsdReq
8018 * Request to WDI to Enter UAPSD power state.
8019 */
8020VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
8021 tUapsdParams *pEnterUapsdReqParams)
8022{
8023 WDI_Status status = WDI_STATUS_SUCCESS ;
8024 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
8025 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
8026 sizeof(WDI_EnterUapsdReqParamsType)) ;
8027 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8029 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8030 if(NULL == wdiEnterUapsdReqParams)
8031 {
8032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8033 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8034 VOS_ASSERT(0);
8035 return VOS_STATUS_E_NOMEM;
8036 }
8037 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8038 if(NULL == pWdaParams)
8039 {
8040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8041 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8042 VOS_ASSERT(0);
8043 vos_mem_free(wdiEnterUapsdReqParams);
8044 return VOS_STATUS_E_NOMEM;
8045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8046 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
8047 pEnterUapsdReqParams->beDeliveryEnabled;
8048 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
8049 pEnterUapsdReqParams->beTriggerEnabled;
8050 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
8051 pEnterUapsdReqParams->bkDeliveryEnabled;
8052 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
8053 pEnterUapsdReqParams->bkTriggerEnabled;
8054 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
8055 pEnterUapsdReqParams->viDeliveryEnabled;
8056 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
8057 pEnterUapsdReqParams->viTriggerEnabled;
8058 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
8059 pEnterUapsdReqParams->voDeliveryEnabled;
8060 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
8061 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8062 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8063
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8064 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
8065 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8066
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8067 /* Store param pointer as passed in by caller */
8068 /* store Params pass it to WDI */
8069 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
8070 pWdaParams->pWdaContext = pWDA;
8071 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8072 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8073 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8074 if(IS_WDI_STATUS_FAILURE(status))
8075 {
8076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8077 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
8078 vos_mem_free(pWdaParams->wdaMsgParam) ;
8079 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8080 vos_mem_free(pWdaParams) ;
8081 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8082 return CONVERT_WDI2VOS_STATUS(status) ;
8083}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8084/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8085 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8086 * send Exit UAPSD RSP back to PE
8087 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8088void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8089{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8090
8091 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8092 tWDA_CbContext *pWDA;
8093 tExitUapsdParams *pExitUapsdRspParams;
8094
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8096 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8097 if(NULL == pWdaParams)
8098 {
8099 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8100 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8101 VOS_ASSERT(0);
8102 return;
8103 }
8104
8105 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8106 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8107
8108 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8109 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8110
8111 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8112 vos_mem_free(pWdaParams) ;
8113
8114 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8115 return ;
8116}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8117/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8118 * FUNCTION: WDA_ExitUapsdReqCallback
8119 * Free memory and send Exit UAPSD RSP back to PE.
8120 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
8121 */
8122void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
8123{
8124 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8125 tWDA_CbContext *pWDA;
8126 tExitUapsdParams *pExitUapsdRspParams;
8127
8128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8129 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8130
8131 if(NULL == pWdaParams)
8132 {
8133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8134 "%s: pWdaParams received NULL", __func__);
8135 VOS_ASSERT(0);
8136 return;
8137 }
8138
8139 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
8140 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
8141 pExitUapsdRspParams->status = wdiStatus;
8142
8143 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8144 {
8145 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8146 vos_mem_free(pWdaParams);
8147 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
8148 }
8149
8150 return;
8151}
8152/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8153 * FUNCTION: WDA_ProcessExitUapsdReq
8154 * Request to WDI to Exit UAPSD power state.
8155 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8156VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
8157 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8158{
8159 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8160 tWDA_ReqParams *pWdaParams ;
8161 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
8162 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
8163 sizeof(WDI_ExitUapsdReqParamsType)) ;
8164
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8166 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8167
8168 if(NULL == wdiExitUapsdReqParams)
8169 {
8170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8171 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8172 VOS_ASSERT(0);
8173 return VOS_STATUS_E_NOMEM;
8174 }
8175 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8176 if(NULL == pWdaParams)
8177 {
8178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8179 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8180 VOS_ASSERT(0);
8181 vos_mem_free(wdiExitUapsdReqParams);
8182 return VOS_STATUS_E_NOMEM;
8183 }
8184
8185 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8186 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
8187 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8188
8189 /* Store param pointer as passed in by caller */
8190 /* store Params pass it to WDI */
8191 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
8192 pWdaParams->pWdaContext = pWDA;
8193 pWdaParams->wdaMsgParam = pExitUapsdParams;
8194
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8195 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8196 if(IS_WDI_STATUS_FAILURE(status))
8197 {
8198 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8199 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]8200 vos_mem_free(pWdaParams->wdaMsgParam) ;
8201 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8202 vos_mem_free(pWdaParams) ;
8203
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8204 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8205 return CONVERT_WDI2VOS_STATUS(status) ;
8206}
8207
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8208/*
8209 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
8210 *
8211 */
8212void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
8213{
8214 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8216 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8217 if(NULL == pWdaParams)
8218 {
8219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8220 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8221 VOS_ASSERT(0) ;
8222 return ;
8223 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8224 if( pWdaParams != NULL )
8225 {
8226 if( pWdaParams->wdaWdiApiMsgParam != NULL )
8227 {
8228 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8229 }
8230 if( pWdaParams->wdaMsgParam != NULL )
8231 {
8232 vos_mem_free(pWdaParams->wdaMsgParam) ;
8233 }
8234 vos_mem_free(pWdaParams) ;
8235 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8236 return ;
8237}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8238/*
8239 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
8240 * Request to WDI to set the power save params at start.
8241 */
8242VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
8243 tSirPowerSaveCfg *pPowerSaveCfg)
8244{
8245 WDI_Status status = WDI_STATUS_SUCCESS ;
8246 tHalCfg *tlvStruct = NULL ;
8247 tANI_U8 *tlvStructStart = NULL ;
8248 v_PVOID_t *configParam;
8249 tANI_U32 configParamSize;
8250 tANI_U32 *configDataValue;
8251 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
8252 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8253 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8254 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8255 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
8256 {
8257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8258 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8259 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8260 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8261 return VOS_STATUS_E_FAILURE;
8262 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8263 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
8264 if (NULL == wdiPowerSaveCfg)
8265 {
8266 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8267 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8268 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8269 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8270 return VOS_STATUS_E_NOMEM;
8271 }
8272 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8273 if(NULL == pWdaParams)
8274 {
8275 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8276 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8277 VOS_ASSERT(0);
8278 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8279 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8280 return VOS_STATUS_E_NOMEM;
8281 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8282 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
8283 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8284 if(NULL == configParam)
8285 {
8286 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8287 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8288 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8289 vos_mem_free(pWdaParams);
8290 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]8291 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8292 return VOS_STATUS_E_NOMEM;
8293 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8294 vos_mem_set(configParam, configParamSize, 0);
8295 wdiPowerSaveCfg->pConfigBuffer = configParam;
8296 tlvStruct = (tHalCfg *)configParam;
8297 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8298 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
8299 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
8300 tlvStruct->length = sizeof(tANI_U32);
8301 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8302 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8303 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8304 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8305 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
8306 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
8307 tlvStruct->length = sizeof(tANI_U32);
8308 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8309 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8310 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8311 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8312 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
8313 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
8314 tlvStruct->length = sizeof(tANI_U32);
8315 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8316 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8317 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8318 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8319 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
8320 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
8321 tlvStruct->length = sizeof(tANI_U32);
8322 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8323 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8324 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8325 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8326 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
8327 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
8328 tlvStruct->length = sizeof(tANI_U32);
8329 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8330 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8331 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8332 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8333 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
8334 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
8335 tlvStruct->length = sizeof(tANI_U32);
8336 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8337 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8338 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8339 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8340 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
8341 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
8342 tlvStruct->length = sizeof(tANI_U32);
8343 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8344 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8345 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8346 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8347 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
8348 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
8349 tlvStruct->length = sizeof(tANI_U32);
8350 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8351 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
8352 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8353 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8354 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
8355 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
8356 tlvStruct->length = sizeof(tANI_U32);
8357 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8358 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
8359 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8360 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8361 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
8362 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
8363 tlvStruct->length = sizeof(tANI_U32);
8364 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8365 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8366 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8367 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8368 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
8369 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
8370 tlvStruct->length = sizeof(tANI_U32);
8371 configDataValue = (tANI_U32 *)(tlvStruct + 1);
8372 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8373 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
8374 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8375 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8376 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8377 /* store Params pass it to WDI */
8378 pWdaParams->wdaMsgParam = configParam;
8379 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
8380 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8381 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
8382 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8383 if(IS_WDI_STATUS_FAILURE(status))
8384 {
8385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8386 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
8387 vos_mem_free(pWdaParams->wdaMsgParam);
8388 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8389 vos_mem_free(pWdaParams);
8390 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8391 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8392 return CONVERT_WDI2VOS_STATUS(status);
8393}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8394/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8395 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8396 *
8397 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8398void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8399{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8400 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8401
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8403 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8404
8405 if(NULL == pWdaParams)
8406 {
8407 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8408 "%s: pWdaParams received NULL", __func__);
8409 VOS_ASSERT(0);
8410 return ;
8411 }
8412
8413 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8414 vos_mem_free(pWdaParams);
8415
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8416 return ;
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_SetUapsdAcParamsReqCallback
8420 * Free memory.
8421 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
8422 */
8423void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8424{
8425 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8426
8427 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8428 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8429
8430 if(NULL == pWdaParams)
8431 {
8432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8433 "%s: pWdaParams received NULL", __func__);
8434 VOS_ASSERT(0);
8435 return;
8436 }
8437
8438 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8439 {
8440 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8441 vos_mem_free(pWdaParams);
8442 }
8443
8444 return;
8445}
8446/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8447 * FUNCTION: WDA_SetUapsdAcParamsReq
8448 * Request to WDI to set the UAPSD params for an ac (sta mode).
8449 */
8450VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
8451 tUapsdInfo *pUapsdInfo)
8452{
8453 WDI_Status status = WDI_STATUS_SUCCESS;
8454 tWDA_CbContext *pWDA = NULL ;
8455 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
8456 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
8457 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
8458 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8460 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8461 if(NULL == wdiUapsdParams)
8462 {
8463 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8464 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8465 VOS_ASSERT(0);
8466 return VOS_STATUS_E_NOMEM;
8467 }
8468 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8469 if(NULL == pWdaParams)
8470 {
8471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8472 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8473 VOS_ASSERT(0);
8474 vos_mem_free(wdiUapsdParams);
8475 return VOS_STATUS_E_NOMEM;
8476 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8477 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
8478 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
8479 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
8480 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
8481 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
8482 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8483 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
8484 wdiUapsdParams->pUserData = pWdaParams;
8485
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8486 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8487 pWdaParams->pWdaContext = pWDA;
8488 /* Store param pointer as passed in by caller */
8489 pWdaParams->wdaMsgParam = pUapsdInfo;
8490 /* store Params pass it to WDI */
8491 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8492 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8493 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8494 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8495 if(IS_WDI_STATUS_FAILURE(status))
8496 {
8497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8498 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
8499 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8500 vos_mem_free(pWdaParams);
8501 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8502 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
8503 return VOS_STATUS_SUCCESS;
8504 else
8505 return VOS_STATUS_E_FAILURE;
8506
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8507}
8508/*
8509 * FUNCTION: WDA_ClearUapsdAcParamsReq
8510 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
8511 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
8512 * and again enter the UPASD with the modified params. Hence the disable
8513 * function was kept empty.
8514 *
8515 */
8516VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
8517{
8518 /* do nothing */
8519 return VOS_STATUS_SUCCESS;
8520}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8521/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8522 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8523 *
8524 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8525void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8526{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8527 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8528
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8529 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8530 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8531
8532 if(NULL == pWdaParams)
8533 {
8534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8535 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8536 VOS_ASSERT(0) ;
8537 return ;
8538 }
8539
8540 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8541 vos_mem_free(pWdaParams->wdaMsgParam);
8542 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8543
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8544 //print a msg, nothing else to do
8545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8546 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8547 return ;
8548}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8549/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8550 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
8551 * Free memory.
8552 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
8553 */
8554void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
8555{
8556 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8557
8558 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8559 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8560
8561 if(NULL == pWdaParams)
8562 {
8563 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8564 "%s: pWdaParams received NULL", __func__);
8565 VOS_ASSERT(0);
8566 return;
8567 }
8568
8569 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8570 {
8571 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8572 vos_mem_free(pWdaParams->wdaMsgParam);
8573 vos_mem_free(pWdaParams);
8574 }
8575
8576 return;
8577}
8578/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8579 * FUNCTION: WDA_UpdateUapsdParamsReq
8580 * Request to WDI to update UAPSD params (in softAP mode) for a station.
8581 */
8582VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
8583 tUpdateUapsdParams* pUpdateUapsdInfo)
8584{
8585 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8586 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8587 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
8588 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
8589 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8590 tWDA_ReqParams *pWdaParams = NULL;
8591
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8593 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8594 if(NULL == wdiUpdateUapsdParams)
8595 {
8596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8597 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8598 VOS_ASSERT(0);
8599 return VOS_STATUS_E_NOMEM;
8600 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8601 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
8602 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
8603 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8604 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
8605 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8606
8607 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8608 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8609 {
8610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8611 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8612 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8613 vos_mem_free(pUpdateUapsdInfo);
8614 vos_mem_free(wdiUpdateUapsdParams);
8615 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8616 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8617 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8618 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8619 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8620 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
8621 pWdaParams->pWdaContext = pWDA;
8622
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8623 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8624 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8625 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8626
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8627 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8628 {
8629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8630 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8631 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
8632 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8633 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8634 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8635 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8636 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8637}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8638/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8639 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8640 *
8641 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8642void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8643{
8644 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8645 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8646 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8647 if(WDI_STATUS_SUCCESS != wdiStatus)
8648 {
8649 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8650 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8651 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8652 if(NULL == pWdaParams)
8653 {
8654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8655 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8656 VOS_ASSERT(0) ;
8657 return ;
8658 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8659 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8660 vos_mem_free(pWdaParams->wdaMsgParam);
8661 vos_mem_free(pWdaParams);
8662 return ;
8663}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8664/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8665 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
8666 * Free memory.
8667 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
8668 */
8669void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8670{
8671 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8672
8673 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8674 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8675
8676 if(NULL == pWdaParams)
8677 {
8678 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8679 "%s: pWdaParams received NULL", __func__);
8680 VOS_ASSERT(0);
8681 return;
8682 }
8683
8684 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8685 {
8686 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8687 vos_mem_free(pWdaParams->wdaMsgParam);
8688 vos_mem_free(pWdaParams);
8689 }
8690
8691 return;
8692}
8693/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8694 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
8695 *
8696 */
8697VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
8698 tSirWlanSetRxpFilters *pWlanSuspendParam)
8699{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8700 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8701 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8702 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8703 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]8704 /* Sanity Check
8705 * This is very unlikely and add assert to collect more info next time */
8706 if(NULL == pWlanSuspendParam)
8707 {
8708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8709 "%s: pWlanSuspendParam received NULL", __func__);
8710 VOS_ASSERT(0) ;
8711 return VOS_STATUS_E_FAULT;
8712 }
8713 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
8714 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8715 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8716 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8717 if(NULL == wdiRxpFilterParams)
8718 {
8719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8720 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8721 VOS_ASSERT(0);
8722 vos_mem_free(pWlanSuspendParam);
8723 return VOS_STATUS_E_NOMEM;
8724 }
8725 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8726 if(NULL == pWdaParams)
8727 {
8728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8729 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8730 VOS_ASSERT(0);
8731 vos_mem_free(wdiRxpFilterParams);
8732 vos_mem_free(pWlanSuspendParam);
8733 return VOS_STATUS_E_NOMEM;
8734 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8735 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
8736 pWlanSuspendParam->setMcstBcstFilter;
8737 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
8738 pWlanSuspendParam->configuredMcstBcstFilterSetting;
8739
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8740 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
8741 wdiRxpFilterParams->pUserData = pWdaParams;
8742
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8743 pWdaParams->pWdaContext = pWDA;
8744 pWdaParams->wdaMsgParam = pWlanSuspendParam;
8745 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8746 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8747 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8748 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8749 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8750 {
8751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8752 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8753 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8754 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8755 vos_mem_free(pWdaParams->wdaMsgParam);
8756 vos_mem_free(pWdaParams);
8757 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]8758 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8759}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8760/*
8761 * FUNCTION: WDA_WdiIndicationCallback
8762 *
8763 */
8764void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
8765 void* pUserData)
8766{
8767 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8768 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8769}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8770/*
8771 * FUNCTION: WDA_ProcessWlanSuspendInd
8772 *
8773 */
8774VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
8775 tSirWlanSuspendParam *pWlanSuspendParam)
8776{
8777 WDI_Status wdiStatus;
8778 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8780 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8781 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
8782 pWlanSuspendParam->configuredMcstBcstFilterSetting;
8783 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
8784 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8785 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]8786 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
8787 if(WDI_STATUS_PENDING == wdiStatus)
8788 {
8789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8790 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8791 }
8792 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
8793 {
8794 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8795 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8796 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8797 vos_mem_free(pWlanSuspendParam);
8798 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8799}
8800
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]8801#ifdef WLAN_FEATURE_11W
8802/*
8803 * FUNCTION: WDA_ProcessExcludeUnecryptInd
8804 *
8805 */
8806VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
8807 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
8808{
8809 WDI_Status wdiStatus;
8810 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
8811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8812 "------> %s ", __func__);
8813
8814 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
8815 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
8816 sizeof(tSirMacAddr));
8817
8818 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
8819 wdiExclUnencryptParams.pUserData = pWDA;
8820
8821 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
8822 if(WDI_STATUS_PENDING == wdiStatus)
8823 {
8824 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8825 "Pending received for %s:%d ", __func__, __LINE__ );
8826 }
8827 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
8828 {
8829 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8830 "Failure in %s:%d ", __func__, __LINE__ );
8831 }
8832 vos_mem_free(pExclUnencryptParam);
8833 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8834}
8835#endif
8836
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8837/*
8838 * FUNCTION: WDA_ProcessWlanResumeCallback
8839 *
8840 */
8841void WDA_ProcessWlanResumeCallback(
8842 WDI_SuspendResumeRspParamsType *resumeRspParams,
8843 void* pUserData)
8844{
8845 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8846 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8847 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8848 if(NULL == pWdaParams)
8849 {
8850 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8851 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8852 VOS_ASSERT(0) ;
8853 return ;
8854 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8855 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
8856 {
8857 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]8858 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8859 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8860 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8861 vos_mem_free(pWdaParams->wdaMsgParam);
8862 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8863 return ;
8864}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8865/*
8866 * FUNCTION: WDA_ProcessWlanResumeReq
8867 *
8868 */
8869VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
8870 tSirWlanResumeParam *pWlanResumeParam)
8871{
8872 WDI_Status wdiStatus;
8873 WDI_ResumeParamsType *wdiResumeParams =
8874 (WDI_ResumeParamsType *)vos_mem_malloc(
8875 sizeof(WDI_ResumeParamsType) ) ;
8876 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8878 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8879 if(NULL == wdiResumeParams)
8880 {
8881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8882 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8883 VOS_ASSERT(0);
8884 return VOS_STATUS_E_NOMEM;
8885 }
8886 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8887 if(NULL == pWdaParams)
8888 {
8889 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8890 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8891 VOS_ASSERT(0);
8892 vos_mem_free(wdiResumeParams);
8893 return VOS_STATUS_E_NOMEM;
8894 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8895 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
8896 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8897 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]8898 wdiResumeParams->wdiReqStatusCB = NULL;
8899 pWdaParams->wdaMsgParam = pWlanResumeParam;
8900 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
8901 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8902 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
8903 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
8904 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8905 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8906 {
8907 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8908 "Failure in Host Resume REQ WDI API, free all the memory " );
8909 VOS_ASSERT(0);
8910 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8911 vos_mem_free(pWdaParams->wdaMsgParam);
8912 vos_mem_free(pWdaParams);
8913 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8914 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
8915}
8916
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8917/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8918 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8919 *
8920 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8921void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8922{
8923 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8924 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8925 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8926 if(NULL == pWdaParams)
8927 {
8928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8929 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8930 VOS_ASSERT(0) ;
8931 return ;
8932 }
8933
8934 vos_mem_free(pWdaParams->wdaMsgParam) ;
8935 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8936 vos_mem_free(pWdaParams) ;
8937 /*
8938 * No respone required for SetBeaconFilter req so just free the request
8939 * param here
8940 */
8941
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8942 return ;
8943}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8944/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]8945 * FUNCTION: WDA_SetBeaconFilterReqCallback
8946 * Free memory.
8947 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
8948 */
8949void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
8950{
8951 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8952
8953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8954 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8955
8956 if(NULL == pWdaParams)
8957 {
8958 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8959 "%s: pWdaParams received NULL", __func__);
8960 VOS_ASSERT(0);
8961 return;
8962 }
8963
8964 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8965 {
8966 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8967 vos_mem_free(pWdaParams->wdaMsgParam);
8968 vos_mem_free(pWdaParams);
8969 }
8970
8971 return;
8972}
8973/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8974 * FUNCTION: WDA_SetBeaconFilterReq
8975 * Request to WDI to send the beacon filtering related information.
8976 */
8977VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
8978 tBeaconFilterMsg* pBeaconFilterInfo)
8979{
8980 WDI_Status status = WDI_STATUS_SUCCESS;
8981 tANI_U8 *dstPtr, *srcPtr;
8982 tANI_U8 filterLength;
8983 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
8984 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
8985 sizeof(WDI_BeaconFilterReqParamsType) ) ;
8986 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8988 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8989 if(NULL == wdiBeaconFilterInfo)
8990 {
8991 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8992 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8993 VOS_ASSERT(0);
8994 return VOS_STATUS_E_NOMEM;
8995 }
8996 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8997 if(NULL == pWdaParams)
8998 {
8999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9000 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9001 VOS_ASSERT(0);
9002 vos_mem_free(wdiBeaconFilterInfo);
9003 return VOS_STATUS_E_NOMEM;
9004 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9005 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
9006 pBeaconFilterInfo->beaconInterval;
9007 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
9008 pBeaconFilterInfo->capabilityInfo;
9009 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
9010 pBeaconFilterInfo->capabilityMask;
9011 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]9012
9013 //Fill the BssIdx
9014 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
9015
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9016 //Fill structure with info contained in the beaconFilterTable
9017 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
9018 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
9019 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
9020 if(WDI_BEACON_FILTER_LEN < filterLength)
9021 {
9022 filterLength = WDI_BEACON_FILTER_LEN;
9023 }
9024 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9025 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
9026 wdiBeaconFilterInfo->pUserData = pWdaParams;
9027
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9028 /* Store param pointer as passed in by caller */
9029 /* store Params pass it to WDI */
9030 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
9031 pWdaParams->pWdaContext = pWDA;
9032 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
9033
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9034 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9035 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9036 if(IS_WDI_STATUS_FAILURE(status))
9037 {
9038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9039 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
9040 vos_mem_free(pWdaParams->wdaMsgParam) ;
9041 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9042 vos_mem_free(pWdaParams) ;
9043 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9044 return CONVERT_WDI2VOS_STATUS(status) ;
9045}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9046/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9047 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9048 *
9049 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9050void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9051{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9052 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9053
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9055 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9056
9057 if(NULL == pWdaParams)
9058 {
9059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9060 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9061 VOS_ASSERT(0) ;
9062 return ;
9063 }
9064
9065 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9066 vos_mem_free(pWdaParams->wdaMsgParam);
9067 vos_mem_free(pWdaParams);
9068
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9069 //print a msg, nothing else to do
9070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9071 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9072 return ;
9073}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9074/*
9075 * FUNCTION: WDA_RemBeaconFilterReqCallback
9076 * Free memory.
9077 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
9078 */
9079void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
9080{
9081 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9082
9083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9084 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9085
9086 if(NULL == pWdaParams)
9087 {
9088 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9089 "%s: pWdaParams received NULL", __func__);
9090 VOS_ASSERT(0);
9091 return;
9092 }
9093
9094 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9095 {
9096 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9097 vos_mem_free(pWdaParams->wdaMsgParam);
9098 vos_mem_free(pWdaParams);
9099 }
9100
9101 return;
9102}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9103 // TODO: PE does not have this feature for now implemented,
9104 // but the support for removing beacon filter exists between
9105 // HAL and FW. This function can be called whenever PE defines
9106 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9107/*
9108 * FUNCTION: WDA_RemBeaconFilterReq
9109 * Request to WDI to send the removal of beacon filtering related information.
9110 */
9111VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
9112 tRemBeaconFilterMsg* pBeaconFilterInfo)
9113{
9114 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9115 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9116 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
9117 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
9118 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9119 tWDA_ReqParams *pWdaParams ;
9120
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9122 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9123 if(NULL == wdiBeaconFilterInfo)
9124 {
9125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9126 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9127 VOS_ASSERT(0);
9128 return VOS_STATUS_E_NOMEM;
9129 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9130 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9131 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9132 {
9133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9134 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9135 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9136 vos_mem_free(wdiBeaconFilterInfo);
9137 vos_mem_free(pBeaconFilterInfo);
9138 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9139 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9140
9141 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
9142 pBeaconFilterInfo->ucIeCount;
9143 //Fill structure with info contained in the ucRemIeId
9144 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
9145 pBeaconFilterInfo->ucRemIeId,
9146 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
9147 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
9148 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9149
9150 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9151 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9152 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9153 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
9154
9155 pWdaParams->pWdaContext = pWDA;
9156
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9157 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9158 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9159 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9160 {
9161 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9162 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9163 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9164 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9165 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9166 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9167 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9168 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9169}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9170/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9171 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9172 *
9173 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9174void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9175{
9176 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9178 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9179 if(NULL == pWdaParams)
9180 {
9181 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9182 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9183 VOS_ASSERT(0) ;
9184 return ;
9185 }
9186
9187 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9188 vos_mem_free(pWdaParams) ;
9189
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9190 return ;
9191}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9192/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9193 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
9194 * Free memory.
9195 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
9196 */
9197void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
9198{
9199 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9200
9201 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9202 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9203
9204 if(NULL == pWdaParams)
9205 {
9206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9207 "%s: pWdaParams received NULL", __func__);
9208 VOS_ASSERT(0);
9209 return;
9210 }
9211
9212 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9213 {
9214 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9215 vos_mem_free(pWdaParams);
9216 }
9217
9218 return;
9219}
9220/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9221 * FUNCTION: WDA_SetRSSIThresholdsReq
9222 * Request to WDI to set the RSSI thresholds (sta mode).
9223 */
9224VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
9225{
9226 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9227 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9228 tWDA_CbContext *pWDA = NULL ;
9229 v_PVOID_t pVosContext = NULL;
9230 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
9231 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
9232 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
9233 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9234 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9235 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9236 if(NULL == wdiRSSIThresholdsInfo)
9237 {
9238 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9239 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9240 VOS_ASSERT(0);
9241 return VOS_STATUS_E_NOMEM;
9242 }
9243 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9244 if(NULL == pWdaParams)
9245 {
9246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9247 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9248 VOS_ASSERT(0);
9249 vos_mem_free(wdiRSSIThresholdsInfo);
9250 return VOS_STATUS_E_NOMEM;
9251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9252 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9253 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
9254 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
9255 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9256 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
9257 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
9258 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9259 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
9260 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
9261 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9262 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
9263 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9264 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
9265 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
9266
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9267 /* Store param pointer as passed in by caller */
9268 /* store Params pass it to WDI */
9269 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
9270 pWdaParams->pWdaContext = pWDA;
9271 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9272 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9273 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9274 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9275 {
9276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9277 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9278 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9279 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9280 vos_mem_free(pWdaParams) ;
9281 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9282 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9283
9284}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9285/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9286 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9287 *
9288 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9289void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9290{
9291 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9292
9293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9294 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9295 if(NULL == pWdaParams)
9296 {
9297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9298 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9299 VOS_ASSERT(0) ;
9300 return ;
9301 }
9302
9303 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9304 vos_mem_free(pWdaParams->wdaMsgParam);
9305 vos_mem_free(pWdaParams) ;
9306
9307 //print a msg, nothing else to do
9308 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9309 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9310 return ;
9311}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9312/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9313 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9314 * Free memory.
9315 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9316 */
9317void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
9318{
9319 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9320
9321 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9322 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9323
9324 if(NULL == pWdaParams)
9325 {
9326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9327 "%s: Invalid pWdaParams pointer", __func__);
9328 VOS_ASSERT(0);
9329 return;
9330 }
9331
9332 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9333 {
9334 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9335 vos_mem_free(pWdaParams->wdaMsgParam);
9336 vos_mem_free(pWdaParams);
9337 }
9338
9339 return;
9340}
9341/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9342 * FUNCTION: WDA_ProcessHostOffloadReq
9343 * Request to WDI to set the filter to minimize unnecessary host wakeup due
9344 * to broadcast traffic (sta mode).
9345 */
9346VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
9347 tSirHostOffloadReq *pHostOffloadParams)
9348{
9349 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9350 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9351 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
9352 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
9353 sizeof(WDI_HostOffloadReqParamsType)) ;
9354 tWDA_ReqParams *pWdaParams ;
9355
9356 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9357 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9358
9359 if(NULL == wdiHostOffloadInfo)
9360 {
9361 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9362 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9363 VOS_ASSERT(0);
9364 return VOS_STATUS_E_NOMEM;
9365 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9366 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9367 if(NULL == pWdaParams)
9368 {
9369 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9370 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9371 VOS_ASSERT(0);
9372 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9373 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9374 return VOS_STATUS_E_NOMEM;
9375 }
9376
9377 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
9378 pHostOffloadParams->offloadType;
9379 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
9380 pHostOffloadParams->enableOrDisable;
9381
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9382 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
9383 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
9384
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9385 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
9386 {
9387 case SIR_IPV4_ARP_REPLY_OFFLOAD:
9388 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
9389 pHostOffloadParams->params.hostIpv4Addr,
9390 4);
9391 break;
9392 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
9393 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9394 pHostOffloadParams->params.hostIpv6Addr,
9395 16);
9396 break;
9397 case SIR_IPV6_NS_OFFLOAD:
9398 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
9399 pHostOffloadParams->params.hostIpv6Addr,
9400 16);
9401
9402#ifdef WLAN_NS_OFFLOAD
9403 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
9404 {
9405 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
9406 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
9407 16);
9408 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
9409 }
9410 else
9411 {
9412 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
9413 }
9414
9415 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
9416 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
9417 16);
9418 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
9419 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
9420 6);
9421
9422 //Only two are supported so let's go through them without a loop
9423 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
9424 {
9425 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
9426 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
9427 16);
9428 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
9429 }
9430 else
9431 {
9432 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
9433 }
9434
9435 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
9436 {
9437 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
9438 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
9439 16);
9440 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
9441 }
9442 else
9443 {
9444 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
9445 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]9446 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
9447 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9448 break;
9449#endif //WLAN_NS_OFFLOAD
9450 default:
9451 {
9452 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9453 "No Handling for Offload Type %x in WDA "
9454 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
9455 //WDA_VOS_ASSERT(0) ;
9456 }
9457 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9458 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
9459 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9460
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9461 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9462 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9463 /* store Params pass it to WDI */
9464 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
9465 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9466
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9467
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9468 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]9469 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9470
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9471 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9472 {
9473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9474 "Failure in host offload REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9475 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9476 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9477 vos_mem_free(pWdaParams->wdaMsgParam);
9478 vos_mem_free(pWdaParams) ;
9479 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9480 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9481
9482}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9483/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9484 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9485 *
9486 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9487void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9488{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9489 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
9490
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9491 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9492 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9493
9494 if(NULL == pWdaParams)
9495 {
9496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9497 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9498 VOS_ASSERT(0) ;
9499 return ;
9500 }
9501
9502 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9503 vos_mem_free(pWdaParams->wdaMsgParam);
9504 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9505
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9506 //print a msg, nothing else to do
9507 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9508 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9509 return ;
9510}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9511/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9512 * FUNCTION: WDA_KeepAliveReqCallback
9513 * Free memory.
9514 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
9515 */
9516void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
9517{
9518 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9519
9520 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9521 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9522
9523 if(NULL == pWdaParams)
9524 {
9525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9526 "%s: pWdaParams received NULL", __func__);
9527 VOS_ASSERT(0);
9528 return;
9529 }
9530
9531 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9532 {
9533 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9534 vos_mem_free(pWdaParams->wdaMsgParam);
9535 vos_mem_free(pWdaParams);
9536 }
9537
9538 return;
9539}
9540/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9541 * FUNCTION: WDA_ProcessKeepAliveReq
9542 * Request to WDI to send Keep Alive packets to minimize unnecessary host
9543 * wakeup due to broadcast traffic (sta mode).
9544 */
9545VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
9546 tSirKeepAliveReq *pKeepAliveParams)
9547{
9548 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9549 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9550 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
9551 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
9552 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9553 tWDA_ReqParams *pWdaParams;
9554
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9556 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9557 if(NULL == wdiKeepAliveInfo)
9558 {
9559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9560 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9561 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9562 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9563 return VOS_STATUS_E_NOMEM;
9564 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9565
9566 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9567 if(NULL == pWdaParams)
9568 {
9569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9570 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9571 VOS_ASSERT(0);
9572 vos_mem_free(wdiKeepAliveInfo);
9573 vos_mem_free(pKeepAliveParams);
9574 return VOS_STATUS_E_NOMEM;
9575 }
9576
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9577 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
9578 pKeepAliveParams->packetType;
9579 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
9580 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9581
9582 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
9583 pKeepAliveParams->bssId,
9584 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9585
9586 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
9587 {
9588 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9589 pKeepAliveParams->hostIpv4Addr,
9590 SIR_IPV4_ADDR_LEN);
9591 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9592 pKeepAliveParams->destIpv4Addr,
9593 SIR_IPV4_ADDR_LEN);
9594 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9595 pKeepAliveParams->destMacAddr,
9596 SIR_MAC_ADDR_LEN);
9597 }
9598 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
9599 {
9600 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
9601 SIR_IPV4_ADDR_LEN,
9602 0);
9603 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
9604 SIR_IPV4_ADDR_LEN,
9605 0);
9606 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
9607 SIR_MAC_ADDR_LEN,
9608 0);
9609 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9610 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
9611 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9612
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9613 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9614 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9615 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9616 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
9617 pWdaParams->pWdaContext = pWDA;
9618
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9619 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
9620 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
9621 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
9622 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
9623 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
9624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
9625 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
9626 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
9627 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
9628 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
9629 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9630 "WDA DMAC : %d:%d:%d:%d:%d:%d",
9631 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
9632 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
9633 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
9634 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
9635 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
9636 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
9637 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9638 "TimePeriod %d PacketType %d",
9639 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
9640 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9641 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9642 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9643
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9644 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9645 {
9646 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9647 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9648 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9649 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
9650 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]9651 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9652 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9653 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9654
9655}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9656/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9657 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9658 *
9659 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9660void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9661 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
9662 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9663{
9664 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9666 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9667 if(NULL == pWdaParams)
9668 {
9669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9670 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9671 VOS_ASSERT(0) ;
9672 return ;
9673 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9674 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9675 vos_mem_free(pWdaParams->wdaMsgParam);
9676 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9677 return ;
9678}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9679/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9680 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
9681 * Free memory.
9682 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
9683 */
9684void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
9685{
9686 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9687
9688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9689 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9690
9691 if(NULL == pWdaParams)
9692 {
9693 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9694 "%s: pWdaParams received NULL", __func__);
9695 VOS_ASSERT(0);
9696 return;
9697 }
9698
9699 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9700 {
9701 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9702 vos_mem_free(pWdaParams->wdaMsgParam);
9703 vos_mem_free(pWdaParams);
9704 }
9705
9706 return;
9707}
9708
9709/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9710 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
9711 * Request to WDI to add WOWL Bcast pattern
9712 */
9713VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
9714 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
9715{
9716 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9717 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9718 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
9719 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
9720 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
9721 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9723 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9724 if(NULL == wdiWowlAddBcPtrnInfo)
9725 {
9726 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9727 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9728 VOS_ASSERT(0);
9729 return VOS_STATUS_E_NOMEM;
9730 }
9731 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9732 if(NULL == pWdaParams)
9733 {
9734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9735 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9736 VOS_ASSERT(0);
9737 vos_mem_free(wdiWowlAddBcPtrnInfo);
9738 return VOS_STATUS_E_NOMEM;
9739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9740 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
9741 pWowlAddBcPtrnParams->ucPatternId;
9742 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
9743 pWowlAddBcPtrnParams->ucPatternByteOffset;
9744 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
9745 pWowlAddBcPtrnParams->ucPatternMaskSize;
9746 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
9747 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9748 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
9749 {
9750 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
9751 pWowlAddBcPtrnParams->ucPattern,
9752 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
9753 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
9754 pWowlAddBcPtrnParams->ucPatternMask,
9755 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
9756 }
9757 else
9758 {
9759 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
9760 pWowlAddBcPtrnParams->ucPattern,
9761 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9762 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
9763 pWowlAddBcPtrnParams->ucPatternMask,
9764 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9765
9766 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
9767 pWowlAddBcPtrnParams->ucPatternExt,
9768 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9769 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
9770 pWowlAddBcPtrnParams->ucPatternMaskExt,
9771 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
9772 }
9773
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9774 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
9775 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
9776
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9777 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
9778 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9779 /* Store param pointer as passed in by caller */
9780 /* store Params pass it to WDI */
9781 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
9782 pWdaParams->pWdaContext = pWDA;
9783 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9784 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9785 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9786 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9787 {
9788 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9789 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9790 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9791 vos_mem_free(pWdaParams->wdaMsgParam) ;
9792 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9793 vos_mem_free(pWdaParams) ;
9794 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9795 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9796
9797}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9798/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9799 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9800 *
9801 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9802void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9803 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
9804 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9805{
9806 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9808 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9809 if(NULL == pWdaParams)
9810 {
9811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9812 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9813 VOS_ASSERT(0) ;
9814 return ;
9815 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9816 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9817 vos_mem_free(pWdaParams->wdaMsgParam);
9818 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9819 return ;
9820}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9821/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9822 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
9823 * Free memory.
9824 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
9825 */
9826void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
9827{
9828 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9829
9830 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9831 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9832
9833 if(NULL == pWdaParams)
9834 {
9835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9836 "%s: pWdaParams received NULL", __func__);
9837 VOS_ASSERT(0);
9838 return;
9839 }
9840
9841 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9842 {
9843 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9844 vos_mem_free(pWdaParams->wdaMsgParam);
9845 vos_mem_free(pWdaParams);
9846 }
9847
9848 return;
9849}
9850/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9851 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
9852 * Request to WDI to delete WOWL Bcast pattern
9853 */
9854VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
9855 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
9856{
9857 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9858 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9859 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
9860 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
9861 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
9862 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9864 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9865 if(NULL == wdiWowlDelBcPtrnInfo)
9866 {
9867 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9868 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9869 VOS_ASSERT(0);
9870 return VOS_STATUS_E_NOMEM;
9871 }
9872 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9873 if(NULL == pWdaParams)
9874 {
9875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9876 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9877 VOS_ASSERT(0);
9878 vos_mem_free(wdiWowlDelBcPtrnInfo);
9879 return VOS_STATUS_E_NOMEM;
9880 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9881 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
9882 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9883
9884 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
9885 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
9886
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9887 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
9888 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9889 /* Store param pointer as passed in by caller */
9890 /* store Params pass it to WDI */
9891 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
9892 pWdaParams->pWdaContext = pWDA;
9893 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9894 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9895 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9896 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9897 {
9898 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9899 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9900 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9901 vos_mem_free(pWdaParams->wdaMsgParam) ;
9902 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9903 vos_mem_free(pWdaParams) ;
9904 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9905 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9906
9907}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9908/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9909 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9910 *
9911 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9912void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9913{
9914 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9915 tWDA_CbContext *pWDA;
9916 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9917 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9918 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9919 if(NULL == pWdaParams)
9920 {
9921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9922 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9923 VOS_ASSERT(0) ;
9924 return ;
9925 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9926 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
9927 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
9928
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9929 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
9930
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9931 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9932 vos_mem_free(pWdaParams) ;
9933
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9934 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9935 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9936 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9937 return ;
9938}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9939/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9940 * FUNCTION: WDA_WowlEnterReqCallback
9941 * Free memory and send WOWL Enter RSP back to PE.
9942 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
9943 */
9944void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
9945{
9946 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9947 tWDA_CbContext *pWDA;
9948 tSirHalWowlEnterParams *pWowlEnterParams;
9949
9950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9951 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9952
9953 if(NULL == pWdaParams)
9954 {
9955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9956 "%s: pWdaParams received NULL", __func__);
9957 VOS_ASSERT(0);
9958 return;
9959 }
9960
9961 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
9962 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
9963 pWowlEnterParams->status = wdiStatus;
9964
9965 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9966 {
9967 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9968 vos_mem_free(pWdaParams);
9969 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
9970 }
9971
9972 return;
9973}
9974/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9975 * FUNCTION: WDA_ProcessWowlEnterReq
9976 * Request to WDI to enter WOWL
9977 */
9978VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
9979 tSirHalWowlEnterParams *pWowlEnterParams)
9980{
9981 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]9982 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9983 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
9984 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
9985 sizeof(WDI_WowlEnterReqParamsType)) ;
9986 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9987 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9988 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9989 if(NULL == wdiWowlEnterInfo)
9990 {
9991 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9992 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9993 VOS_ASSERT(0);
9994 return VOS_STATUS_E_NOMEM;
9995 }
9996 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9997 if(NULL == pWdaParams)
9998 {
9999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10000 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10001 VOS_ASSERT(0);
10002 vos_mem_free(wdiWowlEnterInfo);
10003 return VOS_STATUS_E_NOMEM;
10004 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]10005
10006 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
10007
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10008 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
10009 pWowlEnterParams->magicPtrn,
10010 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10011 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
10012 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10013 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
10014 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10015 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
10016 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10017 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
10018 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10019 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
10020 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10021 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
10022 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10023 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
10024 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10025 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
10026 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10027#ifdef WLAN_WAKEUP_EVENTS
10028 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
10029 pWowlEnterParams->ucWoWEAPIDRequestEnable;
10030
10031 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
10032 pWowlEnterParams->ucWoWEAPOL4WayEnable;
10033
10034 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
10035 pWowlEnterParams->ucWowNetScanOffloadMatch;
10036
10037 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
10038 pWowlEnterParams->ucWowGTKRekeyError;
10039
10040 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
10041 pWowlEnterParams->ucWoWBSSConnLoss;
10042#endif // WLAN_WAKEUP_EVENTS
10043
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10044 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
10045 pWowlEnterParams->bssIdx;
10046
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10047 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
10048 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10049 /* Store param pointer as passed in by caller */
10050 /* store Params pass it to WDI */
10051 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
10052 pWdaParams->pWdaContext = pWDA;
10053 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10054 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10055 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10056 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10057 {
10058 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10059 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10060 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10061 vos_mem_free(pWdaParams->wdaMsgParam) ;
10062 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10063 vos_mem_free(pWdaParams) ;
10064 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10065 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10066
10067}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10068/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10069 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10070 *
10071 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10072void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10073{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10074 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10075 tWDA_CbContext *pWDA;
10076 tSirHalWowlExitParams *pWowlExitParams;
10077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10078 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10079 if(NULL == pWdaParams)
10080 {
10081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10082 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10083 VOS_ASSERT(0) ;
10084 return ;
10085 }
10086 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10087 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
10088
10089 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10090 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10091
10092 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10093 vos_mem_free(pWdaParams) ;
10094
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10095 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10096 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10097 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10098 return ;
10099}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10100/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10101 * FUNCTION: WDA_WowlExitReqCallback
10102 * Free memory and send WOWL Exit RSP back to PE.
10103 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
10104 */
10105void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
10106{
10107 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10108 tWDA_CbContext *pWDA;
10109 tSirHalWowlExitParams *pWowlExitParams;
10110
10111 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10112 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10113
10114 if(NULL == pWdaParams)
10115 {
10116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10117 "%s: pWdaParams received NULL", __func__);
10118 VOS_ASSERT(0);
10119 return;
10120 }
10121
10122 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10123 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
10124 pWowlExitParams->status = wdiStatus;
10125
10126 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10127 {
10128 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10129 vos_mem_free(pWdaParams);
10130 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
10131 }
10132
10133 return;
10134}
10135/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10136 * FUNCTION: WDA_ProcessWowlExitReq
10137 * Request to WDI to add WOWL Bcast pattern
10138 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10139VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
10140 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10141{
10142 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10143 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10144 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
10145 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
10146 sizeof(WDI_WowlExitReqParamsType)) ;
10147 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10149 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10150 if(NULL == wdiWowlExitInfo)
10151 {
10152 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10153 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10154 VOS_ASSERT(0);
10155 return VOS_STATUS_E_NOMEM;
10156 }
10157 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10158 if(NULL == pWdaParams)
10159 {
10160 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10161 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10162 VOS_ASSERT(0);
10163 vos_mem_free(wdiWowlExitInfo);
10164 return VOS_STATUS_E_NOMEM;
10165 }
10166
10167 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
10168 pWowlExitParams->bssIdx;
10169
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10170 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
10171 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10172
10173 /* Store param pointer as passed in by caller */
10174 /* store Params pass it to WDI */
10175 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
10176 pWdaParams->pWdaContext = pWDA;
10177 pWdaParams->wdaMsgParam = pWowlExitParams;
10178
10179 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10180 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10181
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10182 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10183 {
10184 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10185 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10186 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10187 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10188 vos_mem_free(pWdaParams->wdaMsgParam);
10189 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10190 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10191 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10192}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10193/*
10194 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
10195 * Request to WDI to determine whether a given station is capable of
10196 * using HW-based frame translation
10197 */
10198v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
10199 tANI_U8 staIdx)
10200{
10201 return WDI_IsHwFrameTxTranslationCapable(staIdx);
10202}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10203
10204/*
10205 * FUNCTION: WDA_IsSelfSTA
10206 * Request to WDI to determine whether a given STAID is self station
10207 * index.
10208 */
10209v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
10210{
10211
10212 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10213
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]10214 if (NULL != pWDA)
10215 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
10216 else
10217 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]10218}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10219/*
10220 * FUNCTION: WDA_NvDownloadReqCallback
10221 * send NV Download RSP back to PE
10222 */
10223void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
10224 void* pUserData)
10225{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10226
10227 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
10228 tWDA_CbContext *pWDA;
10229
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10231 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10232
10233 if(NULL == pWdaParams)
10234 {
10235 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10236 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10237 VOS_ASSERT(0) ;
10238 return ;
10239 }
10240
10241 pWDA = pWdaParams->pWdaContext;
10242
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10243 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10244 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10245 vos_mem_free(pWdaParams);
10246
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10247 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10248 return ;
10249}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10250/*
10251 * FUNCTION: WDA_ProcessNvDownloadReq
10252 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
10253 */
10254VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
10255{
10256 /* Initialize the local Variables*/
10257 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
10258 v_VOID_t *pNvBuffer=NULL;
10259 v_SIZE_t bufferSize = 0;
10260 WDI_Status status = WDI_STATUS_E_FAILURE;
10261 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10262 tWDA_ReqParams *pWdaParams ;
10263
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10264 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10265 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10266 if(NULL == pWDA)
10267 {
10268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10269 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10270 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10271 return VOS_STATUS_E_FAILURE;
10272 }
10273
10274 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]10275 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
10276
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10277 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
10278 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10279 if(NULL == wdiNvDownloadReqParam)
10280 {
10281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10282 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10283 VOS_ASSERT(0);
10284 return VOS_STATUS_E_NOMEM;
10285 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10286 /* Copy Params to wdiNvDownloadReqParam*/
10287 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
10288 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10289
10290 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10291 if(NULL == pWdaParams)
10292 {
10293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10294 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10295 VOS_ASSERT(0);
10296 vos_mem_free(wdiNvDownloadReqParam);
10297 return VOS_STATUS_E_NOMEM;
10298 }
10299
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10300 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10301 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
10302 pWdaParams->wdaMsgParam = NULL;
10303 pWdaParams->pWdaContext = pWDA;
10304
10305
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10306 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10307
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10308 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10309 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
10310
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10311 if(IS_WDI_STATUS_FAILURE(status))
10312 {
10313 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10314 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10315 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10316 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10317 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10318 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10319}
10320/*
10321 * FUNCTION: WDA_FlushAcReqCallback
10322 * send Flush AC RSP back to TL
10323 */
10324void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
10325{
10326 vos_msg_t wdaMsg = {0} ;
10327 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10328 tFlushACReq *pFlushACReqParams;
10329 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10330 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10331 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10332 if(NULL == pWdaParams)
10333 {
10334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10335 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10336 VOS_ASSERT(0) ;
10337 return ;
10338 }
10339
10340 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
10341 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
10342 if(NULL == pFlushACRspParams)
10343 {
10344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10345 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10346 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]10347 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10348 return ;
10349 }
10350 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
10351 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
10352 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
10353 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
10354 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]10355 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10356 vos_mem_free(pWdaParams->wdaMsgParam) ;
10357 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10358 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10359 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
10360 wdaMsg.bodyptr = (void *)pFlushACRspParams;
10361 // POST message to TL
10362 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
10363
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10364 return ;
10365}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10366/*
10367 * FUNCTION: WDA_ProcessFlushAcReq
10368 * Request to WDI to Update the DELBA REQ params.
10369 */
10370VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
10371 tFlushACReq *pFlushAcReqParams)
10372{
10373 WDI_Status status = WDI_STATUS_SUCCESS ;
10374 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
10375 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
10376 sizeof(WDI_FlushAcReqParamsType)) ;
10377 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10378 if(NULL == wdiFlushAcReqParam)
10379 {
10380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10381 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10382 VOS_ASSERT(0);
10383 return VOS_STATUS_E_NOMEM;
10384 }
10385 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10386 if(NULL == pWdaParams)
10387 {
10388 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10389 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10390 VOS_ASSERT(0);
10391 vos_mem_free(wdiFlushAcReqParam);
10392 return VOS_STATUS_E_NOMEM;
10393 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10394 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10395 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10396 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
10397 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
10398 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
10399 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10400 /* Store Flush AC pointer, as this will be used for response */
10401 /* store Params pass it to WDI */
10402 pWdaParams->pWdaContext = pWDA;
10403 pWdaParams->wdaMsgParam = pFlushAcReqParams;
10404 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10405 status = WDI_FlushAcReq(wdiFlushAcReqParam,
10406 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10407 if(IS_WDI_STATUS_FAILURE(status))
10408 {
10409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10410 "Failure in Flush AC REQ Params WDI API, free all the memory " );
10411 vos_mem_free(pWdaParams->wdaMsgParam) ;
10412 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10413 vos_mem_free(pWdaParams) ;
10414 //TODO: respond to TL with failure
10415 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10416 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10417}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10418/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10419 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10420 *
10421 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10422void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10423{
10424 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10425 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10426 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10427
10428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10429 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10430 if(NULL == pWdaParams)
10431 {
10432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10433 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10434 VOS_ASSERT(0) ;
10435 return ;
10436 }
10437 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10438 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10439 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10440 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10441 {
10442 pWDA->wdaAmpSessionOn = VOS_FALSE;
10443 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10444 vos_mem_free(pWdaParams->wdaMsgParam) ;
10445 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10446 vos_mem_free(pWdaParams) ;
10447 /*
10448 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
10449 * param here
10450 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10451 return ;
10452}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10453/*
10454 * FUNCTION: WDA_BtAmpEventReqCallback
10455 * Free memory.
10456 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
10457 */
10458void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
10459{
10460 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10461 tWDA_CbContext *pWDA;
10462 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10463
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10465 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10466
10467 if(NULL == pWdaParams)
10468 {
10469 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10470 "%s: pWdaParams received NULL", __func__);
10471 VOS_ASSERT(0);
10472 return;
10473 }
10474
10475 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10476 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
10477
10478 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
10479 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10480 {
10481 pWDA->wdaAmpSessionOn = VOS_FALSE;
10482 }
10483
10484 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10485 {
10486 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10487 vos_mem_free(pWdaParams->wdaMsgParam);
10488 vos_mem_free(pWdaParams);
10489 }
10490
10491 return;
10492}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10493/*
10494 * FUNCTION: WDA_ProcessBtAmpEventReq
10495 * Request to WDI to Update with BT AMP events.
10496 */
10497VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
10498 tSmeBtAmpEvent *pBtAmpEventParams)
10499{
10500 WDI_Status status = WDI_STATUS_SUCCESS ;
10501 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
10502 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
10503 sizeof(WDI_BtAmpEventParamsType)) ;
10504 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10506 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10507 if(NULL == wdiBtAmpEventParam)
10508 {
10509 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10510 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10511 VOS_ASSERT(0);
10512 return VOS_STATUS_E_NOMEM;
10513 }
10514 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10515 if(NULL == pWdaParams)
10516 {
10517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10518 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10519 VOS_ASSERT(0);
10520 vos_mem_free(wdiBtAmpEventParam);
10521 return VOS_STATUS_E_NOMEM;
10522 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10523 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
10524 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10525 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
10526 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10527 /* Store BT AMP event pointer, as this will be used for response */
10528 /* store Params pass it to WDI */
10529 pWdaParams->pWdaContext = pWDA;
10530 pWdaParams->wdaMsgParam = pBtAmpEventParams;
10531 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10532 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10533 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10534 if(IS_WDI_STATUS_FAILURE(status))
10535 {
10536 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10537 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
10538 vos_mem_free(pWdaParams->wdaMsgParam) ;
10539 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10540 vos_mem_free(pWdaParams) ;
10541 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10542 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
10543 {
10544 pWDA->wdaAmpSessionOn = VOS_TRUE;
10545 }
10546 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10547}
10548
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10549/*
10550 * FUNCTION: WDA_FTMCommandReqCallback
10551 * Handle FTM CMD response came from HAL
10552 * Route responce to HDD FTM
10553 */
10554void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
10555 void *usrData)
10556{
10557 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10558 if((NULL == pWDA) || (NULL == ftmCmdRspData))
10559 {
10560 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]10561 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10562 return;
10563 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10564 /* Release Current FTM Command Request */
10565 vos_mem_free(pWDA->wdaFTMCmdReq);
10566 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10567 /* Post FTM Responce to HDD FTM */
10568 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10569 return;
10570}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10571/*
10572 * FUNCTION: WDA_ProcessFTMCommand
10573 * Send FTM command to WDI
10574 */
10575VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
10576 tPttMsgbuffer *pPTTFtmCmd)
10577{
10578 WDI_Status status = WDI_STATUS_SUCCESS;
10579 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10580 ftmCMDReq = (WDI_FTMCommandReqType *)
10581 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
10582 if(NULL == ftmCMDReq)
10583 {
10584 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10585 "WDA FTM Command buffer alloc fail");
10586 return VOS_STATUS_E_NOMEM;
10587 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10588 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
10589 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10590 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10591 /* Send command to WDI */
10592 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10593 return status;
10594}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10595#ifdef FEATURE_OEM_DATA_SUPPORT
10596/*
10597 * FUNCTION: WDA_StartOemDataReqCallback
10598 *
10599 */
10600void WDA_StartOemDataReqCallback(
10601 WDI_oemDataRspParamsType *wdiOemDataRspParams,
10602 void* pUserData)
10603{
10604 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10605 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10606 tWDA_CbContext *pWDA;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10607 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10608
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10610 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10611
10612 if(NULL == pWdaParams)
10613 {
10614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10615 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10616 VOS_ASSERT(0) ;
10617 return ;
10618 }
10619 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
10620
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10621 if(NULL == pWDA)
10622 {
10623 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10624 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10625 VOS_ASSERT(0);
10626 return ;
10627 }
10628
10629 /*
10630 * Allocate memory for response params sent to PE
10631 */
10632 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
10633
10634 // Check if memory is allocated for OemdataMeasRsp Params.
10635 if(NULL == pOemDataRspParams)
10636 {
10637 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10638 "OEM DATA WDA callback alloc fail");
10639 VOS_ASSERT(0) ;
10640 return;
10641 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10642
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10643 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10644 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10645 vos_mem_free(pWdaParams->wdaMsgParam);
10646 vos_mem_free(pWdaParams) ;
10647
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10648 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]10649 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10650 * Also, here success always means that we have atleast one BSSID.
10651 */
10652 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
10653
10654 //enable Tx
10655 status = WDA_ResumeDataTx(pWDA);
10656 if(status != VOS_STATUS_SUCCESS)
10657 {
10658 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
10659 }
10660 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
10661 return ;
10662}
10663/*
10664 * FUNCTION: WDA_ProcessStartOemDataReq
10665 * Send Start Oem Data Req to WDI
10666 */
10667VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
10668 tStartOemDataReq *pOemDataReqParams)
10669{
10670 WDI_Status status = WDI_STATUS_SUCCESS;
10671 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10672 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10673
10674 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
10675
10676 if(NULL == wdiOemDataReqParams)
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 Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10680 VOS_ASSERT(0);
10681 return VOS_STATUS_E_NOMEM;
10682 }
10683
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10684 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
10685 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
10686 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
10687 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10688
10689 wdiOemDataReqParams->wdiReqStatusCB = NULL;
10690
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10691 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10692 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10693 {
10694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10695 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10696 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10697 vos_mem_free(pOemDataReqParams);
10698 VOS_ASSERT(0);
10699 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10700 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10701
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]10702 pWdaParams->pWdaContext = (void*)pWDA;
10703 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
10704 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10705
10706 status = WDI_StartOemDataReq(wdiOemDataReqParams,
10707 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10708
10709 if(IS_WDI_STATUS_FAILURE(status))
10710 {
10711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10712 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10713 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10714 vos_mem_free(pWdaParams->wdaMsgParam);
10715 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]10716 }
10717 return CONVERT_WDI2VOS_STATUS(status) ;
10718}
10719#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10720/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10721 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10722 *
10723 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10724void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10725{
10726 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10728 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10729 if(NULL == pWdaParams)
10730 {
10731 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10732 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10733 VOS_ASSERT(0) ;
10734 return ;
10735 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10736
10737 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10738 vos_mem_free(pWdaParams->wdaMsgParam);
10739 vos_mem_free(pWdaParams);
10740
10741 return ;
10742}
10743/*
10744 * FUNCTION: WDA_SetTxPerTrackingReqCallback
10745 * Free memory.
10746 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
10747 */
10748void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
10749{
10750 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10751
10752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10753 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10754
10755 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10756 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10758 "%s: pWdaParams received NULL", __func__);
10759 VOS_ASSERT(0);
10760 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10761 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10762
10763 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10764 {
10765 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10766 vos_mem_free(pWdaParams->wdaMsgParam);
10767 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10768 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10769
10770 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10771}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10772#ifdef WLAN_FEATURE_GTK_OFFLOAD
10773/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10774 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10775 *
10776 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10777void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10778 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10779{
10780 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10781
10782 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10783 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]10784 if(NULL == pWdaParams)
10785 {
10786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10787 "%s: pWdaParams received NULL", __func__);
10788 VOS_ASSERT(0);
10789 return;
10790 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10791
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10792 vos_mem_free(pWdaParams->wdaMsgParam) ;
10793 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10794 vos_mem_free(pWdaParams) ;
10795
10796 //print a msg, nothing else to do
10797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10798 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10799
10800 return ;
10801}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10802/*
10803 * FUNCTION: WDA_GTKOffloadReqCallback
10804 * Free memory.
10805 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
10806 */
10807void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
10808{
10809 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10810
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10812 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10813
10814 if(NULL == pWdaParams)
10815 {
10816 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10817 "%s: pWdaParams received NULL", __func__);
10818 VOS_ASSERT(0);
10819 return;
10820 }
10821
10822 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10823 {
10824 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10825 vos_mem_free(pWdaParams->wdaMsgParam);
10826 vos_mem_free(pWdaParams);
10827 }
10828
10829 return;
10830}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10831/*
10832 * FUNCTION: WDA_ProcessGTKOffloadReq
10833 * Request to WDI to set the filter to minimize unnecessary host wakeup due
10834 * to broadcast traffic (sta mode).
10835 */
10836VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
10837 tpSirGtkOffloadParams pGtkOffloadParams)
10838{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10839 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10840 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
10841 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
10842 sizeof(WDI_GtkOffloadReqMsg)) ;
10843 tWDA_ReqParams *pWdaParams ;
10844
10845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10846 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10847
10848 if(NULL == wdiGtkOffloadReqMsg)
10849 {
10850 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10851 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10852 VOS_ASSERT(0);
10853 return VOS_STATUS_E_NOMEM;
10854 }
10855
10856 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10857 if(NULL == pWdaParams)
10858 {
10859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10860 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10861 VOS_ASSERT(0);
10862 vos_mem_free(wdiGtkOffloadReqMsg);
10863 return VOS_STATUS_E_NOMEM;
10864 }
10865
10866 //
10867 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
10868 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10869
10870 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10871 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10872
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10873 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
10874 // Copy KCK
10875 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
10876 // Copy KEK
10877 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
10878 // Copy KeyReplayCounter
10879 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
10880 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
10881
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10882 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
10883 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10884
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10885
10886 /* Store Params pass it to WDI */
10887 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
10888 pWdaParams->pWdaContext = pWDA;
10889 /* Store param pointer as passed in by caller */
10890 pWdaParams->wdaMsgParam = pGtkOffloadParams;
10891
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10892 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10893
10894 if(IS_WDI_STATUS_FAILURE(status))
10895 {
10896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10897 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
10898 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10899 vos_mem_free(pWdaParams->wdaMsgParam);
10900 vos_mem_free(pWdaParams);
10901 }
10902
10903 return CONVERT_WDI2VOS_STATUS(status) ;
10904}
10905
10906/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10907 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10908 *
10909 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10910void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10911 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10912{
10913 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10914 tWDA_CbContext *pWDA;
10915 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10916 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10917 vos_msg_t vosMsg;
10918
10919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10920 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10921
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]10922 if(NULL == pWdaParams)
10923 {
10924 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10925 "%s: pWdaParams received NULL", __func__);
10926 VOS_ASSERT(0);
10927 return;
10928 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10929
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]10930 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
10931 if(NULL == pGtkOffloadGetInfoRsp)
10932 {
10933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10934 "%s: vos_mem_malloc failed ", __func__);
10935 VOS_ASSERT(0);
10936 return;
10937 }
10938
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10939 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
10940 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
10941
10942 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
10943 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
10944
10945 /* Message Header */
10946 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]10947 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10948
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]10949 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
10950 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
10951 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
10952 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
10953 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10954
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]10955 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
10956 pwdiGtkOffloadGetInfoRsparams->bssId,
10957 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10958 /* VOS message wrapper */
10959 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
10960 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
10961 vosMsg.bodyval = 0;
10962
10963 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
10964 {
10965 /* free the mem and return */
10966 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
10967 }
10968
10969 vos_mem_free(pWdaParams->wdaMsgParam) ;
10970 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10971 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10972
10973 return;
10974}
10975/*
10976 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
10977 * Free memory and send RSP back to SME.
10978 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
10979 */
10980void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
10981{
10982 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10983 vos_msg_t vosMsg;
10984
10985 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10986 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10987
10988 if(NULL == pWdaParams)
10989 {
10990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10991 "%s: pWdaParams received NULL", __func__);
10992 VOS_ASSERT(0);
10993 return;
10994 }
10995
10996 /* VOS message wrapper */
10997 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
10998 vosMsg.bodyptr = NULL;
10999 vosMsg.bodyval = 0;
11000
11001 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11002 {
11003 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11004 vos_mem_free(pWdaParams->wdaMsgParam);
11005 vos_mem_free(pWdaParams);
11006 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
11007 }
11008
11009 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11010}
11011#endif
11012
11013/*
11014 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
11015 * Request to WDI to set Tx Per Tracking configurations
11016 */
11017VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
11018{
11019 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11020 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11021 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
11022 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
11023 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
11024 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11025 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11026 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11027 if(NULL == pwdiSetTxPerTrackingReqParams)
11028 {
11029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11030 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11031 vos_mem_free(pTxPerTrackingParams);
11032 VOS_ASSERT(0);
11033 return VOS_STATUS_E_NOMEM;
11034 }
11035 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11036 if(NULL == pWdaParams)
11037 {
11038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11039 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11040 vos_mem_free(pwdiSetTxPerTrackingReqParams);
11041 vos_mem_free(pTxPerTrackingParams);
11042 VOS_ASSERT(0);
11043 return VOS_STATUS_E_NOMEM;
11044 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11045 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
11046 pTxPerTrackingParams->ucTxPerTrackingEnable;
11047 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
11048 pTxPerTrackingParams->ucTxPerTrackingPeriod;
11049 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
11050 pTxPerTrackingParams->ucTxPerTrackingRatio;
11051 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
11052 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11053 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
11054 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11055 /* Store param pointer as passed in by caller */
11056 /* store Params pass it to WDI
11057 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
11058 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
11059 pWdaParams->pWdaContext = pWDA;
11060 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11061 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11062 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11063 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11064 {
11065 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11066 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11067 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11068 vos_mem_free(pWdaParams->wdaMsgParam) ;
11069 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11070 vos_mem_free(pWdaParams) ;
11071 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11072 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11073
11074}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11075/*
11076 * FUNCTION: WDA_HALDumpCmdCallback
11077 * Send the VOS complete .
11078 */
11079void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
11080 void* pUserData)
11081{
11082 tANI_U8 *buffer = NULL;
11083 tWDA_CbContext *pWDA = NULL;
11084 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11085 if(NULL == pWdaParams)
11086 {
11087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11088 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11089 VOS_ASSERT(0) ;
11090 return ;
11091 }
11092
11093 pWDA = pWdaParams->pWdaContext;
11094 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11095 if(wdiRspParams->usBufferLen > 0)
11096 {
11097 /*Copy the Resp data to UMAC supplied buffer*/
11098 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
11099 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11100 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11101 vos_mem_free(pWdaParams);
11102
11103 /* Indicate VOSS about the start complete */
11104 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11105 return ;
11106}
11107
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11108/*
11109 * FUNCTION: WDA_ProcessHALDumpCmdReq
11110 * Send Dump command to WDI
11111 */
11112VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
11113 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
11114 tANI_U32 arg4, tANI_U8 *pBuffer)
11115{
11116 WDI_Status status = WDI_STATUS_SUCCESS;
11117 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
11118 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
11119 tWDA_ReqParams *pWdaParams ;
11120 pVosContextType pVosContext = NULL;
11121 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11122 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
11123 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]11124 if(pVosContext)
11125 {
11126 if (pVosContext->isLogpInProgress)
11127 {
11128 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
11129 "%s:LOGP in Progress. Ignore!!!", __func__);
11130 return VOS_STATUS_E_BUSY;
11131 }
11132 }
11133 else
11134 {
11135 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11136 "%s: VOS Context Null", __func__);
11137 return VOS_STATUS_E_RESOURCES;
11138 }
11139
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11140 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11141 if(NULL == pWdaParams)
11142 {
11143 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11144 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11145 return VOS_STATUS_E_NOMEM;
11146 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11147 /* Allocate memory WDI request structure*/
11148 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
11149 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
11150 if(NULL == wdiHALDumpCmdReqParam)
11151 {
11152 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11153 "WDA HAL DUMP Command buffer alloc fail");
11154 vos_mem_free(pWdaParams);
11155 return WDI_STATUS_E_FAILURE;
11156 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11157 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11158 /* Extract the arguments */
11159 wdiHalDumpCmdInfo->command = cmd;
11160 wdiHalDumpCmdInfo->argument1 = arg1;
11161 wdiHalDumpCmdInfo->argument2 = arg2;
11162 wdiHalDumpCmdInfo->argument3 = arg3;
11163 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11164 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11165 pWdaParams->pWdaContext = pVosContext->pWDAContext;
11166
11167 /* Response message will be passed through the buffer */
11168 pWdaParams->wdaMsgParam = (void *)pBuffer;
11169
11170 /* store Params pass it to WDI */
11171 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11172 /* Send command to WDI */
11173 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback, pWdaParams);
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]11174 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent), WDA_DUMPCMD_WAIT_TIMEOUT );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11175 if ( vStatus != VOS_STATUS_SUCCESS )
11176 {
11177 if ( vStatus == VOS_STATUS_E_TIMEOUT )
11178 {
11179 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11180 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11181 }
11182 else
11183 {
11184 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11185 "%s: WDA_HALDUMP reporting other error",__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11186 }
11187 VOS_ASSERT(0);
11188 }
11189 return status;
11190}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11191#ifdef WLAN_FEATURE_GTK_OFFLOAD
11192/*
11193 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
11194 * Request to WDI to get GTK Offload Information
11195 */
11196VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
11197 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
11198{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11199 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11200 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
11201 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
11202 tWDA_ReqParams *pWdaParams ;
11203
11204 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
11205 {
11206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11207 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11208 VOS_ASSERT(0);
11209 return VOS_STATUS_E_NOMEM;
11210 }
11211
11212 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11213 if(NULL == pWdaParams)
11214 {
11215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11216 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11217 VOS_ASSERT(0);
11218 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
11219 return VOS_STATUS_E_NOMEM;
11220 }
11221
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11222 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
11223 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11224
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11225 /* Store Params pass it to WDI */
11226 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
11227 pWdaParams->pWdaContext = pWDA;
11228 /* Store param pointer as passed in by caller */
11229 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
11230
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11231 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]11232 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11233
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11234 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11235
11236 if(IS_WDI_STATUS_FAILURE(status))
11237 {
11238 /* failure returned by WDI API */
11239 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11240 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
11241 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11242 vos_mem_free(pWdaParams) ;
11243 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
11244 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
11245 }
11246
11247 return CONVERT_WDI2VOS_STATUS(status) ;
11248}
11249#endif // WLAN_FEATURE_GTK_OFFLOAD
11250
11251/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11252 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
11253 *
11254 */
11255VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11256 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
11257{
11258 WDI_Status wdiStatus;
11259 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
11260
11261 addPeriodicTxPtrnParams =
11262 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
11263
11264 if (NULL == addPeriodicTxPtrnParams)
11265 {
11266 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11267 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
11268 __func__);
11269
11270 return VOS_STATUS_E_NOMEM;
11271 }
11272
11273 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
11274 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
11275
11276 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11277 addPeriodicTxPtrnParams->pUserData = pWDA;
11278
11279 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
11280
11281 if (WDI_STATUS_PENDING == wdiStatus)
11282 {
11283 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11284 "Pending received for %s:%d", __func__, __LINE__ );
11285 }
11286 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11287 {
11288 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11289 "Failure in %s:%d", __func__, __LINE__ );
11290 }
11291
11292 vos_mem_free(addPeriodicTxPtrnParams);
11293
11294 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11295}
11296
11297/*
11298 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
11299 *
11300 */
11301VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
11302 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
11303{
11304 WDI_Status wdiStatus;
11305 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
11306
11307 delPeriodicTxPtrnParams =
11308 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
11309
11310 if (NULL == delPeriodicTxPtrnParams)
11311 {
11312 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11313 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
11314 __func__);
11315
11316 return VOS_STATUS_E_NOMEM;
11317 }
11318
11319 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
11320 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
11321
11322 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
11323 delPeriodicTxPtrnParams->pUserData = pWDA;
11324
11325 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
11326
11327 if (WDI_STATUS_PENDING == wdiStatus)
11328 {
11329 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11330 "Pending received for %s:%d", __func__, __LINE__ );
11331 }
11332 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11333 {
11334 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11335 "Failure in %s:%d", __func__, __LINE__ );
11336 }
11337
11338 vos_mem_free(delPeriodicTxPtrnParams);
11339
11340 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11341}
11342
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11343#ifdef FEATURE_WLAN_BATCH_SCAN
11344/*
11345 * FUNCTION: WDA_ProcessStopBatchScanInd
11346 *
11347 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
11348 *
11349 * PARAM:
11350 * pWDA: pointer to WDA context
11351 * pReq: pointer to stop batch scan request
11352 */
11353VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
11354 tSirStopBatchScanInd *pReq)
11355{
11356 WDI_Status wdiStatus;
11357 WDI_StopBatchScanIndType wdiReq;
11358
11359 wdiReq.param = pReq->param;
11360
11361 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
11362
11363 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11364 {
11365 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11366 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
11367 }
11368
11369 vos_mem_free(pReq);
11370
11371 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11372}
11373/*==========================================================================
11374 FUNCTION WDA_ProcessTriggerBatchScanResultInd
11375
11376 DESCRIPTION
11377 API to pull batch scan result from FW
11378
11379 PARAMETERS
11380 pWDA: Pointer to WDA context
11381 pGetBatchScanReq: Pointer to get batch scan result indication
11382
11383 RETURN VALUE
11384 NONE
11385
11386===========================================================================*/
11387VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
11388 tSirTriggerBatchScanResultInd *pReq)
11389{
11390 WDI_Status wdiStatus;
11391 WDI_TriggerBatchScanResultIndType wdiReq;
11392
11393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11394 "------> %s " ,__func__);
11395
11396 wdiReq.param = pReq->param;
11397
11398 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
11399
11400 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11401 {
11402 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11403 "Trigger batch scan result ind failed %s:%d",
11404 __func__, wdiStatus);
11405 }
11406
11407 vos_mem_free(pReq);
11408
11409 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11410}
11411
11412/*==========================================================================
11413 FUNCTION WDA_SetBatchScanRespCallback
11414
11415 DESCRIPTION
11416 API to process set batch scan response from FW
11417
11418 PARAMETERS
11419 pRsp: Pointer to set batch scan response
11420 pUserData: Pointer to user data
11421
11422 RETURN VALUE
11423 NONE
11424
11425===========================================================================*/
11426void WDA_SetBatchScanRespCallback
11427(
11428 WDI_SetBatchScanRspType *pRsp,
11429 void* pUserData
11430)
11431{
11432 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
11433 tpAniSirGlobal pMac;
11434 void *pCallbackContext;
11435 tWDA_CbContext *pWDA = NULL ;
11436 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11437
11438
11439 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11440 "<------ %s " ,__func__);
11441 if (NULL == pWdaParams)
11442 {
11443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11444 "%s: pWdaParams received NULL", __func__);
11445 VOS_ASSERT(0) ;
11446 return ;
11447 }
11448
11449 /*extract WDA context*/
11450 pWDA = pWdaParams->pWdaContext;
11451 if (NULL == pWDA)
11452 {
11453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11454 "%s:pWDA is NULL can't invole HDD callback",
11455 __func__);
11456 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11457 vos_mem_free(pWdaParams->wdaMsgParam);
11458 vos_mem_free(pWdaParams);
11459 VOS_ASSERT(0);
11460 return;
11461 }
11462
11463 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11464 vos_mem_free(pWdaParams->wdaMsgParam);
11465 vos_mem_free(pWdaParams);
11466
11467 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11468 if (NULL == pMac)
11469 {
11470 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11471 "%s:pMac is NULL", __func__);
11472 VOS_ASSERT(0);
11473 return;
11474 }
11475
11476 pHddSetBatchScanRsp =
11477 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
11478 if (NULL == pHddSetBatchScanRsp)
11479 {
11480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11481 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
11482 VOS_ASSERT(0);
11483 return;
11484 }
11485
11486 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
11487
11488 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
11489 /*call hdd callback with set batch scan response data*/
11490 if(pMac->pmc.setBatchScanReqCallback)
11491 {
11492 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
11493 }
11494 else
11495 {
11496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11497 "%s:HDD callback is null", __func__);
11498 VOS_ASSERT(0);
11499 }
11500
11501 vos_mem_free(pHddSetBatchScanRsp);
11502 return ;
11503}
11504
11505/*==========================================================================
11506 FUNCTION WDA_ProcessSetBatchScanReq
11507
11508 DESCRIPTION
11509 API to send set batch scan request to WDI
11510
11511 PARAMETERS
11512 pWDA: Pointer to WDA context
11513 pSetBatchScanReq: Pointer to set batch scan req
11514
11515 RETURN VALUE
11516 NONE
11517
11518===========================================================================*/
11519VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
11520 tSirSetBatchScanReq *pSetBatchScanReq)
11521{
11522 WDI_Status status;
11523 tWDA_ReqParams *pWdaParams ;
11524 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
11525
11526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
11527 "------> %s " ,__func__);
11528
11529 pWdiSetBatchScanReq =
11530 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
11531 if (NULL == pWdiSetBatchScanReq)
11532 {
11533 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11534 "%s: VOS MEM Alloc Failure", __func__);
11535 vos_mem_free(pSetBatchScanReq);
11536 VOS_ASSERT(0);
11537 return VOS_STATUS_E_NOMEM;
11538 }
11539
11540 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
11541 if (NULL == pWdaParams)
11542 {
11543 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11544 "%s: VOS MEM Alloc Failure", __func__);
11545 VOS_ASSERT(0);
11546 vos_mem_free(pSetBatchScanReq);
11547 vos_mem_free(pWdiSetBatchScanReq);
11548 return VOS_STATUS_E_NOMEM;
11549 }
11550
11551 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
11552 pWdiSetBatchScanReq->numberOfScansToBatch =
11553 pSetBatchScanReq->numberOfScansToBatch;
11554 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
11555 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
11556 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
11557
11558 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
11559 pWdaParams->pWdaContext = pWDA;
11560 pWdaParams->wdaMsgParam = pSetBatchScanReq;
11561
11562 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
11563 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
11564 if (IS_WDI_STATUS_FAILURE(status))
11565 {
11566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11567 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
11568 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11569 vos_mem_free(pWdaParams->wdaMsgParam);
11570 vos_mem_free(pWdaParams);
11571 }
11572 return CONVERT_WDI2VOS_STATUS(status);
11573}
11574
11575#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11576/*
11577 * FUNCTION: WDA_ProcessHT40OBSSScanInd
11578 *
11579 * DESCRIPTION: This function sends start/update OBSS scan
11580 * inidcation message to WDI
11581 *
11582 * PARAM:
11583 * pWDA: pointer to WDA context
11584 * pReq: pointer to start OBSS scan request
11585 */
11586VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
11587 tSirHT40OBSSScanInd *pReq)
11588{
11589 WDI_Status status;
11590 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
11591 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]11592
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]11593 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11594 "------> %s " ,__func__);
11595 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11596 wdiOBSSScanParams.pUserData = pWDA;
11597
11598 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
11599 pWdiOBSSScanInd->cmdType = pReq->cmdType;
11600 pWdiOBSSScanInd->scanType = pReq->scanType;
11601 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
11602 pReq->OBSSScanActiveDwellTime;
11603 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
11604 pReq->OBSSScanPassiveDwellTime;
11605 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
11606 pReq->BSSChannelWidthTriggerScanInterval;
11607 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
11608 pReq->BSSWidthChannelTransitionDelayFactor;
11609 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
11610 pReq->OBSSScanActiveTotalPerChannel;
11611 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
11612 pReq->OBSSScanPassiveTotalPerChannel;
11613 pWdiOBSSScanInd->OBSSScanActivityThreshold =
11614 pReq->OBSSScanActivityThreshold;
11615 pWdiOBSSScanInd->channelCount = pReq->channelCount;
11616 vos_mem_copy(pWdiOBSSScanInd->channels,
11617 pReq->channels,
11618 pReq->channelCount);
11619 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
11620 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
11621 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
11622 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
11623 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
11624
11625 vos_mem_copy(pWdiOBSSScanInd->ieField,
11626 pReq->ieField,
11627 pReq->ieFieldLen);
11628
11629 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
11630 if (WDI_STATUS_PENDING == status)
11631 {
11632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11633 "Pending received for %s:%d ",__func__,__LINE__ );
11634 }
11635 else if (WDI_STATUS_SUCCESS_SYNC != status)
11636 {
11637 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11638 "Failure in %s:%d ",__func__,__LINE__ );
11639 }
11640 return CONVERT_WDI2VOS_STATUS(status) ;
11641}
11642/*
11643 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
11644 *
11645 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
11646 *
11647 * PARAM:
11648 * pWDA: pointer to WDA context
11649 * pReq: pointer to stop batch scan request
11650 */
11651VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
11652 tANI_U8 *bssIdx)
11653{
11654 WDI_Status status;
11655
11656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11657 "------> %s " ,__func__);
11658
11659 status = WDI_HT40OBSSStopScanInd(*bssIdx);
11660 if (WDI_STATUS_PENDING == status)
11661 {
11662 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11663 "Pending received for %s:%d ",__func__,__LINE__ );
11664 }
11665 else if (WDI_STATUS_SUCCESS_SYNC != status)
11666 {
11667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11668 "Failure in %s:%d ",__func__,__LINE__ );
11669 }
11670 return CONVERT_WDI2VOS_STATUS(status) ;
11671}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]11672/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]11673 * FUNCTION: WDA_ProcessRateUpdateInd
11674 *
11675 */
11676VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
11677 tSirRateUpdateInd *pRateUpdateParams)
11678{
11679 WDI_Status wdiStatus;
11680 WDI_RateUpdateIndParams rateUpdateParams;
11681
11682 vos_mem_copy(rateUpdateParams.bssid,
11683 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
11684
11685 rateUpdateParams.ucastDataRateTxFlag =
11686 pRateUpdateParams->ucastDataRateTxFlag;
11687 rateUpdateParams.reliableMcastDataRateTxFlag =
11688 pRateUpdateParams->reliableMcastDataRateTxFlag;
11689 rateUpdateParams.mcastDataRate24GHzTxFlag =
11690 pRateUpdateParams->mcastDataRate24GHzTxFlag;
11691 rateUpdateParams.mcastDataRate5GHzTxFlag =
11692 pRateUpdateParams->mcastDataRate5GHzTxFlag;
11693
11694 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
11695 rateUpdateParams.reliableMcastDataRate =
11696 pRateUpdateParams->reliableMcastDataRate;
11697 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
11698 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
11699
11700 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
11701 rateUpdateParams.pUserData = pWDA;
11702
11703 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
11704
11705 if (WDI_STATUS_PENDING == wdiStatus)
11706 {
11707 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11708 "Pending received for %s:%d", __func__, __LINE__ );
11709 }
11710 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
11711 {
11712 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11713 "Failure in %s:%d", __func__, __LINE__ );
11714 }
11715
11716 vos_mem_free(pRateUpdateParams);
11717
11718 return CONVERT_WDI2VOS_STATUS(wdiStatus);
11719}
11720
11721/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11722 * -------------------------------------------------------------------------
11723 * DATA interface with WDI for Mgmt Frames
11724 * -------------------------------------------------------------------------
11725 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11726/*
11727 * FUNCTION: WDA_TxComplete
11728 * Callback function for the WDA_TxPacket
11729 */
11730VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
11731 VOS_STATUS status )
11732{
11733
11734 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
11735 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11736 tANI_U32 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11737
11738 if(NULL == wdaContext)
11739 {
11740 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11741 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11742 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11743 VOS_ASSERT(0);
11744 return VOS_STATUS_E_FAILURE;
11745 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11746
11747 /*Check if frame was timed out or not*/
11748 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
11749 (v_PVOID_t)&uUserData);
11750
11751 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
11752 {
11753 /*Discard frame - no further processing is needed*/
11754 vos_pkt_return_packet(pData);
11755 return VOS_STATUS_SUCCESS;
11756 }
11757
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11758 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
11759 if( NULL!=wdaContext->pTxCbFunc)
11760 {
11761 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11762 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]11763 {
11764 wdaContext->pTxCbFunc(pMac, pData);
11765 }
11766 else
11767 {
11768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]11769 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11770 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11771 //Return from here since we reaching here because the packet already timeout
11772 return status;
11773 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11774 }
11775
11776 /*
11777 * Trigger the event to bring the HAL TL Tx complete function to come
11778 * out of wait
11779 * Let the coe above to complete the packet first. When this event is set,
11780 * the thread waiting for the event may run and set Vospacket_freed causing the original
11781 * packet not being freed.
11782 */
11783 status = vos_event_set(&wdaContext->txFrameEvent);
11784 if(!VOS_IS_STATUS_SUCCESS(status))
11785 {
11786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11787 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11788 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11789 return status;
11790}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11791/*
11792 * FUNCTION: WDA_TxPacket
11793 * Forward TX management frame to WDI
11794 */
11795VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
11796 void *pFrmBuf,
11797 tANI_U16 frmLen,
11798 eFrameType frmType,
11799 eFrameTxDir txDir,
11800 tANI_U8 tid,
11801 pWDATxRxCompFunc pCompFunc,
11802 void *pData,
11803 pWDAAckFnTxComp pAckTxComp,
Kanchanapally, Vidyullathaf9426e52013-12-24 17:28:54 +0530[diff] [blame]11804 tANI_U32 txFlag)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11805{
11806 VOS_STATUS status = VOS_STATUS_SUCCESS ;
11807 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
11808 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
11809 tANI_U8 eventIdx = 0;
11810 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
11811 tpAniSirGlobal pMac;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11812 if((NULL == pWDA)||(NULL == pFrmBuf))
11813 {
11814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]11815 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11816 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11817 VOS_ASSERT(0);
11818 return VOS_STATUS_E_FAILURE;
11819 }
11820
11821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11822 "Tx Mgmt Frame Subtype: %d alloc(%p)", pFc->subType, pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11823 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
11824 if(NULL == pMac)
11825 {
11826 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11827 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11828 VOS_ASSERT(0);
11829 return VOS_STATUS_E_FAILURE;
11830 }
11831
11832
11833
11834 /* store the call back function in WDA context */
11835 pWDA->pTxCbFunc = pCompFunc;
11836 /* store the call back for the function of ackTxComplete */
11837 if( pAckTxComp )
11838 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11839 if( NULL != pWDA->pAckTxCbFunc )
11840 {
11841 /* Already TxComp is active no need to active again */
11842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11843 "There is already one request pending for tx complete");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11844 pWDA->pAckTxCbFunc( pMac, 0);
11845 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11846
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11847 if( VOS_STATUS_SUCCESS !=
11848 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11849 {
11850 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11851 "Tx Complete timeout Timer Stop Failed ");
11852 }
11853 else
11854 {
11855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]11856 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11857 }
11858 }
11859
11860 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
11861 pWDA->pAckTxCbFunc = pAckTxComp;
11862 if( VOS_STATUS_SUCCESS !=
11863 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
11864 {
11865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11866 "Tx Complete Timer Start Failed ");
11867 pWDA->pAckTxCbFunc = NULL;
11868 return eHAL_STATUS_FAILURE;
11869 }
11870 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11871 /* Reset the event to be not signalled */
11872 status = vos_event_reset(&pWDA->txFrameEvent);
11873 if(!VOS_IS_STATUS_SUCCESS(status))
11874 {
11875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11876 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11877 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
11878 if( pAckTxComp )
11879 {
11880 pWDA->pAckTxCbFunc = NULL;
11881 if( VOS_STATUS_SUCCESS !=
11882 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11883 {
11884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11885 "Tx Complete timeout Timer Stop Failed ");
11886 }
11887 }
11888 return VOS_STATUS_E_FAILURE;
11889 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11890
11891 /* If Peer Sta mask is set don't overwrite to self sta */
11892 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11893 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11894 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11895 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11896 else
11897 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11898 /* Get system role, use the self station if in unknown role or STA role */
11899 systemRole = wdaGetGlobalSystemRole(pMac);
11900 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
11901 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]11902#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11903 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]11904#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]11905 ))
11906 {
11907 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
11908 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]11909 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11910
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11911 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
11912 disassoc frame reaches the HW, HAL has already deleted the peer station */
11913 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11914 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]11915 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11916 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11917 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11918 /*Send Probe request frames on self sta idx*/
11919 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]11920 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11921 /* Since we donot want probe responses to be retried, send probe responses
11922 through the NO_ACK queues */
11923 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
11924 {
11925 //probe response is sent out using self station and no retries options.
11926 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
11927 }
11928 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
11929 {
11930 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
11931 }
11932 }
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11933 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]11934
11935 /*Set frame tag to 0
11936 We will use the WDA user data in order to tag a frame as expired*/
11937 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
11938 (v_PVOID_t)0);
11939
11940
11941 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
11942 frmLen, ucTypeSubType, tid,
11943 WDA_TxComplete, NULL, txFlag)) != VOS_STATUS_SUCCESS)
11944 {
11945 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]11946 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11947 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11948 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]11949 if( pAckTxComp )
11950 {
11951 pWDA->pAckTxCbFunc = NULL;
11952 if( VOS_STATUS_SUCCESS !=
11953 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11954 {
11955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11956 "Tx Complete timeout Timer Stop Failed ");
11957 }
11958 }
11959 return VOS_STATUS_E_FAILURE;
11960 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11961 /*
11962 * Wait for the event to be set by the TL, to get the response of TX
11963 * complete, this event should be set by the Callback function called by TL
11964 */
11965 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
11966 &eventIdx);
11967 if(!VOS_IS_STATUS_SUCCESS(status))
11968 {
11969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11970 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11971 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11972 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
11973 after the packet gets completed(packet freed once)*/
11974
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]11975 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]11976 WDA_TransportChannelDebug(pMac, 1, WPAL_DEBUG_TX_DESC_RESYNC);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]11977
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11978 /*Tag Frame as timed out for later deletion*/
11979 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
11980 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
11981
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11982 /* check whether the packet was freed already,so need not free again when
11983 * TL calls the WDA_Txcomplete routine
11984 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]11985 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
11986 /*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]11987 {
11988 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]11989 } */
11990
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11991 if( pAckTxComp )
11992 {
11993 pWDA->pAckTxCbFunc = NULL;
11994 if( VOS_STATUS_SUCCESS !=
11995 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
11996 {
11997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11998 "Tx Complete timeout Timer Stop Failed ");
11999 }
12000 }
12001 status = VOS_STATUS_E_FAILURE;
12002 }
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]12003#ifdef WLAN_DUMP_MGMTFRAMES
12004 if (VOS_IS_STATUS_SUCCESS(status))
12005 {
12006 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12007 "%s() TX packet : SubType %d", __func__,pFc->subType);
12008 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12009 pData, frmLen);
12010 }
12011#endif
12012
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]12013 if (VOS_IS_STATUS_SUCCESS(status))
12014 {
12015 if (pMac->fEnableDebugLog & 0x1)
12016 {
12017 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
12018 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
12019 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
12020 {
12021 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
12022 pFc->type, pFc->subType);
12023 }
12024 }
12025 }
12026
12027
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12028 return status;
12029}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12030/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12031 * FUNCTION: WDA_ProcessDHCPStartInd
12032 * Forward DHCP Start to WDI
12033 */
12034static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
12035 tAniDHCPInd *dhcpStartInd)
12036{
12037 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12038 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12039
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12040 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
12041 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12042 sizeof(tSirMacAddr));
12043
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12044 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12045
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12046 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12047 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12048 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12049 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12050 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12051 else if (WDI_STATUS_SUCCESS_SYNC != status)
12052 {
12053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12054 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
12055 }
12056
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12057 vos_mem_free(dhcpStartInd);
12058 return CONVERT_WDI2VOS_STATUS(status) ;
12059}
12060
12061 /*
12062 * FUNCTION: WDA_ProcessDHCPStopInd
12063 * Forward DHCP Stop to WDI
12064 */
12065 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
12066 tAniDHCPInd *dhcpStopInd)
12067 {
12068 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12069 WDI_DHCPInd wdiDHCPInd;
12070
12071 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
12072 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
12073
12074 status = WDI_dhcpStopInd(&wdiDHCPInd);
12075
12076 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12077 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12078 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12079 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12080 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12081 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12082 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12084 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12085 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12086
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12087 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]12088
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12089 return CONVERT_WDI2VOS_STATUS(status) ;
12090 }
12091
12092/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12093 * FUNCTION: WDA_McProcessMsg
12094 * Trigger DAL-AL to start CFG download
12095 */
12096VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
12097{
12098 VOS_STATUS status = VOS_STATUS_SUCCESS;
12099 tWDA_CbContext *pWDA = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12100 if(NULL == pMsg)
12101 {
12102 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12103 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12104 VOS_ASSERT(0);
12105 return VOS_STATUS_E_FAILURE;
12106 }
12107
12108 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12109 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12110
12111 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
12112 if(NULL == pWDA )
12113 {
12114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12115 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12116 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12117 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12118 return VOS_STATUS_E_FAILURE;
12119 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12120 /* Process all the WDA messages.. */
12121 switch( pMsg->type )
12122 {
12123 case WNI_CFG_DNLD_REQ:
12124 {
12125 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12126 /* call WDA complete event if config download success */
12127 if( VOS_IS_STATUS_SUCCESS(status) )
12128 {
12129 vos_WDAComplete_cback(pVosContext);
12130 }
12131 else
12132 {
12133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12134 "WDA Config Download failure" );
12135 }
12136 break ;
12137 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12138 /*
12139 * Init SCAN request from PE, convert it into DAL format
12140 * and send it to DAL
12141 */
12142 case WDA_INIT_SCAN_REQ:
12143 {
12144 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
12145 break ;
12146 }
12147 /* start SCAN request from PE */
12148 case WDA_START_SCAN_REQ:
12149 {
12150 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
12151 break ;
12152 }
12153 /* end SCAN request from PE */
12154 case WDA_END_SCAN_REQ:
12155 {
12156 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
12157 break ;
12158 }
12159 /* end SCAN request from PE */
12160 case WDA_FINISH_SCAN_REQ:
12161 {
12162 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
12163 break ;
12164 }
12165 /* join request from PE */
12166 case WDA_CHNL_SWITCH_REQ:
12167 {
12168 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
12169 {
12170 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
12171 }
12172 else
12173 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]12174 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
12175 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
12176 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
12177 {
12178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12179 "call ProcessChannelSwitchReq_V1" );
12180 WDA_ProcessChannelSwitchReq_V1(pWDA,
12181 (tSwitchChannelParams*)pMsg->bodyptr) ;
12182 }
12183 else
12184 {
12185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12186 "call ProcessChannelSwitchReq" );
12187 WDA_ProcessChannelSwitchReq(pWDA,
12188 (tSwitchChannelParams*)pMsg->bodyptr) ;
12189 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12190 }
12191 break ;
12192 }
12193 /* ADD BSS request from PE */
12194 case WDA_ADD_BSS_REQ:
12195 {
12196 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
12197 break ;
12198 }
12199 case WDA_ADD_STA_REQ:
12200 {
12201 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
12202 break ;
12203 }
12204 case WDA_DELETE_BSS_REQ:
12205 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12206 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
12207 break ;
12208 }
12209 case WDA_DELETE_STA_REQ:
12210 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12211 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
12212 break ;
12213 }
12214 case WDA_CONFIG_PARAM_UPDATE_REQ:
12215 {
12216 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
12217 break ;
12218 }
12219 case WDA_SET_BSSKEY_REQ:
12220 {
12221 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
12222 break ;
12223 }
12224 case WDA_SET_STAKEY_REQ:
12225 {
12226 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12227 break ;
12228 }
12229 case WDA_SET_STA_BCASTKEY_REQ:
12230 {
12231 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
12232 break ;
12233 }
12234 case WDA_REMOVE_BSSKEY_REQ:
12235 {
12236 WDA_ProcessRemoveBssKeyReq(pWDA,
12237 (tRemoveBssKeyParams *)pMsg->bodyptr);
12238 break ;
12239 }
12240 case WDA_REMOVE_STAKEY_REQ:
12241 {
12242 WDA_ProcessRemoveStaKeyReq(pWDA,
12243 (tRemoveStaKeyParams *)pMsg->bodyptr);
12244 break ;
12245 }
12246 case WDA_REMOVE_STA_BCASTKEY_REQ:
12247 {
12248 /* TODO: currently UMAC is not sending this request, Add the code for
12249 handling this request when UMAC supports */
12250 break;
12251 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12252#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12253 case WDA_TSM_STATS_REQ:
12254 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]12255 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12256 break;
12257 }
12258#endif
12259 case WDA_UPDATE_EDCA_PROFILE_IND:
12260 {
12261 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
12262 break;
12263 }
12264 case WDA_ADD_TS_REQ:
12265 {
12266 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
12267 break;
12268 }
12269 case WDA_DEL_TS_REQ:
12270 {
12271 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
12272 break;
12273 }
12274 case WDA_ADDBA_REQ:
12275 {
12276 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
12277 break;
12278 }
12279 case WDA_DELBA_IND:
12280 {
12281 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
12282 break;
12283 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]12284 case WDA_UPDATE_CHAN_LIST_REQ:
12285 {
12286 WDA_ProcessUpdateChannelList(pWDA,
12287 (tSirUpdateChanList *)pMsg->bodyptr);
12288 break;
12289 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12290 case WDA_SET_LINK_STATE:
12291 {
12292 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
12293 break;
12294 }
12295 case WDA_GET_STATISTICS_REQ:
12296 {
12297 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
12298 break;
12299 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12300#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]12301 case WDA_GET_ROAM_RSSI_REQ:
12302 {
12303 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
12304 break;
12305 }
12306#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12307 case WDA_PWR_SAVE_CFG:
12308 {
12309 if(pWDA->wdaState == WDA_READY_STATE)
12310 {
12311 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
12312 }
12313 else
12314 {
12315 if(NULL != pMsg->bodyptr)
12316 {
12317 vos_mem_free(pMsg->bodyptr);
12318 }
12319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12320 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
12321 }
12322 break;
12323 }
12324 case WDA_ENTER_IMPS_REQ:
12325 {
12326 if(pWDA->wdaState == WDA_READY_STATE)
12327 {
12328 WDA_ProcessEnterImpsReq(pWDA);
12329 }
12330 else
12331 {
12332 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12333 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12334 }
12335 break;
12336 }
12337 case WDA_EXIT_IMPS_REQ:
12338 {
12339 if(pWDA->wdaState == WDA_READY_STATE)
12340 {
12341 WDA_ProcessExitImpsReq(pWDA);
12342 }
12343 else
12344 {
12345 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12346 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
12347 }
12348 break;
12349 }
12350 case WDA_ENTER_BMPS_REQ:
12351 {
12352 if(pWDA->wdaState == WDA_READY_STATE)
12353 {
12354 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
12355 }
12356 else
12357 {
12358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12359 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12360 }
12361 break;
12362 }
12363 case WDA_EXIT_BMPS_REQ:
12364 {
12365 if(pWDA->wdaState == WDA_READY_STATE)
12366 {
12367 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
12368 }
12369 else
12370 {
12371 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12372 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
12373 }
12374 break;
12375 }
12376 case WDA_ENTER_UAPSD_REQ:
12377 {
12378 if(pWDA->wdaState == WDA_READY_STATE)
12379 {
12380 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
12381 }
12382 else
12383 {
12384 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12385 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12386 }
12387 break;
12388 }
12389 case WDA_EXIT_UAPSD_REQ:
12390 {
12391 if(pWDA->wdaState == WDA_READY_STATE)
12392 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12393 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12394 }
12395 else
12396 {
12397 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12398 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
12399 }
12400 break;
12401 }
12402 case WDA_UPDATE_UAPSD_IND:
12403 {
12404 if(pWDA->wdaState == WDA_READY_STATE)
12405 {
12406 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
12407 }
12408 else
12409 {
12410 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12411 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
12412 }
12413 break;
12414 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12415 case WDA_REGISTER_PE_CALLBACK :
12416 {
12417 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12418 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
12419 /*TODO: store the PE callback */
12420 /* Do Nothing? MSG Body should be freed at here */
12421 if(NULL != pMsg->bodyptr)
12422 {
12423 vos_mem_free(pMsg->bodyptr);
12424 }
12425 break;
12426 }
12427 case WDA_SYS_READY_IND :
12428 {
12429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12430 "Handling msg type WDA_SYS_READY_IND " );
12431 pWDA->wdaState = WDA_READY_STATE;
12432 if(NULL != pMsg->bodyptr)
12433 {
12434 vos_mem_free(pMsg->bodyptr);
12435 }
12436 break;
12437 }
12438 case WDA_BEACON_FILTER_IND :
12439 {
12440 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
12441 break;
12442 }
12443 case WDA_BTC_SET_CFG:
12444 {
12445 /*TODO: handle this while dealing with BTC */
12446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12447 "Handling msg type WDA_BTC_SET_CFG " );
12448 /* Do Nothing? MSG Body should be freed at here */
12449 if(NULL != pMsg->bodyptr)
12450 {
12451 vos_mem_free(pMsg->bodyptr);
12452 }
12453 break;
12454 }
12455 case WDA_SIGNAL_BT_EVENT:
12456 {
12457 /*TODO: handle this while dealing with BTC */
12458 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
12459 "Handling msg type WDA_SIGNAL_BT_EVENT " );
12460 /* Do Nothing? MSG Body should be freed at here */
12461 if(NULL != pMsg->bodyptr)
12462 {
12463 vos_mem_free(pMsg->bodyptr);
12464 }
12465 break;
12466 }
12467 case WDA_CFG_RXP_FILTER_REQ:
12468 {
12469 WDA_ProcessConfigureRxpFilterReq(pWDA,
12470 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
12471 break;
12472 }
12473 case WDA_SET_HOST_OFFLOAD:
12474 {
12475 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12476 break;
12477 }
12478 case WDA_SET_KEEP_ALIVE:
12479 {
12480 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
12481 break;
12482 }
12483#ifdef WLAN_NS_OFFLOAD
12484 case WDA_SET_NS_OFFLOAD:
12485 {
12486 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
12487 break;
12488 }
12489#endif //WLAN_NS_OFFLOAD
12490 case WDA_ADD_STA_SELF_REQ:
12491 {
12492 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
12493 break;
12494 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12495 case WDA_DEL_STA_SELF_REQ:
12496 {
12497 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
12498 break;
12499 }
12500 case WDA_WOWL_ADD_BCAST_PTRN:
12501 {
12502 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
12503 break;
12504 }
12505 case WDA_WOWL_DEL_BCAST_PTRN:
12506 {
12507 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
12508 break;
12509 }
12510 case WDA_WOWL_ENTER_REQ:
12511 {
12512 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
12513 break;
12514 }
12515 case WDA_WOWL_EXIT_REQ:
12516 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12517 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12518 break;
12519 }
12520 case WDA_TL_FLUSH_AC_REQ:
12521 {
12522 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
12523 break;
12524 }
12525 case WDA_SIGNAL_BTAMP_EVENT:
12526 {
12527 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
12528 break;
12529 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]12530#ifdef WLAN_FEATURE_LINK_LAYER_STATS
12531 case WDA_LINK_LAYER_STATS_SET_REQ:
12532 {
12533 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
12534 break;
12535 }
12536 case WDA_LINK_LAYER_STATS_GET_REQ:
12537 {
12538 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
12539 break;
12540 }
12541 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
12542 {
12543 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
12544 break;
12545 }
12546#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]12547#ifdef WLAN_FEATURE_EXTSCAN
12548 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
12549 {
12550 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
12551 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
12552 break;
12553 }
12554 case WDA_EXTSCAN_START_REQ:
12555 {
12556 WDA_ProcessEXTScanStartReq(pWDA,
12557 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
12558 break;
12559 }
12560 case WDA_EXTSCAN_STOP_REQ:
12561 {
12562 WDA_ProcessEXTScanStopReq(pWDA,
12563 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
12564 break;
12565 }
12566 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
12567 {
12568 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
12569 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
12570 break;
12571 }
12572 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
12573 {
12574 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
12575 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
12576 break;
12577 }
12578 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
12579 {
12580 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
12581 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
12582 break;
12583 }
12584 case WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_REQ:
12585 {
12586 WDA_ProcessEXTScanSetSignfRSSIChangeReq(pWDA,
12587 (tSirEXTScanSetSignificantChangeReqParams *)pMsg->bodyptr);
12588 break;
12589 }
12590 case WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_REQ:
12591 {
12592 WDA_ProcessEXTScanResetSignfRSSIChangeReq(pWDA,
12593 (tSirEXTScanResetSignificantChangeReqParams *)pMsg->bodyptr);
12594 break;
12595 }
12596#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12597#ifdef WDA_UT
12598 case WDA_WDI_EVENT_MSG:
12599 {
12600 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
12601 break ;
12602 }
12603#endif
12604 case WDA_UPDATE_BEACON_IND:
12605 {
12606 WDA_ProcessUpdateBeaconParams(pWDA,
12607 (tUpdateBeaconParams *)pMsg->bodyptr);
12608 break;
12609 }
12610 case WDA_SEND_BEACON_REQ:
12611 {
12612 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
12613 break;
12614 }
12615 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
12616 {
12617 WDA_ProcessUpdateProbeRspTemplate(pWDA,
12618 (tSendProbeRespParams *)pMsg->bodyptr);
12619 break;
12620 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]12621#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12622 case WDA_SET_MAX_TX_POWER_REQ:
12623 {
12624 WDA_ProcessSetMaxTxPowerReq(pWDA,
12625 (tMaxTxPowerParams *)pMsg->bodyptr);
12626 break;
12627 }
12628#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]12629 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
12630 {
12631 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
12632 pMsg->bodyptr);
12633 break;
12634 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]12635 case WDA_SET_TX_POWER_REQ:
12636 {
12637 WDA_ProcessSetTxPowerReq(pWDA,
12638 (tSirSetTxPowerReq *)pMsg->bodyptr);
12639 break;
12640 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12641 case WDA_SET_P2P_GO_NOA_REQ:
12642 {
12643 WDA_ProcessSetP2PGONOAReq(pWDA,
12644 (tP2pPsParams *)pMsg->bodyptr);
12645 break;
12646 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12647 /* timer related messages */
12648 case WDA_TIMER_BA_ACTIVITY_REQ:
12649 {
12650 WDA_BaCheckActivity(pWDA) ;
12651 break ;
12652 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]12653
12654 /* timer related messages */
12655 case WDA_TIMER_TRAFFIC_STATS_IND:
12656 {
12657 WDA_TimerTrafficStatsInd(pWDA);
12658 break;
12659 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12660#ifdef WLAN_FEATURE_VOWIFI_11R
12661 case WDA_AGGR_QOS_REQ:
12662 {
12663 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
12664 break;
12665 }
12666#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12667 case WDA_FTM_CMD_REQ:
12668 {
12669 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
12670 break ;
12671 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12672#ifdef FEATURE_OEM_DATA_SUPPORT
12673 case WDA_START_OEM_DATA_REQ:
12674 {
12675 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
12676 break;
12677 }
12678#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12679 /* Tx Complete Time out Indication */
12680 case WDA_TX_COMPLETE_TIMEOUT_IND:
12681 {
12682 WDA_ProcessTxCompleteTimeOutInd(pWDA);
12683 break;
12684 }
12685 case WDA_WLAN_SUSPEND_IND:
12686 {
12687 WDA_ProcessWlanSuspendInd(pWDA,
12688 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
12689 break;
12690 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12691 case WDA_WLAN_RESUME_REQ:
12692 {
12693 WDA_ProcessWlanResumeReq(pWDA,
12694 (tSirWlanResumeParam *)pMsg->bodyptr) ;
12695 break;
12696 }
12697
12698 case WDA_UPDATE_CF_IND:
12699 {
12700 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
12701 pMsg->bodyptr = NULL;
12702 break;
12703 }
12704#ifdef FEATURE_WLAN_SCAN_PNO
12705 case WDA_SET_PNO_REQ:
12706 {
12707 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
12708 break;
12709 }
12710 case WDA_UPDATE_SCAN_PARAMS_REQ:
12711 {
12712 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
12713 break;
12714 }
12715 case WDA_SET_RSSI_FILTER_REQ:
12716 {
12717 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
12718 break;
12719 }
12720#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12721#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12722 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12723 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]12724 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]12725 break;
12726 }
12727#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12728 case WDA_SET_TX_PER_TRACKING_REQ:
12729 {
12730 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
12731 break;
12732 }
12733
12734#ifdef WLAN_FEATURE_PACKET_FILTERING
12735 case WDA_8023_MULTICAST_LIST_REQ:
12736 {
12737 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
12738 break;
12739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12740 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
12741 {
12742 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
12743 break;
12744 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12745 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
12746 {
12747 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
12748 break;
12749 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12750 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
12751 {
12752 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
12753 break;
12754 }
12755#endif // WLAN_FEATURE_PACKET_FILTERING
12756
12757
12758 case WDA_TRANSMISSION_CONTROL_IND:
12759 {
12760 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
12761 break;
12762 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12763 case WDA_SET_POWER_PARAMS_REQ:
12764 {
12765 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
12766 break;
12767 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12768#ifdef WLAN_FEATURE_GTK_OFFLOAD
12769 case WDA_GTK_OFFLOAD_REQ:
12770 {
12771 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
12772 break;
12773 }
12774
12775 case WDA_GTK_OFFLOAD_GETINFO_REQ:
12776 {
12777 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
12778 break;
12779 }
12780#endif //WLAN_FEATURE_GTK_OFFLOAD
12781
12782 case WDA_SET_TM_LEVEL_REQ:
12783 {
12784 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
12785 break;
12786 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]12787
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12788 case WDA_UPDATE_OP_MODE:
12789 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]12790 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
12791 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
12792 {
12793 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
12794 }
12795 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12796 {
12797 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
12798 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
12799 else
12800 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12801 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12802 }
12803 else
12804 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]12805 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]12806 break;
12807 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]12808#ifdef WLAN_FEATURE_11W
12809 case WDA_EXCLUDE_UNENCRYPTED_IND:
12810 {
12811 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
12812 break;
12813 }
12814#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]12815#ifdef FEATURE_WLAN_TDLS
12816 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
12817 {
12818 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
12819 break;
12820 }
12821#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]12822 case WDA_DHCP_START_IND:
12823 {
12824 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
12825 break;
12826 }
12827 case WDA_DHCP_STOP_IND:
12828 {
12829 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
12830 break;
12831 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]12832#ifdef FEATURE_WLAN_LPHB
12833 case WDA_LPHB_CONF_REQ:
12834 {
12835 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
12836 break;
12837 }
12838#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]12839 case WDA_ADD_PERIODIC_TX_PTRN_IND:
12840 {
12841 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
12842 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
12843 break;
12844 }
12845 case WDA_DEL_PERIODIC_TX_PTRN_IND:
12846 {
12847 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
12848 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
12849 break;
12850 }
12851
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12852#ifdef FEATURE_WLAN_BATCH_SCAN
12853 case WDA_SET_BATCH_SCAN_REQ:
12854 {
12855 WDA_ProcessSetBatchScanReq(pWDA,
12856 (tSirSetBatchScanReq *)pMsg->bodyptr);
12857 break;
12858 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]12859 case WDA_RATE_UPDATE_IND:
12860 {
12861 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
12862 break;
12863 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12864 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
12865 {
12866 WDA_ProcessTriggerBatchScanResultInd(pWDA,
12867 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
12868 break;
12869 }
12870 case WDA_STOP_BATCH_SCAN_IND:
12871 {
12872 WDA_ProcessStopBatchScanInd(pWDA,
12873 (tSirStopBatchScanInd *)pMsg->bodyptr);
12874 break;
12875 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]12876 case WDA_GET_BCN_MISS_RATE_REQ:
12877 WDA_ProcessGetBcnMissRateReq(pWDA,
12878 (tSirBcnMissRateReq *)pMsg->bodyptr);
12879 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]12880#endif
12881
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]12882 case WDA_HT40_OBSS_SCAN_IND:
12883 {
12884 WDA_ProcessHT40OBSSScanInd(pWDA,
12885 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
12886 break;
12887 }
12888 case WDA_HT40_OBSS_STOP_SCAN_IND:
12889 {
12890 WDA_ProcessHT40OBSSStopScanInd(pWDA,
12891 (tANI_U8*)pMsg->bodyptr);
12892 break;
12893 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12894 default:
12895 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]12896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12897 "No Handling for msg type %x in WDA "
12898 ,pMsg->type);
12899 /* Do Nothing? MSG Body should be freed at here */
12900 if(NULL != pMsg->bodyptr)
12901 {
12902 vos_mem_free(pMsg->bodyptr);
12903 }
12904 //WDA_VOS_ASSERT(0) ;
12905 }
12906 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12907 return status ;
12908}
12909
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12910/*
12911 * FUNCTION: WDA_LowLevelIndCallback
12912 * IND API callback from WDI, send Ind to PE
12913 */
12914void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
12915 void* pUserData )
12916{
12917 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
12918#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
12919 tSirRSSINotification rssiNotification;
12920#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12921 if(NULL == pWDA)
12922 {
12923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12924 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12925 VOS_ASSERT(0);
12926 return ;
12927 }
12928
12929 switch(wdiLowLevelInd->wdiIndicationType)
12930 {
12931 case WDI_RSSI_NOTIFICATION_IND:
12932 {
12933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12934 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12935#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
12936 rssiNotification.bReserved =
12937 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
12938 rssiNotification.bRssiThres1NegCross =
12939 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
12940 rssiNotification.bRssiThres1PosCross =
12941 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
12942 rssiNotification.bRssiThres2NegCross =
12943 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
12944 rssiNotification.bRssiThres2PosCross =
12945 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
12946 rssiNotification.bRssiThres3NegCross =
12947 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
12948 rssiNotification.bRssiThres3PosCross =
12949 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]12950 rssiNotification.avgRssi = (v_S7_t)
12951 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12952 WLANTL_BMPSRSSIRegionChangedNotification(
12953 pWDA->pVosContext,
12954 &rssiNotification);
12955#endif
12956 break ;
12957 }
12958 case WDI_MISSED_BEACON_IND:
12959 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]12960 tpSirSmeMissedBeaconInd pMissBeacInd =
12961 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12962 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12963 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12964 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]12965 if(NULL == pMissBeacInd)
12966 {
12967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12968 "%s: VOS MEM Alloc Failure", __func__);
12969 break;
12970 }
12971 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
12972 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
12973 pMissBeacInd->bssIdx =
12974 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
12975 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12976 break ;
12977 }
12978 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
12979 {
12980 /* TODO: Decode Ind and send Ind to PE */
12981 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12982 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
12983 break ;
12984 }
12985
12986 case WDI_MIC_FAILURE_IND:
12987 {
12988 tpSirSmeMicFailureInd pMicInd =
12989 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
12990
12991 if(NULL == pMicInd)
12992 {
12993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12994 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12995 break;
12996 }
12997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12998 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12999 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
13000 pMicInd->length = sizeof(tSirSmeMicFailureInd);
13001 vos_mem_copy(pMicInd->bssId,
13002 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
13003 sizeof(tSirMacAddr));
13004 vos_mem_copy(pMicInd->info.srcMacAddr,
13005 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
13006 sizeof(tSirMacAddr));
13007 vos_mem_copy(pMicInd->info.taMacAddr,
13008 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
13009 sizeof(tSirMacAddr));
13010 vos_mem_copy(pMicInd->info.dstMacAddr,
13011 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
13012 sizeof(tSirMacAddr));
13013 vos_mem_copy(pMicInd->info.rxMacAddr,
13014 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
13015 sizeof(tSirMacAddr));
13016 pMicInd->info.multicast =
13017 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
13018 pMicInd->info.keyId=
13019 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
13020 pMicInd->info.IV1=
13021 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
13022 vos_mem_copy(pMicInd->info.TSC,
13023 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13024 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
13025 (void *)pMicInd , 0) ;
13026 break ;
13027 }
13028 case WDI_FATAL_ERROR_IND:
13029 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]13030 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13031 /* TODO: Decode Ind and send Ind to PE */
13032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13033 "Received WDI_FATAL_ERROR_IND from WDI ");
13034 break ;
13035 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13036 case WDI_DEL_STA_IND:
13037 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13038 tpDeleteStaContext pDelSTACtx =
13039 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
13040
13041 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13042 "Received WDI_DEL_STA_IND from WDI ");
13043 if(NULL == pDelSTACtx)
13044 {
13045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13046 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13047 break;
13048 }
13049 vos_mem_copy(pDelSTACtx->addr2,
13050 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
13051 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13052 vos_mem_copy(pDelSTACtx->bssId,
13053 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
13054 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13055 pDelSTACtx->assocId =
13056 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
13057 pDelSTACtx->reasonCode =
13058 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
13059 pDelSTACtx->staId =
13060 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13061 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
13062 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13063 break ;
13064 }
13065 case WDI_COEX_IND:
13066 {
13067 tANI_U32 index;
13068 vos_msg_t vosMsg;
13069 tSirSmeCoexInd *pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
13070 if(NULL == pSmeCoexInd)
13071 {
13072 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13073 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13074 break;
13075 }
13076 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13077 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13078 /* Message Header */
13079 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
13080 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13081 /* Info from WDI Indication */
13082 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
13083 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
13084 {
13085 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
13086 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13087 /* VOS message wrapper */
13088 vosMsg.type = eWNI_SME_COEX_IND;
13089 vosMsg.bodyptr = (void *)pSmeCoexInd;
13090 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13091 /* Send message to SME */
13092 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13093 {
13094 /* free the mem and return */
13095 vos_mem_free((v_VOID_t *)pSmeCoexInd);
13096 }
13097 else
13098 {
13099 /* DEBUG */
13100 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13101 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
13102 pSmeCoexInd->coexIndType,
13103 pSmeCoexInd->coexIndData[0],
13104 pSmeCoexInd->coexIndData[1],
13105 pSmeCoexInd->coexIndData[2],
13106 pSmeCoexInd->coexIndData[3]);
13107 }
13108 break;
13109 }
13110 case WDI_TX_COMPLETE_IND:
13111 {
13112 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
13113 /* Calling TxCompleteAck Indication from wda context*/
13114 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13115 "Complete Indication received from HAL");
13116 if( pWDA->pAckTxCbFunc )
13117 {
13118 if( VOS_STATUS_SUCCESS !=
13119 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13120 {
13121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13122 "Tx Complete timeout Timer Stop Failed ");
13123 }
13124 pWDA->pAckTxCbFunc( pMac, wdiLowLevelInd->wdiIndicationData.tx_complete_status);
13125 pWDA->pAckTxCbFunc = NULL;
13126 }
13127 else
13128 {
13129 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13130 "Tx Complete Indication is received after timeout ");
13131 }
13132 break;
13133 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]13134 case WDI_P2P_NOA_START_IND :
13135 {
13136 tSirP2PNoaStart *pP2pNoaStart =
13137 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
13138
13139 if (NULL == pP2pNoaStart)
13140 {
13141 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13142 "Memory allocation failure, "
13143 "WDI_P2P_NOA_START_IND not forwarded");
13144 break;
13145 }
13146 pP2pNoaStart->status =
13147 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
13148 pP2pNoaStart->bssIdx =
13149 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
13150 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
13151 (void *)pP2pNoaStart , 0) ;
13152 break;
13153 }
13154
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]13155#ifdef FEATURE_WLAN_TDLS
13156 case WDI_TDLS_IND :
13157 {
13158 tSirTdlsInd *pTdlsInd =
13159 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
13160
13161 if (NULL == pTdlsInd)
13162 {
13163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13164 "Memory allocation failure, "
13165 "WDI_TDLS_IND not forwarded");
13166 break;
13167 }
13168 pTdlsInd->status =
13169 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
13170 pTdlsInd->assocId =
13171 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
13172 pTdlsInd->staIdx =
13173 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
13174 pTdlsInd->reasonCode =
13175 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
13176 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
13177 (void *)pTdlsInd , 0) ;
13178 break;
13179 }
13180#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13181 case WDI_P2P_NOA_ATTR_IND :
13182 {
13183 tSirP2PNoaAttr *pP2pNoaAttr =
13184 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13186 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13187 if (NULL == pP2pNoaAttr)
13188 {
13189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13190 "Memory allocation failure, "
13191 "WDI_P2P_NOA_ATTR_IND not forwarded");
13192 break;
13193 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13194 pP2pNoaAttr->index =
13195 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
13196 pP2pNoaAttr->oppPsFlag =
13197 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
13198 pP2pNoaAttr->ctWin =
13199 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
13200
13201 pP2pNoaAttr->uNoa1IntervalCnt =
13202 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
13203 pP2pNoaAttr->uNoa1Duration =
13204 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
13205 pP2pNoaAttr->uNoa1Interval =
13206 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
13207 pP2pNoaAttr->uNoa1StartTime =
13208 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13209 pP2pNoaAttr->uNoa2IntervalCnt =
13210 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
13211 pP2pNoaAttr->uNoa2Duration =
13212 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
13213 pP2pNoaAttr->uNoa2Interval =
13214 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
13215 pP2pNoaAttr->uNoa2StartTime =
13216 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13217 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
13218 (void *)pP2pNoaAttr , 0) ;
13219 break;
13220 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13221#ifdef FEATURE_WLAN_SCAN_PNO
13222 case WDI_PREF_NETWORK_FOUND_IND:
13223 {
13224 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13225 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
13226 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13227 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
13228 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
13229
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13231 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13232 if (NULL == pPrefNetworkFoundInd)
13233 {
13234 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13235 "Memory allocation failure, "
13236 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]13237 if (NULL !=
13238 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13239 {
13240 wpalMemoryFree(
13241 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
13242 );
13243 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13244 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13245 break;
13246 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13247 /* Message Header */
13248 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13249 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13250
13251 /* Info from WDI Indication */
13252 pPrefNetworkFoundInd->ssId.length =
13253 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13254 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13255 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
13256 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
13257 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]13258 if (NULL !=
13259 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
13260 {
13261 pPrefNetworkFoundInd->frameLength =
13262 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
13263 vos_mem_copy( pPrefNetworkFoundInd->data,
13264 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
13265 pPrefNetworkFoundInd->frameLength);
13266 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
13267 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
13268 }
13269 else
13270 {
13271 pPrefNetworkFoundInd->frameLength = 0;
13272 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13273 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13274 /* VOS message wrapper */
13275 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
13276 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
13277 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13278 /* Send message to SME */
13279 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13280 {
13281 /* free the mem and return */
13282 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
13283 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13284 break;
13285 }
13286#endif // FEATURE_WLAN_SCAN_PNO
13287
13288#ifdef WLAN_WAKEUP_EVENTS
13289 case WDI_WAKE_REASON_IND:
13290 {
13291 vos_msg_t vosMsg;
13292 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
13293 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
13294 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
13295
13296 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13297 "[WAKE_REASON WDI] WAKE_REASON_IND Type (0x%x) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
13298 wdiLowLevelInd->wdiIndicationType,
13299 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
13300 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
13301 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13302
13303 if (NULL == pWakeReasonInd)
13304 {
13305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13306 "Memory allocation failure, "
13307 "WDI_WAKE_REASON_IND not forwarded");
13308 break;
13309 }
13310
13311 vos_mem_zero(pWakeReasonInd, allocSize);
13312
13313 /* Message Header */
13314 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
13315 pWakeReasonInd->mesgLen = allocSize;
13316
13317 /* Info from WDI Indication */
13318 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
13319 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
13320 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
13321 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
13322 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
13323 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
13324 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
13325 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
13326
13327 /* VOS message wrapper */
13328 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
13329 vosMsg.bodyptr = (void *) pWakeReasonInd;
13330 vosMsg.bodyval = 0;
13331
13332 /* Send message to SME */
13333 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13334 {
13335 /* free the mem and return */
13336 vos_mem_free((v_VOID_t *) pWakeReasonInd);
13337 }
13338
13339 break;
13340 }
13341#endif // WLAN_WAKEUP_EVENTS
13342
13343 case WDI_TX_PER_HIT_IND:
13344 {
13345 vos_msg_t vosMsg;
13346 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
13347 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
13348 /* VOS message wrapper */
13349 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
13350 vosMsg.bodyptr = NULL;
13351 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13352 /* Send message to SME */
13353 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13354 {
13355 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
13356 }
13357 break;
13358 }
13359
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13360#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13361 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13362 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13363 vos_msg_t vosMsg;
13364 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13365
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13366 lphbInd =
13367 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
13368 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13369 {
13370 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13371 "%s: LPHB IND buffer alloc Fail", __func__);
13372 return ;
13373 }
13374
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13375 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13376 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13377 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13378 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13379 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13380 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
13381
13382 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13383 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13384 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
13385
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13386 vosMsg.type = eWNI_SME_LPHB_IND;
13387 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13388 vosMsg.bodyval = 0;
13389 /* Send message to SME */
13390 if (VOS_STATUS_SUCCESS !=
13391 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13392 {
13393 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13394 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]13395 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13396 }
13397 break;
13398 }
13399#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13400 case WDI_PERIODIC_TX_PTRN_FW_IND:
13401 {
13402 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13403 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
13404 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
13405 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
13406 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
13407 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
13408 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
13409
13410 break;
13411 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]13412
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]13413 case WDI_IBSS_PEER_INACTIVITY_IND:
13414 {
13415 tSirIbssPeerInactivityInd *pIbssInd =
13416 (tSirIbssPeerInactivityInd *)
13417 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
13418
13419 if (NULL == pIbssInd)
13420 {
13421 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13422 "Memory allocation failure, "
13423 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
13424 break;
13425 }
13426
13427 pIbssInd->bssIdx =
13428 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
13429 pIbssInd->staIdx =
13430 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
13431 vos_mem_copy(pIbssInd->peerAddr,
13432 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
13433 sizeof(tSirMacAddr));
13434 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
13435 break;
13436 }
13437
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13438#ifdef FEATURE_WLAN_BATCH_SCAN
13439 case WDI_BATCH_SCAN_RESULT_IND:
13440 {
13441 void *pBatchScanResult;
13442 void *pCallbackContext;
13443 tpAniSirGlobal pMac;
13444
13445 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13446 "Received WDI_BATCHSCAN_RESULT_IND from FW");
13447
13448 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13449 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13450 {
13451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13452 "%s:pWDA is NULL", __func__);
13453 VOS_ASSERT(0);
13454 return;
13455 }
13456
13457 pBatchScanResult =
13458 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
13459 if (NULL == pBatchScanResult)
13460 {
13461 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13462 "%s:Batch scan result from FW is null can't invoke HDD callback",
13463 __func__);
13464 VOS_ASSERT(0);
13465 return;
13466 }
13467
13468 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13469 if (NULL == pMac)
13470 {
13471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13472 "%s:pMac is NULL", __func__);
13473 VOS_ASSERT(0);
13474 return;
13475 }
13476
13477 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
13478 /*call hdd callback with set batch scan response data*/
13479 if(pMac->pmc.batchScanResultCallback)
13480 {
13481 pMac->pmc.batchScanResultCallback(pCallbackContext,
13482 pBatchScanResult);
13483 }
13484 else
13485 {
13486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13487 "%s:HDD callback is null", __func__);
13488 VOS_ASSERT(0);
13489 }
13490 break;
13491 }
13492#endif
13493
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]13494#ifdef FEATURE_WLAN_CH_AVOID
13495 case WDI_CH_AVOID_IND:
13496 {
13497 vos_msg_t vosMsg;
13498 tSirChAvoidIndType *chAvoidInd;
13499
13500 chAvoidInd =
13501 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
13502 if (NULL == chAvoidInd)
13503 {
13504 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13505 "%s: CH_AVOID IND buffer alloc Fail", __func__);
13506 return ;
13507 }
13508
13509 chAvoidInd->avoidRangeCount =
13510 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
13511 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
13512 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
13513 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
13514
13515 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13516 "%s : WDA CH avoid notification", __func__);
13517
13518 vosMsg.type = eWNI_SME_CH_AVOID_IND;
13519 vosMsg.bodyptr = chAvoidInd;
13520 vosMsg.bodyval = 0;
13521 /* Send message to SME */
13522 if (VOS_STATUS_SUCCESS !=
13523 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13524 {
13525 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13526 "post eWNI_SME_CH_AVOID_IND to SME Failed");
13527 vos_mem_free(chAvoidInd);
13528 }
13529 break;
13530 }
13531#endif /* FEATURE_WLAN_CH_AVOID */
13532
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13533#ifdef WLAN_FEATURE_LINK_LAYER_STATS
13534 case WDI_LL_STATS_RESULTS_IND:
13535 {
13536 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13537 tpAniSirGlobal pMac;
13538
13539 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13540 "Received WDI_LL_STATS_RESULTS_IND from FW");
13541
13542 /*sanity check*/
13543 if (NULL == pWDA)
13544 {
13545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13546 "%s:pWDA is NULL", __func__);
13547 VOS_ASSERT(0);
13548 return;
13549 }
13550
13551 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13552 (void *)wdiLowLevelInd->
13553 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13554 if (NULL == pLinkLayerStatsInd)
13555 {
13556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13557 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
13558 __func__);
13559 VOS_ASSERT(0);
13560 return;
13561 }
13562
13563 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13564 if (NULL == pMac)
13565 {
13566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13567 "%s:pMac is NULL", __func__);
13568 VOS_ASSERT(0);
13569 return;
13570 }
13571
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13572 /* call hdd callback with Link Layer Statistics.
13573 * vdev_id/ifacId in link_stats_results will be
13574 * used to retrieve the correct HDD context
13575 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13576 if (pMac->sme.pLinkLayerStatsIndCallback)
13577 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13578 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13579 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]13580 pLinkLayerStatsInd,
13581 wdiLowLevelInd->
13582 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]13583 }
13584 else
13585 {
13586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13587 "%s:HDD callback is null", __func__);
13588 }
13589 break;
13590 }
13591#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
13592
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]13593#ifdef WLAN_FEATURE_EXTSCAN
13594 case WDI_EXTSCAN_PROGRESS_IND:
13595 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
13596 case WDI_EXTSCAN_SCAN_RESULT_IND:
13597 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
13598 case WDI_EXTSCAN_SIGN_RSSI_RESULT_IND:
13599 {
13600 void *pEXTScanData;
13601 void *pCallbackContext;
13602 tpAniSirGlobal pMac;
13603 tANI_U16 indType;
13604
13605 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13606 "Received WDI_EXTSCAN Indications from FW");
13607 /*sanity check*/
13608 if (NULL == pWDA)
13609 {
13610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13611 "%s:pWDA is NULL", __func__);
13612 VOS_ASSERT(0);
13613 return;
13614 }
13615 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
13616 {
13617 indType = WDA_EXTSCAN_PROGRESS_IND;
13618
13619 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13620 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
13621 }
13622 if (wdiLowLevelInd->wdiIndicationType ==
13623 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
13624 {
13625 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
13626
13627 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13628 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
13629 }
13630 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
13631 {
13632 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
13633
13634 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13635 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
13636 }
13637 if (wdiLowLevelInd->wdiIndicationType ==
13638 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
13639 {
13640 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
13641
13642 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13643 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
13644 }
13645 if (wdiLowLevelInd->wdiIndicationType ==
13646 WDI_EXTSCAN_SIGN_RSSI_RESULT_IND)
13647 {
13648 indType = WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND;
13649
13650 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13651 "WDI_EXTSCAN Indication is WDA_EXTSCAN_SIGNF_RSSI_RESULT_IND");
13652 }
13653
13654 pEXTScanData =
13655 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
13656 if (NULL == pEXTScanData)
13657 {
13658 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13659 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
13660 __func__);
13661 VOS_ASSERT(0);
13662 return;
13663 }
13664
13665 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13666 if (NULL == pMac)
13667 {
13668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13669 "%s:pMac is NULL", __func__);
13670 VOS_ASSERT(0);
13671 return;
13672 }
13673
13674 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
13675
13676 if(pMac->sme.pEXTScanIndCb)
13677 {
13678 pMac->sme.pEXTScanIndCb(pCallbackContext,
13679 indType,
13680 pEXTScanData);
13681 }
13682 else
13683 {
13684 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13685 "%s:HDD callback is null", __func__);
13686 }
13687 break;
13688 }
13689#endif /* WLAN_FEATURE_EXTSCAN */
13690
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13691 default:
13692 {
13693 /* TODO error */
13694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13695 "Received UNKNOWN Indication from WDI ");
13696 }
13697 }
13698 return ;
13699}
13700
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13701/*
13702 * BA related processing in WDA.
13703 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13704void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
13705 void* pUserData)
13706{
13707 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13708 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13709 if(NULL == pWdaParams)
13710 {
13711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13712 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13713 VOS_ASSERT(0) ;
13714 return ;
13715 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13716 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13717 vos_mem_free(pWdaParams->wdaMsgParam) ;
13718 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13719 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13721 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13722 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
13723 {
13724 tANI_U8 i = 0 ;
13725 tBaActivityInd *baActivityInd = NULL ;
13726 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
13727 tANI_U8 allocSize = sizeof(tBaActivityInd)
13728 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
13729 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
13730 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13731 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13732 if(NULL == baActivityInd)
13733 {
13734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13735 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13736 VOS_ASSERT(0) ;
13737 return;
13738 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13739 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
13740 sizeof(tSirMacAddr)) ;
13741 baActivityInd->baCandidateCnt = baCandidateCount ;
13742
13743 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
13744 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
13745
13746 for(i = 0 ; i < baCandidateCount ; i++)
13747 {
13748 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13749 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
13750 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13751 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
13752 {
13753 baCandidate->baInfo[tid].fBaEnable =
13754 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
13755 baCandidate->baInfo[tid].startingSeqNum =
13756 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
13757 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]13758 wdiBaCandidate++ ;
13759 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13760 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13761 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
13762 }
13763 else
13764 {
13765 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13766 "BA Trigger RSP with Failure received ");
13767 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13768 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13769}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13770
13771
13772/*
13773 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
13774 * during MCC
13775 */
13776void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
13777{
13778 wpt_uint32 enabled;
13779 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
13780 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
13781 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
13782
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]13783 if (NULL == pMac )
13784 {
13785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13786 "%s: Invoked with invalid MAC context ", __func__ );
13787 VOS_ASSERT(0);
13788 return;
13789 }
13790
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13791 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
13792 != eSIR_SUCCESS)
13793 {
13794 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13795 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
13796 return;
13797 }
13798
13799 if(!enabled)
13800 {
13801 return;
13802 }
13803
13804 if(NULL == pWDA)
13805 {
13806 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13807 "%s:WDA context is NULL", __func__);
13808 VOS_ASSERT(0);
13809 return;
13810 }
13811
13812 if(activate)
13813 {
13814 if( VOS_STATUS_SUCCESS !=
13815 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13816 {
13817 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13818 "Traffic Stats Timer Start Failed ");
13819 return;
13820 }
13821 WDI_DS_ActivateTrafficStats();
13822 }
13823 else
13824 {
13825 WDI_DS_DeactivateTrafficStats();
13826 WDI_DS_ClearTrafficStats();
13827
13828 if( VOS_STATUS_SUCCESS !=
13829 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13830 {
13831 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13832 "Traffic Stats Timer Stop Failed ");
13833 return;
13834 }
13835 }
13836}
13837
13838/*
13839 * Traffic Stats Timer handler
13840 */
13841void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
13842{
13843 WDI_Status wdiStatus;
13844 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
13845 WDI_TrafficStatsIndType trafficStatsIndParams;
13846 wpt_uint32 length, enabled;
13847 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13848
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]13849 if (NULL == pMac )
13850 {
13851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13852 "%s: Invoked with invalid MAC context ", __func__ );
13853 VOS_ASSERT(0);
13854 return;
13855 }
13856
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13857 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
13858 != eSIR_SUCCESS)
13859 {
13860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13861 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
13862 return;
13863 }
13864
13865 if(!enabled)
13866 {
13867 WDI_DS_DeactivateTrafficStats();
13868 return;
13869 }
13870
13871 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
13872
13873 if(pWdiTrafficStats != NULL)
13874 {
13875 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
13876 trafficStatsIndParams.length = length;
13877 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]13878 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]13879 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
13880 trafficStatsIndParams.pUserData = pWDA;
13881
13882 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
13883
13884 if(WDI_STATUS_PENDING == wdiStatus)
13885 {
13886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13887 "Pending received for %s:%d ",__func__,__LINE__ );
13888 }
13889 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
13890 {
13891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13892 "Failure in %s:%d ",__func__,__LINE__ );
13893 }
13894
13895 WDI_DS_ClearTrafficStats();
13896 }
13897 else
13898 {
13899 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13900 "pWdiTrafficStats is Null");
13901 }
13902
13903 if( VOS_STATUS_SUCCESS !=
13904 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
13905 {
13906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13907 "Traffic Stats Timer Start Failed ");
13908 return;
13909 }
13910}
13911
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13912/*
13913 * BA Activity check timer handler
13914 */
13915void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
13916{
13917 tANI_U8 curSta = 0 ;
13918 tANI_U8 tid = 0 ;
13919 tANI_U8 size = 0 ;
13920 tANI_U8 baCandidateCount = 0 ;
13921 tANI_U8 newBaCandidate = 0 ;
13922 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
13923
13924 if(NULL == pWDA)
13925 {
13926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13927 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13928 VOS_ASSERT(0);
13929 return ;
13930 }
13931 if(WDA_MAX_STA < pWDA->wdaMaxSta)
13932 {
13933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13934 "Inconsistent STA entries in WDA");
13935 VOS_ASSERT(0) ;
13936 }
13937 /* walk through all STA entries and find out TX packet count */
13938 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
13939 {
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]13940#ifdef WLAN_SOFTAP_VSTA_FEATURE
13941 // We can only do BA on "hard" STAs.
13942 if (!(IS_HWSTA_IDX(curSta)))
13943 {
13944 continue;
13945 }
13946#endif //WLAN_SOFTAP_VSTA_FEATURE
13947 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
13948 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]13949 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13950 tANI_U32 txPktCount = 0 ;
13951 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13952 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]13953 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
13954 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13955 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
13956 curSta, tid, &txPktCount)))
13957 {
13958#if 0
13959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
13960 "************* %d:%d, %d ",curSta, txPktCount,
13961 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
13962#endif
13963 if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]13964 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13965 && (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
13966 curSta, tid)))
13967 {
13968 /* get prepare for sending message to HAL */
13969 //baCandidate[baCandidateCount].staIdx = curSta ;
13970 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
13971 newBaCandidate = WDA_ENABLE_BA ;
13972 }
13973 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
13974 }
13975 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13976 /* fill the entry for all the sta with given TID's */
13977 if(WDA_ENABLE_BA == newBaCandidate)
13978 {
13979 /* move to next BA candidate */
13980 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
13981 size += sizeof(WDI_TriggerBAReqCandidateType) ;
13982 baCandidateCount++ ;
13983 newBaCandidate = WDA_DISABLE_BA ;
13984 }
13985 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13986 /* prepare and send message to hal */
13987 if( 0 < baCandidateCount)
13988 {
13989 WDI_Status status = WDI_STATUS_SUCCESS ;
13990 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
13991 tWDA_ReqParams *pWdaParams =
13992 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13993 if(NULL == pWdaParams)
13994 {
13995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13996 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13997 VOS_ASSERT(0) ;
13998 return;
13999 }
14000 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
14001 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
14002 if(NULL == wdiTriggerBaReq)
14003 {
14004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14005 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14006 VOS_ASSERT(0) ;
14007 vos_mem_free(pWdaParams);
14008 return;
14009 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14010 do
14011 {
14012 WDI_TriggerBAReqinfoType *triggerBaInfo =
14013 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
14014 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
14015 /* TEMP_FIX: Need to see if WDI need check for assoc session for
14016 * for each request */
14017 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
14018 triggerBaInfo->ucBASessionID = 0;
14019 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
14020 } while(0) ;
14021 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
14022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14023 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14024 pWdaParams->pWdaContext = pWDA;
14025 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
14026 pWdaParams->wdaMsgParam = NULL;
14027 status = WDI_TriggerBAReq(wdiTriggerBaReq,
14028 WDA_TriggerBaReqCallback, pWdaParams) ;
14029 if(IS_WDI_STATUS_FAILURE(status))
14030 {
14031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14032 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
14033 vos_mem_free(pWdaParams->wdaMsgParam) ;
14034 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14035 vos_mem_free(pWdaParams) ;
14036 }
14037 }
14038 else
14039 {
14040 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
14041 "There is no TID for initiating BA");
14042 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14043 if( VOS_STATUS_SUCCESS !=
14044 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14045 {
14046 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14047 "BA Activity Timer Stop Failed ");
14048 return ;
14049 }
14050 if( VOS_STATUS_SUCCESS !=
14051 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
14052 {
14053 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14054 "BA Activity Timer Start Failed ");
14055 return;
14056 }
14057 return ;
14058}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14059/*
14060 * WDA common routine to create timer used by WDA.
14061 */
14062static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
14063{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14064 VOS_STATUS status = VOS_STATUS_SUCCESS ;
14065 tANI_U32 val = 0 ;
14066 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
14067
14068 if(NULL == pMac)
14069 {
14070 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14071 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14072 VOS_ASSERT(0);
14073 return VOS_STATUS_E_FAILURE;
14074 }
14075 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
14076 != eSIR_SUCCESS)
14077 {
14078 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14079 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
14080 return VOS_STATUS_E_FAILURE;
14081 }
14082 val = SYS_MS_TO_TICKS(val) ;
14083
14084 /* BA activity check timer */
14085 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
14086 "BA Activity Check timer", WDA_TimerHandler,
14087 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
14088 if(status != TX_SUCCESS)
14089 {
14090 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14091 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14092 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14093 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14094 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14095 /* Tx Complete Timeout timer */
14096 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
14097 "Tx Complete Check timer", WDA_TimerHandler,
14098 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14099 if(status != TX_SUCCESS)
14100 {
14101 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14102 "Unable to create Tx Complete Timeout timer");
14103 /* Destroy timer of BA activity check timer */
14104 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14105 if(status != TX_SUCCESS)
14106 {
14107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14108 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14109 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14110 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14111 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14112 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14113
14114 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
14115
14116 /* Traffic Stats timer */
14117 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
14118 "Traffic Stats timer", WDA_TimerHandler,
14119 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
14120 if(status != TX_SUCCESS)
14121 {
14122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14123 "Unable to create traffic stats timer");
14124 /* Destroy timer of BA activity check timer */
14125 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14126 if(status != TX_SUCCESS)
14127 {
14128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14129 "Unable to Destroy BA activity timer");
14130 }
14131 /* Destroy timer of tx complete timer */
14132 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14133 if(status != TX_SUCCESS)
14134 {
14135 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14136 "Unable to Tx complete timer");
14137 }
14138 return VOS_STATUS_E_FAILURE ;
14139 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]14140 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14141}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14142/*
14143 * WDA common routine to destroy timer used by WDA.
14144 */
14145static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
14146{
14147 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14148 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
14149 if(status != TX_SUCCESS)
14150 {
14151 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14152 "Unable to Destroy Tx Complete Timeout timer");
14153 return eSIR_FAILURE ;
14154 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14155 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
14156 if(status != TX_SUCCESS)
14157 {
14158 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14159 "Unable to Destroy BA activity timer");
14160 return eSIR_FAILURE ;
14161 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]14162 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
14163 if(status != TX_SUCCESS)
14164 {
14165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14166 "Unable to Destroy traffic stats timer");
14167 return eSIR_FAILURE ;
14168 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14169 return eSIR_SUCCESS ;
14170}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14171/*
14172 * WDA timer handler.
14173 */
14174void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
14175{
14176 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
14177 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14178 /*
14179 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
14180 */
14181 wdaMsg.type = timerInfo ;
14182 wdaMsg.bodyptr = NULL;
14183 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14184 /* post the message.. */
14185 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
14186 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
14187 {
14188 vosStatus = VOS_STATUS_E_BADMSG;
14189 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14190}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14191/*
14192 * WDA Tx Complete timeout Indication.
14193 */
14194void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
14195{
14196 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14197 if( pWDA->pAckTxCbFunc )
14198 {
14199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14200 "TxComplete timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14201 pWDA->pAckTxCbFunc( pMac, 0);
14202 pWDA->pAckTxCbFunc = NULL;
14203 }
14204 else
14205 {
14206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14207 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14208 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14209}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14210/*
14211 * WDA Set REG Domain to VOS NV
14212 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14213eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
14214 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14215{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]14216 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14217 {
14218 return eHAL_STATUS_INVALID_PARAMETER;
14219 }
14220 return eHAL_STATUS_SUCCESS;
14221}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14222
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14223#ifdef FEATURE_WLAN_SCAN_PNO
14224/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14225 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14226 *
14227 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14228void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14229{
14230 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14231 tSirPNOScanReq *pPNOScanReqParams;
14232
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14233 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14234 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14235 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14236 {
14237 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14238 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14239 VOS_ASSERT(0) ;
14240 return ;
14241 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14242
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14243 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14244 if(pPNOScanReqParams->statusCallback)
14245 {
14246 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14247 (status == WDI_STATUS_SUCCESS) ?
14248 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
14249 }
14250
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14251 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14252 vos_mem_free(pWdaParams->wdaMsgParam);
14253 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14254
14255 return ;
14256}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14257/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14258 * FUNCTION: WDA_PNOScanReqCallback
14259 * Free memory.
14260 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
14261 */
14262void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14263{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14264 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14265 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14266
14267 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14268 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14269
14270 if(NULL == pWdaParams)
14271 {
14272 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14273 "%s: pWdaParams received NULL", __func__);
14274 VOS_ASSERT(0);
14275 return;
14276 }
14277
14278 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14279 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14280 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
14281 if(pPNOScanReqParams->statusCallback)
14282 {
14283 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14284 VOS_STATUS_E_FAILURE);
14285 }
14286
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14287 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14288 vos_mem_free(pWdaParams->wdaMsgParam);
14289 vos_mem_free(pWdaParams);
14290 }
14291
14292 return;
14293}
14294/*
14295 * FUNCTION: WDA_UpdateScanParamsRespCallback
14296 *
14297 */
14298void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
14299{
14300 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14302 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14303 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14304 {
14305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14306 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14307 VOS_ASSERT(0) ;
14308 return ;
14309 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14310
14311 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14312 vos_mem_free(pWdaParams->wdaMsgParam);
14313 vos_mem_free(pWdaParams);
14314
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14315 return ;
14316}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14317/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14318 * FUNCTION: WDA_UpdateScanParamsReqCallback
14319 * Free memory.
14320 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
14321 */
14322void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14323{
14324 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14325
14326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14327 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14328
14329 if(NULL == pWdaParams)
14330 {
14331 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14332 "%s: pWdaParams received NULL", __func__);
14333 VOS_ASSERT(0);
14334 return;
14335 }
14336
14337 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14338 {
14339 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14340 vos_mem_free(pWdaParams->wdaMsgParam);
14341 vos_mem_free(pWdaParams);
14342 }
14343
14344 return;
14345}
14346/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14347 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14348 * Request to WDI to set Preferred Network List.Offload
14349 */
14350VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
14351 tSirPNOScanReq *pPNOScanReqParams)
14352{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14353 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14354 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
14355 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
14356 tWDA_ReqParams *pWdaParams ;
14357 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14359 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14360 if(NULL == pwdiPNOScanReqInfo)
14361 {
14362 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14363 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14364 VOS_ASSERT(0);
14365 return VOS_STATUS_E_NOMEM;
14366 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14367 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14368 if(NULL == pWdaParams)
14369 {
14370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14371 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14372 VOS_ASSERT(0);
14373 vos_mem_free(pwdiPNOScanReqInfo);
14374 return VOS_STATUS_E_NOMEM;
14375 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14376 //
14377 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
14378 //
14379 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
14380 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14381 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
14382 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
14383 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14384 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
14385 {
14386 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
14387 &pPNOScanReqParams->aNetworks[i],
14388 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
14389 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14390 /*Scan timer intervals*/
14391 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
14392 &pPNOScanReqParams->scanTimers,
14393 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14394 /*Probe template for 2.4GHz band*/
14395 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
14396 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14397 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14398 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
14399 pPNOScanReqParams->p24GProbeTemplate,
14400 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14401 /*Probe template for 5GHz band*/
14402 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
14403 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14404 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14405 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
14406 pPNOScanReqParams->p5GProbeTemplate,
14407 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14408 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
14409 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14410
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14411 /* Store Params pass it to WDI */
14412 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
14413 pWdaParams->pWdaContext = pWDA;
14414 /* Store param pointer as passed in by caller */
14415 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14416 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14417 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14418 if(IS_WDI_STATUS_FAILURE(status))
14419 {
14420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14421 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]14422 if(pPNOScanReqParams->statusCallback)
14423 {
14424 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
14425 VOS_STATUS_E_FAILURE);
14426 }
14427
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14428 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14429 vos_mem_free(pWdaParams->wdaMsgParam);
14430 pWdaParams->wdaWdiApiMsgParam = NULL;
14431 pWdaParams->wdaMsgParam = NULL;
14432 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14433 return CONVERT_WDI2VOS_STATUS(status) ;
14434}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14435
14436#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14437
14438void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
14439{
14440 /*Convert the CSR Auth types to WDI Auth types */
14441 switch (csrAuthType)
14442 {
14443 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
14444 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14445 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14446#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14447 case eCSR_AUTH_TYPE_CCKM_WPA:
14448 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
14449 break;
14450#endif
14451 case eCSR_AUTH_TYPE_WPA:
14452 *AuthType = eWDA_AUTH_TYPE_WPA;
14453 break;
14454 case eCSR_AUTH_TYPE_WPA_PSK:
14455 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
14456 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14457#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14458 case eCSR_AUTH_TYPE_CCKM_RSN:
14459 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
14460 break;
14461#endif
14462 case eCSR_AUTH_TYPE_RSN:
14463 *AuthType = eWDA_AUTH_TYPE_RSN;
14464 break;
14465 case eCSR_AUTH_TYPE_RSN_PSK:
14466 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
14467 break;
14468#if defined WLAN_FEATURE_VOWIFI_11R
14469 case eCSR_AUTH_TYPE_FT_RSN:
14470 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
14471 break;
14472 case eCSR_AUTH_TYPE_FT_RSN_PSK:
14473 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
14474 break;
14475#endif
14476#ifdef FEATURE_WLAN_WAPI
14477 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
14478 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
14479 break;
14480 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
14481 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
14482 break;
14483#endif /* FEATURE_WLAN_WAPI */
14484 case eCSR_AUTH_TYPE_SHARED_KEY:
14485 case eCSR_AUTH_TYPE_AUTOSWITCH:
14486 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
14487 break;
14488#if 0
14489 case eCSR_AUTH_TYPE_SHARED_KEY:
14490 *AuthType = eWDA_AUTH_TYPE_SHARED_KEY;
14491 break;
14492 case eCSR_AUTH_TYPE_AUTOSWITCH:
14493 *AuthType = eWDA_AUTH_TYPE_AUTOSWITCH;
14494#endif
14495 default:
14496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14497 "%s: Unknown Auth Type", __func__);
14498 break;
14499 }
14500}
14501void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
14502{
14503 switch (csrEncrType)
14504 {
14505 case eCSR_ENCRYPT_TYPE_NONE:
14506 *EncrType = WDI_ED_NONE;
14507 break;
14508 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
14509 case eCSR_ENCRYPT_TYPE_WEP40:
14510 *EncrType = WDI_ED_WEP40;
14511 break;
14512 case eCSR_ENCRYPT_TYPE_WEP104:
14513 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
14514 *EncrType = WDI_ED_WEP104;
14515 break;
14516 case eCSR_ENCRYPT_TYPE_TKIP:
14517 *EncrType = WDI_ED_TKIP;
14518 break;
14519 case eCSR_ENCRYPT_TYPE_AES:
14520 *EncrType = WDI_ED_CCMP;
14521 break;
14522#ifdef WLAN_FEATURE_11W
14523 case eCSR_ENCRYPT_TYPE_AES_CMAC:
14524 *EncrType = WDI_ED_AES_128_CMAC;
14525 break;
14526#endif
14527#ifdef FEATURE_WLAN_WAPI
14528 case eCSR_ENCRYPT_TYPE_WPI:
14529 *EncrType = WDI_ED_WPI;
14530 break;
14531#endif
14532 case eCSR_ENCRYPT_TYPE_ANY:
14533 *EncrType = WDI_ED_ANY;
14534 break;
14535
14536 default:
14537 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14538 "%s: Unknown Encryption Type", __func__);
14539 break;
14540 }
14541}
14542
14543/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14544 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14545 * Request to WDI to set Roam Offload Scan
14546 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14547VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14548 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
14549{
14550 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14551 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
14552 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14553 tWDA_ReqParams *pWdaParams ;
14554 v_U8_t csrAuthType;
14555 WDI_RoamNetworkType *pwdiRoamNetworkType;
14556 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
14557 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14558 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14559 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14560 {
14561 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14562 "%s: VOS MEM Alloc Failure", __func__);
14563 VOS_ASSERT(0);
14564 return VOS_STATUS_E_NOMEM;
14565 }
14566 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14567 if (NULL == pWdaParams)
14568 {
14569 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14570 "%s: VOS MEM Alloc Failure", __func__);
14571 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14572 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14573 return VOS_STATUS_E_NOMEM;
14574 }
14575
14576 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14577 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14578 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14579 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
14580 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14581 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
14582 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
14583 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
14584 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
14585 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
14586 sizeof(pwdiRoamNetworkType->currAPbssid));
14587 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
14588 csrAuthType);
14589 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
14590 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
14591 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
14592 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
14593 pwdiRoamOffloadScanInfo->LookupThreshold =
14594 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]14595 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
14596 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14597 pwdiRoamOffloadScanInfo->RoamRssiDiff =
14598 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]14599 pwdiRoamOffloadScanInfo->MAWCEnabled =
14600 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14601 pwdiRoamOffloadScanInfo->Command =
14602 pRoamOffloadScanReqParams->Command ;
14603 pwdiRoamOffloadScanInfo->StartScanReason =
14604 pRoamOffloadScanReqParams->StartScanReason ;
14605 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
14606 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
14607 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
14608 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
14609 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
14610 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
14611 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
14612 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
14613 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
14614 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14615 pwdiRoamOffloadScanInfo->IsESEEnabled =
14616 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14617 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
14618 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
14619 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
14620 pwdiRoamNetworkType->ssId.ucLength =
14621 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
14622 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
14623 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
14624 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
14625 pwdiRoamNetworkType->ChannelCount =
14626 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
14627 pwdiRoamOffloadScanInfo->ChannelCacheType =
14628 pRoamOffloadScanReqParams->ChannelCacheType;
14629 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
14630 pRoamOffloadScanReqParams->ValidChannelList,
14631 pRoamOffloadScanReqParams->ValidChannelCount);
14632 pwdiRoamOffloadScanInfo->ValidChannelCount =
14633 pRoamOffloadScanReqParams->ValidChannelCount;
14634 pwdiRoamOffloadScanInfo->us24GProbeSize =
14635 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14636 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14637 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
14638 pRoamOffloadScanReqParams->p24GProbeTemplate,
14639 pwdiRoamOffloadScanInfo->us24GProbeSize);
14640 pwdiRoamOffloadScanInfo->us5GProbeSize =
14641 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
14642 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
14643 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
14644 pRoamOffloadScanReqParams->p5GProbeTemplate,
14645 pwdiRoamOffloadScanInfo->us5GProbeSize);
14646 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
14647 pRoamOffloadScanReqParams->MDID.mdiePresent;
14648 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
14649 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14650 pwdiRoamOffloadScanInfo->nProbes =
14651 pRoamOffloadScanReqParams->nProbes;
14652 pwdiRoamOffloadScanInfo->HomeAwayTime =
14653 pRoamOffloadScanReqParams->HomeAwayTime;
14654 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14655 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14656 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14657 pWdaParams->pWdaContext = pWDA;
14658 /* Store param pointer as passed in by caller */
14659 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]14660 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14661 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
14662 if(IS_WDI_STATUS_FAILURE(status))
14663 {
14664 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14665 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
14666 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14667 vos_mem_free(pWdaParams->wdaMsgParam);
14668 pWdaParams->wdaWdiApiMsgParam = NULL;
14669 pWdaParams->wdaMsgParam = NULL;
14670 }
14671 return CONVERT_WDI2VOS_STATUS(status) ;
14672}
14673#endif
14674
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14675/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14676 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14677 *
14678 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14679void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14680{
14681 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14682
14683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14684 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14685
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14686 if(NULL == pWdaParams)
14687 {
14688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14689 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14690 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14691 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]14692 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14693
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14694 vos_mem_free(pWdaParams->wdaMsgParam) ;
14695 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14696 vos_mem_free(pWdaParams) ;
14697
14698 return ;
14699}
14700/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14701 * FUNCTION: WDA_RssiFilterReqCallback
14702 * Free memory.
14703 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
14704 */
14705void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
14706{
14707 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14708
14709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14710 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14711
14712 if(NULL == pWdaParams)
14713 {
14714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14715 "%s: pWdaParams received NULL", __func__);
14716 VOS_ASSERT(0);
14717 return;
14718 }
14719
14720 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14721 {
14722 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14723 vos_mem_free(pWdaParams->wdaMsgParam);
14724 vos_mem_free(pWdaParams);
14725 }
14726
14727 return;
14728}
14729/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14730 * FUNCTION: WDA_ProcessSetPreferredNetworkList
14731 * Request to WDI to set Preferred Network List.Offload
14732 */
14733VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
14734 tSirSetRSSIFilterReq* pRssiFilterParams)
14735{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14736 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14737 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
14738 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
14739 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14740 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14741 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14742 if(NULL == pwdiSetRssiFilterReqInfo)
14743 {
14744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14745 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14746 VOS_ASSERT(0);
14747 return VOS_STATUS_E_NOMEM;
14748 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14749 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14750 if(NULL == pWdaParams)
14751 {
14752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14753 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14754 VOS_ASSERT(0);
14755 vos_mem_free(pwdiSetRssiFilterReqInfo);
14756 return VOS_STATUS_E_NOMEM;
14757 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14758 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14759 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
14760 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14761
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14762 /* Store Params pass it to WDI */
14763 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
14764 pWdaParams->pWdaContext = pWDA;
14765 /* Store param pointer as passed in by caller */
14766 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14767 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14768 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14769 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14770 if(IS_WDI_STATUS_FAILURE(status))
14771 {
14772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14773 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
14774 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14775 vos_mem_free(pWdaParams->wdaMsgParam);
14776 pWdaParams->wdaWdiApiMsgParam = NULL;
14777 pWdaParams->wdaMsgParam = NULL;
14778 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14779 return CONVERT_WDI2VOS_STATUS(status) ;
14780}
14781
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14782/*
14783 * FUNCTION: WDA_ProcessUpdateScanParams
14784 * Request to WDI to update Scan Parameters
14785 */
14786VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
14787 tSirUpdateScanParams *pUpdateScanParams)
14788{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]14789 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14790 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
14791 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
14792 sizeof(WDI_UpdateScanParamsInfoType)) ;
14793 tWDA_ReqParams *pWdaParams ;
14794 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14795 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14796 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14797 if(NULL == wdiUpdateScanParamsInfoType)
14798 {
14799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14800 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14801 VOS_ASSERT(0);
14802 return VOS_STATUS_E_NOMEM;
14803 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14804 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14805 if ( NULL == pWdaParams )
14806 {
14807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14808 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14809 VOS_ASSERT(0);
14810 vos_mem_free(wdiUpdateScanParamsInfoType);
14811 return VOS_STATUS_E_NOMEM;
14812 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14813 //
14814 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
14815 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14816 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14817 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
14818 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
14819 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]14820 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14821 pUpdateScanParams->b11dEnabled,
14822 pUpdateScanParams->b11dResolved,
14823 pUpdateScanParams->ucChannelCount,
14824 pUpdateScanParams->usPassiveMinChTime,
14825 pUpdateScanParams->usPassiveMaxChTime,
14826 pUpdateScanParams->usActiveMinChTime,
14827 pUpdateScanParams->usActiveMaxChTime,
14828 sizeof(tSirUpdateScanParams),
14829 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
14830
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14831 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
14832 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14833 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
14834 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14835 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
14836 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14837 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
14838 pUpdateScanParams->usActiveMaxChTime;
14839 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
14840 pUpdateScanParams->usActiveMinChTime;
14841 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
14842 pUpdateScanParams->usPassiveMaxChTime;
14843 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
14844 pUpdateScanParams->usPassiveMinChTime;
14845
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14846 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]14847 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
14848 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14849
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14850 for ( i = 0; i <
14851 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
14852 i++)
14853 {
14854 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14855 "Update Scan Parameters channel: %d",
14856 pUpdateScanParams->aChannels[i]);
14857
14858 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
14859 pUpdateScanParams->aChannels[i];
14860 }
14861
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14862 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
14863 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]14864
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14865 /* Store Params pass it to WDI */
14866 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
14867 pWdaParams->pWdaContext = pWDA;
14868 /* Store param pointer as passed in by caller */
14869 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]14870
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14871
14872
14873 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14874 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14875 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14876 if(IS_WDI_STATUS_FAILURE(status))
14877 {
14878 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14879 "Failure in Update Scan Params EQ WDI API, free all the memory " );
14880 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14881 vos_mem_free(pWdaParams->wdaMsgParam);
14882 vos_mem_free(pWdaParams);
14883 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14884 return CONVERT_WDI2VOS_STATUS(status) ;
14885}
14886#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14887
14888#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
14889/*
14890 * FUNCTION: WDA_RoamOffloadScanReqCallback
14891 *
14892 */
14893void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
14894{
14895 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14896 vos_msg_t vosMsg;
14897 wpt_uint8 reason = 0;
14898
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]14899 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14900 "<------ %s " ,__func__);
14901 if (NULL == pWdaParams)
14902 {
14903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14904 "%s: pWdaParams received NULL", __func__);
14905 VOS_ASSERT(0) ;
14906 return ;
14907 }
14908 if ( pWdaParams != NULL )
14909 {
14910 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
14911 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14912 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14913 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14914 }
14915 if ( pWdaParams->wdaMsgParam != NULL)
14916 {
14917 vos_mem_free(pWdaParams->wdaMsgParam);
14918 }
14919
14920 vos_mem_free(pWdaParams) ;
14921 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14922 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
14923 vosMsg.bodyptr = NULL;
14924 if (WDI_STATUS_SUCCESS != status)
14925 {
14926 reason = 0;
14927 }
14928 vosMsg.bodyval = reason;
14929 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
14930 {
14931 /* free the mem and return */
14932 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]14933 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]14934 }
14935
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]14936 return ;
14937}
14938#endif
14939
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14940/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14941 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14942 *
14943 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14944void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14945{
14946 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14947
14948 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14949 "<------ %s " ,__func__);
14950
14951 if(NULL == pWdaParams)
14952 {
14953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14954 "%s: pWdaParams received NULL", __func__);
14955 VOS_ASSERT(0);
14956 return;
14957 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14958
14959 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14960 vos_mem_free(pWdaParams->wdaMsgParam);
14961 vos_mem_free(pWdaParams);
14962
14963 return;
14964}
14965/*
14966 * FUNCTION: WDA_SetPowerParamsReqCallback
14967 * Free memory.
14968 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
14969 */
14970void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
14971{
14972 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14973
14974 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14975 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
14976
14977 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14978 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14980 "%s: pWdaParams received NULL", __func__);
14981 VOS_ASSERT(0);
14982 return;
14983 }
14984
14985 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14986 {
14987 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14988 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14989 vos_mem_free(pWdaParams);
14990 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14991
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]14992 return;
14993}
14994
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14995#ifdef WLAN_FEATURE_PACKET_FILTERING
14996/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]14997 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14998 *
14999 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15000void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15001 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
15002 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15003{
15004 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15006 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15007 if(NULL == pWdaParams)
15008 {
15009 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15010 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15011 VOS_ASSERT(0) ;
15012 return ;
15013 }
15014
15015 vos_mem_free(pWdaParams->wdaMsgParam) ;
15016 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15017 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15018 //print a msg, nothing else to do
15019 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15020 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15021 return ;
15022}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15023/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15024 * FUNCTION: WDA_8023MulticastListReqCallback
15025 * Free memory.
15026 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
15027 */
15028void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
15029{
15030 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15031
15032 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15033 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15034
15035 if(NULL == pWdaParams)
15036 {
15037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15038 "%s: pWdaParams received NULL", __func__);
15039 VOS_ASSERT(0);
15040 return;
15041 }
15042
15043 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15044 {
15045 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15046 vos_mem_free(pWdaParams->wdaMsgParam);
15047 vos_mem_free(pWdaParams);
15048 }
15049
15050 return;
15051}
15052/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15053 * FUNCTION: WDA_Process8023MulticastListReq
15054 * Request to WDI to add 8023 Multicast List
15055 */
15056VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
15057 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
15058{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15059 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15060 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
15061 tWDA_ReqParams *pWdaParams ;
15062 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15064 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15065 pwdiFltPktSetMcListReqParamsType =
15066 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
15067 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
15068 ) ;
15069 if(NULL == pwdiFltPktSetMcListReqParamsType)
15070 {
15071 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15072 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15073 return VOS_STATUS_E_NOMEM;
15074 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15075 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15076 if(NULL == pWdaParams)
15077 {
15078 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15079 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15080 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
15081 return VOS_STATUS_E_NOMEM;
15082 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15083
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15084 //
15085 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
15086 //
15087 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15088 pRcvFltMcAddrList->ulMulticastAddrCnt;
15089
15090 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
15091 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
15092 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
15093 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
15094
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15095 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
15096 {
15097 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
15098 &(pRcvFltMcAddrList->multicastAddr[i]),
15099 sizeof(tSirMacAddr));
15100 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15101 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
15102 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15103
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15104 /* Store Params pass it to WDI */
15105 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
15106 pWdaParams->pWdaContext = pWDA;
15107 /* Store param pointer as passed in by caller */
15108 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15109 status = WDI_8023MulticastListReq(
15110 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15111 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15112 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15113 if(IS_WDI_STATUS_FAILURE(status))
15114 {
15115 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15116 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
15117 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15118 vos_mem_free(pWdaParams->wdaMsgParam);
15119 vos_mem_free(pWdaParams);
15120 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15121 return CONVERT_WDI2VOS_STATUS(status) ;
15122}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15123/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15124 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15125 *
15126 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15127void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15128 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
15129 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15130{
15131 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15132 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15133 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15134 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15135 if(NULL == pWdaParams)
15136 {
15137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15138 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15139 VOS_ASSERT(0) ;
15140 return ;
15141 }
15142
15143 vos_mem_free(pWdaParams->wdaMsgParam) ;
15144 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15145 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15146 //print a msg, nothing else to do
15147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15148 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15149 return ;
15150}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15151
15152/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15153 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
15154 * Free memory.
15155 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15156 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15157void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15158 void* pUserData)
15159{
15160 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15161
15162 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15163 "<------ %s, wdiStatus: %d",
15164 __func__, wdiStatus);
15165
15166 if (NULL == pWdaParams)
15167 {
15168 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15169 "%s: Invalid pWdaParams pointer", __func__);
15170 VOS_ASSERT(0);
15171 return;
15172 }
15173
15174 if (IS_WDI_STATUS_FAILURE(wdiStatus))
15175 {
15176 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15177 vos_mem_free(pWdaParams->wdaMsgParam);
15178 vos_mem_free(pWdaParams);
15179 }
15180
15181 return;
15182}
15183
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15184/*
15185 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
15186 * Request to WDI to set Receive Filters
15187 */
15188VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
15189 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
15190{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15191 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15192 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
15193 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
15194 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
15195 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
15196 tWDA_ReqParams *pWdaParams ;
15197 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15198 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15199 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15200 if(NULL == pwdiSetRcvPktFilterReqParamsType)
15201 {
15202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15203 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15204 VOS_ASSERT(0);
15205 return VOS_STATUS_E_NOMEM;
15206 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15207 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15208 if(NULL == pWdaParams)
15209 {
15210 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15211 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15212 VOS_ASSERT(0);
15213 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
15214 return VOS_STATUS_E_NOMEM;
15215 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15216 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
15217 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
15218 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
15219 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15220 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
15221 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
15222
15223 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
15224 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15225
15226 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15227 "FID %d FT %d NParams %d CT %d",
15228 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
15229 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
15230 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
15231 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15232 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
15233 {
15234 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
15235 &pRcvPktFilterCfg->paramsData[i],
15236 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15237 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15238 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15239 pwdiSetRcvPktFilterReqParamsType->
15240 wdiPktFilterCfg.paramsData[i].protocolLayer,
15241 pwdiSetRcvPktFilterReqParamsType->
15242 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15244 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15245 pwdiSetRcvPktFilterReqParamsType->
15246 wdiPktFilterCfg.paramsData[i].dataOffset,
15247 pwdiSetRcvPktFilterReqParamsType->
15248 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15250 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15251 pwdiSetRcvPktFilterReqParamsType->
15252 wdiPktFilterCfg.paramsData[i].compareData[0],
15253 pwdiSetRcvPktFilterReqParamsType->
15254 wdiPktFilterCfg.paramsData[i].compareData[1],
15255 pwdiSetRcvPktFilterReqParamsType->
15256 wdiPktFilterCfg.paramsData[i].compareData[2],
15257 pwdiSetRcvPktFilterReqParamsType->
15258 wdiPktFilterCfg.paramsData[i].compareData[3],
15259 pwdiSetRcvPktFilterReqParamsType->
15260 wdiPktFilterCfg.paramsData[i].compareData[4],
15261 pwdiSetRcvPktFilterReqParamsType->
15262 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15264 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15265 pwdiSetRcvPktFilterReqParamsType->
15266 wdiPktFilterCfg.paramsData[i].dataMask[0],
15267 pwdiSetRcvPktFilterReqParamsType->
15268 wdiPktFilterCfg.paramsData[i].dataMask[1],
15269 pwdiSetRcvPktFilterReqParamsType->
15270 wdiPktFilterCfg.paramsData[i].dataMask[2],
15271 pwdiSetRcvPktFilterReqParamsType->
15272 wdiPktFilterCfg.paramsData[i].dataMask[3],
15273 pwdiSetRcvPktFilterReqParamsType->
15274 wdiPktFilterCfg.paramsData[i].dataMask[4],
15275 pwdiSetRcvPktFilterReqParamsType->
15276 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15277 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15278 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15279 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15280 /* Store Params pass it to WDI */
15281 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
15282 pWdaParams->pWdaContext = pWDA;
15283 /* Store param pointer as passed in by caller */
15284 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15285 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15286 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15287 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15288 if(IS_WDI_STATUS_FAILURE(status))
15289 {
15290 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15291 "Failure in SetFilter(),free all the memory,status %d ",status);
15292 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15293 vos_mem_free(pWdaParams->wdaMsgParam);
15294 vos_mem_free(pWdaParams);
15295 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15296 return CONVERT_WDI2VOS_STATUS(status) ;
15297}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15298/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15299 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15300 *
15301 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15302void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15303 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
15304 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15305{
15306 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15307 tWDA_CbContext *pWDA;
15308 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
15309 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
15310 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
15311 tANI_U8 i;
15312 vos_msg_t vosMsg;
15313
15314 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15315 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15316 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
15317
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15318 if(NULL == pRcvFltPktMatchCntRsp)
15319 {
15320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15321 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15322 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15323 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15324 return ;
15325 }
15326
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15327 if(NULL == pWdaParams)
15328 {
15329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15330 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15331 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15332 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15333 return ;
15334 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15335 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
15336 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15337 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
15338 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
15339
15340 /* Message Header */
15341 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15342 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
15343
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15344 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15345
15346 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
15347 {
15348 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
15349 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
15350 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15351 /* VOS message wrapper */
15352 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15353 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
15354 vosMsg.bodyval = 0;
15355 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15356 {
15357 /* free the mem and return */
15358 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
15359 }
15360
15361 vos_mem_free(pWdaParams->wdaMsgParam) ;
15362 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15363 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15364
15365 return;
15366}
15367/*
15368 * FUNCTION: WDA_FilterMatchCountReqCallback
15369 * Free memory and send RSP back to SME.
15370 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
15371 */
15372void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
15373{
15374 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15375 vos_msg_t vosMsg;
15376
15377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15378 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15379
15380 if(NULL == pWdaParams)
15381 {
15382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15383 "%s: pWdaParams received NULL", __func__);
15384 VOS_ASSERT(0);
15385 return;
15386 }
15387
15388 /* VOS message wrapper */
15389 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
15390 vosMsg.bodyptr = NULL;
15391 vosMsg.bodyval = 0;
15392
15393 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15394 {
15395 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15396 vos_mem_free(pWdaParams->wdaMsgParam);
15397 vos_mem_free(pWdaParams);
15398 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
15399 }
15400
15401 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15402}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15403/*
15404 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
15405 * Request to WDI to get PC Filter Match Count
15406 */
15407VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
15408{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15409 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15410 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
15411 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
15412 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15413 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15414 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15415 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
15416 {
15417 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15418 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15419 VOS_ASSERT(0);
15420 return VOS_STATUS_E_NOMEM;
15421 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15422 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15423 if(NULL == pWdaParams)
15424 {
15425 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15426 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15427 VOS_ASSERT(0);
15428 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
15429 return VOS_STATUS_E_NOMEM;
15430 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15431
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15432 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
15433 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15434
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15435 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
15436 pRcvFltPktMatchRsp->bssId,
15437 sizeof(wpt_macAddr));
15438
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15439 /* Store Params pass it to WDI */
15440 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
15441 pWdaParams->pWdaContext = pWDA;
15442 /* Store param pointer as passed in by caller */
15443 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15444 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15445 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15446 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15447 if(IS_WDI_STATUS_FAILURE(status))
15448 {
15449 /* failure returned by WDI API */
15450 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15451 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
15452 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15453 vos_mem_free(pWdaParams) ;
15454 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
15455 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
15456 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15457 return CONVERT_WDI2VOS_STATUS(status) ;
15458}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15459/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15460 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15461 *
15462 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15463void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]15464 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
15465 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15466{
15467 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15469 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15470/* WDA_VOS_ASSERT(NULL != pWdaParams); */
15471 if(NULL == pWdaParams)
15472 {
15473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15474 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15475 VOS_ASSERT(0) ;
15476 return ;
15477 }
15478
15479 vos_mem_free(pWdaParams->wdaMsgParam) ;
15480 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15481 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15482 //print a msg, nothing else to do
15483 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15484 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15485 return ;
15486}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15487/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15488 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
15489 * Free memory.
15490 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
15491 */
15492void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
15493{
15494 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15495
15496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15497 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
15498
15499 if(NULL == pWdaParams)
15500 {
15501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15502 "%s: Invalid pWdaParams pointer", __func__);
15503 VOS_ASSERT(0);
15504 return;
15505 }
15506
15507 if(IS_WDI_STATUS_FAILURE(wdiStatus))
15508 {
15509 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15510 vos_mem_free(pWdaParams->wdaMsgParam);
15511 vos_mem_free(pWdaParams);
15512 }
15513
15514 return;
15515}
15516/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15517 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
15518 * Request to WDI to clear Receive Filters
15519 */
15520VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
15521 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
15522{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15523 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15524 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
15525 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
15526 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15527 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15528 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15529 if(NULL == pwdiRcvFltPktClearReqParamsType)
15530 {
15531 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15532 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15533 VOS_ASSERT(0);
15534 return VOS_STATUS_E_NOMEM;
15535 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15536 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15537 if(NULL == pWdaParams)
15538 {
15539 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15540 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15541 VOS_ASSERT(0);
15542 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
15543 return VOS_STATUS_E_NOMEM;
15544 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15545 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
15546 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15547 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
15548 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
15549 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
15550 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15551
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15552 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15553 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15554 /* Store Params pass it to WDI */
15555 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
15556 pWdaParams->pWdaContext = pWDA;
15557 /* Store param pointer as passed in by caller */
15558 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15559 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]15560 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15561 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15562 if(IS_WDI_STATUS_FAILURE(status))
15563 {
15564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15565 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
15566 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]15567 vos_mem_free(pWdaParams->wdaMsgParam);
15568 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15569 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15570 return CONVERT_WDI2VOS_STATUS(status) ;
15571}
15572#endif // WLAN_FEATURE_PACKET_FILTERING
15573
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15574/*
15575 * FUNCTION: WDA_ProcessSetPowerParamsReq
15576 * Request to WDI to set power params
15577 */
15578VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
15579 tSirSetPowerParamsReq *pPowerParams)
15580{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]15581 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15582 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
15583 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15584 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15585 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15586 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15587 if(NULL == pwdiSetPowerParamsReqInfo)
15588 {
15589 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15590 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15591 VOS_ASSERT(0);
15592 return VOS_STATUS_E_NOMEM;
15593 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15594 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15595 if(NULL == pWdaParams)
15596 {
15597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15598 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15599 VOS_ASSERT(0);
15600 vos_mem_free(pwdiSetPowerParamsReqInfo);
15601 return VOS_STATUS_E_NOMEM;
15602 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15603
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15604
15605 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
15606 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15607 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
15608 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15609 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
15610 pPowerParams->uListenInterval;
15611 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
15612 pPowerParams->uBcastMcastFilter;
15613 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
15614 pPowerParams->uEnableBET;
15615 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
15616 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]15617 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
15618 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15619 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
15620 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15621
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15622 /* Store Params pass it to WDI */
15623 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
15624 pWdaParams->pWdaContext = pWDA;
15625 /* Store param pointer as passed in by caller */
15626 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15627 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]15628 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15629 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15630 if(IS_WDI_STATUS_FAILURE(status))
15631 {
15632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15633 "Failure in Set power params REQ WDI API, free all the memory " );
15634 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15635 vos_mem_free(pWdaParams->wdaMsgParam);
15636 pWdaParams->wdaWdiApiMsgParam = NULL;
15637 pWdaParams->wdaMsgParam = NULL;
15638 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15639 return CONVERT_WDI2VOS_STATUS(status) ;
15640}
15641
15642/*
15643 * FUNCTION: WDA_SetTmLevelRspCallback
15644 * Set TM Level response
15645 */
15646void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
15647{
15648 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15649
15650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15651 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15652
15653 if(NULL == pWdaParams)
15654 {
15655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15656 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15657 VOS_ASSERT(0) ;
15658 return ;
15659 }
15660
15661 /* Dose not need to send notification to upper layer
15662 * Just free allocated resources */
15663 if( pWdaParams != NULL )
15664 {
15665 if( pWdaParams->wdaWdiApiMsgParam != NULL )
15666 {
15667 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15668 }
15669 vos_mem_free(pWdaParams->wdaMsgParam) ;
15670 vos_mem_free(pWdaParams) ;
15671 }
15672}
15673
15674/*
15675 * FUNCTION: WDA_ProcessSetTmLevelReq
15676 * Set TM Level request
15677 */
15678VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
15679 tAniSetTmLevelReq *setTmLevelReq)
15680{
15681 WDI_Status status = WDI_STATUS_SUCCESS ;
15682 tWDA_ReqParams *pWdaParams ;
15683 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
15684 (WDI_SetTmLevelReqType *)vos_mem_malloc(
15685 sizeof(WDI_SetTmLevelReqType)) ;
15686 if(NULL == wdiSetTmLevelReq)
15687 {
15688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15689 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15690 VOS_ASSERT(0);
15691 return VOS_STATUS_E_NOMEM;
15692 }
15693
15694 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15695 if(NULL == pWdaParams)
15696 {
15697 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15698 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15699 VOS_ASSERT(0);
15700 vos_mem_free(wdiSetTmLevelReq);
15701 return VOS_STATUS_E_NOMEM;
15702 }
15703
15704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15705 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15706
15707 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
15708 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
15709
15710 pWdaParams->pWdaContext = pWDA;
15711 pWdaParams->wdaMsgParam = setTmLevelReq;
15712 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
15713
15714 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
15715 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
15716
15717 if(IS_WDI_STATUS_FAILURE(status))
15718 {
15719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]15720 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15721 vos_mem_free(pWdaParams->wdaMsgParam) ;
15722 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15723 vos_mem_free(pWdaParams) ;
15724 }
15725
15726 return CONVERT_WDI2VOS_STATUS(status) ;
15727}
15728
15729VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
15730 tpTxControlParams pTxCtrlParam)
15731{
15732 VOS_STATUS wdaStatus;
15733
15734 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15735 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15736 if( pTxCtrlParam == NULL )
15737 {
15738 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15739 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15740 return VOS_STATUS_E_FAILURE;
15741 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15742 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
15743 {
15744 wdaStatus = WDA_SuspendDataTx(pWDA);
15745 }
15746 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
15747 {
15748 wdaStatus = WDA_ResumeDataTx(pWDA);
15749 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15750 return wdaStatus;
15751}
15752
15753 /* FUNCTION WDA_featureCapsExchange
15754 * WDA API to invoke capability exchange between host and FW.
15755 */
15756void WDA_featureCapsExchange(v_PVOID_t pVosContext)
15757{
15758 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15759 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15760 WDI_featureCapsExchangeReq( NULL, pVosContext);
15761}
15762
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]15763/* FUNCTION WDA_disableCapablityFeature
15764 * WDA API to diable Active mode offload in host.
15765 */
15766void WDA_disableCapablityFeature(tANI_U8 feature_index)
15767{
15768 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15769 "%s:enter", __func__ );
15770 WDI_disableCapablityFeature(feature_index);
15771}
15772
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15773 /* FUNCTION WDA_getHostWlanFeatCaps
15774 * Wrapper for WDI API, that will return if the feature (enum value).passed
15775 * to this API is supported or not in Host
15776 * return value
15777 * 0 - implies feature is NOT Supported
15778 * any non zero value - implies feature is SUPPORTED
15779 */
15780tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
15781{
15782 return WDI_getHostWlanFeatCaps(featEnumValue);
15783}
15784
15785 /* FUNCTION WDA_getFwWlanFeatCaps
15786 * Wrapper for WDI API, that will return if the feature (enum value).passed
15787 * to this API is supported or not in FW
15788 * return value
15789 * 0 - implies feature is NOT Supported
15790 * any non zero value - implies feature is SUPPORTED
15791 */
15792tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
15793{
15794 return WDI_getFwWlanFeatCaps(featEnumValue);
15795}
15796
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]15797
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15798/*
15799 * FUNCTION: WDA_shutdown
15800 * Shutdown WDA/WDI without handshaking with Riva.
15801 * Synchronous function.
15802 */
15803VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
15804{
15805 WDI_Status wdiStatus;
15806 //tANI_U8 eventIdx = 0;
15807 VOS_STATUS status = VOS_STATUS_SUCCESS;
15808 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15809 if (NULL == pWDA)
15810 {
15811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15812 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15813 VOS_ASSERT(0);
15814 return VOS_STATUS_E_FAILURE;
15815 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15816 /* FTM mode stay START_STATE */
15817 if( (WDA_READY_STATE != pWDA->wdaState) &&
15818 (WDA_INIT_STATE != pWDA->wdaState) &&
15819 (WDA_START_STATE != pWDA->wdaState) )
15820 {
15821 VOS_ASSERT(0);
15822 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15823
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]15824 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
15825 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15826 {
15827 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]15828 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15829 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]15830 else
15831 {
15832 vos_event_destroy(&pWDA->ftmStopDoneEvent);
15833 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]15834
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15835 /* call WDI shutdown */
15836 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15837 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
15838 {
15839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15840 "error in WDA Stop" );
15841 status = VOS_STATUS_E_FAILURE;
15842 }
15843 /* WDI stop is synchrnous, shutdown is complete when it returns */
15844 pWDA->wdaState = WDA_STOP_STATE;
15845
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15846 /* shutdown should perform the stop & close actions. */
15847 /* Destroy the event */
15848 status = vos_event_destroy(&pWDA->txFrameEvent);
15849 if(!VOS_IS_STATUS_SUCCESS(status))
15850 {
15851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15852 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15853 status = VOS_STATUS_E_FAILURE;
15854 }
15855 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
15856 if(!VOS_IS_STATUS_SUCCESS(status))
15857 {
15858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15859 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15860 status = VOS_STATUS_E_FAILURE;
15861 }
15862 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
15863 if(!VOS_IS_STATUS_SUCCESS(status))
15864 {
15865 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15866 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15867 status = VOS_STATUS_E_FAILURE;
15868 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15869 /* free WDA context */
15870 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
15871 if ( !VOS_IS_STATUS_SUCCESS(status) )
15872 {
15873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15874 "error in WDA close " );
15875 status = VOS_STATUS_E_FAILURE;
15876 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15877 return status;
15878}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15879
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15880/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15881 * FUNCTION: WDA_setNeedShutdown
15882 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15883 */
15884
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]15885void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15886{
15887 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]15888 if(pWDA == NULL)
15889 {
15890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15891 "Could not get the WDA Context pointer" );
15892 return;
15893 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15894 pWDA->needShutdown = TRUE;
15895}
15896/*
15897 * FUNCTION: WDA_needShutdown
15898 * WDA needs a shutdown
15899 */
15900
15901v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
15902{
15903 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]15904 if(pWDA == NULL)
15905 {
15906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15907 "Could not get the WDA Context pointer" );
15908 return 0;
15909 }
15910 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15911}
15912
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15913#ifdef WLAN_FEATURE_11AC
15914/*
15915 * FUNCTION: WDA_SetBeaconFilterReqCallback
15916 *
15917 */
15918void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
15919{
15920 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
15921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15922 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15923 if(NULL == pWdaParams)
15924 {
15925 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15926 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15927 VOS_ASSERT(0) ;
15928 return ;
15929 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15930
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15931 vos_mem_free(pWdaParams->wdaMsgParam) ;
15932 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
15933 vos_mem_free(pWdaParams) ;
15934 /*
15935 * No respone required for SetBeaconFilter req so just free the request
15936 * param here
15937 */
15938
15939 return ;
15940}
15941
15942VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
15943 tUpdateVHTOpMode *pData)
15944{
15945 WDI_Status status = WDI_STATUS_SUCCESS ;
15946 tWDA_ReqParams *pWdaParams ;
15947 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
15948 sizeof(WDI_UpdateVHTOpMode)) ;
15949 if(NULL == wdiTemp)
15950 {
15951 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15952 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15953 VOS_ASSERT(0);
15954 return VOS_STATUS_E_NOMEM;
15955 }
15956 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
15957 if(NULL == pWdaParams)
15958 {
15959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15960 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15961 VOS_ASSERT(0);
15962 vos_mem_free(wdiTemp);
15963 return VOS_STATUS_E_NOMEM;
15964 }
15965
15966 wdiTemp->opMode = pData->opMode;
15967 wdiTemp->staId = pData->staId;
15968
15969 pWdaParams->pWdaContext = pWDA;
15970 /* Store Req pointer, as this will be used for response */
15971 pWdaParams->wdaMsgParam = (void *)pData;
15972 /* store Params pass it to WDI */
15973 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
15974
15975 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
15976
15977 if(IS_WDI_STATUS_FAILURE(status))
15978 {
15979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15980 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
15981 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
15982 vos_mem_free(pWdaParams->wdaMsgParam);
15983 vos_mem_free(pWdaParams);
15984 }
15985 return CONVERT_WDI2VOS_STATUS(status) ;
15986}
15987#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]15988
15989/*==========================================================================
15990 FUNCTION WDA_TransportChannelDebug
15991
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]15992 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]15993 Display Transport Channel debugging information
15994 User may request to display DXE channel snapshot
15995 Or if host driver detects any abnormal stcuk may display
15996
15997 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]15998 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]15999 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16000 debugFlags : Enable stall detect features
16001 defined by WPAL_DeviceDebugFlags
16002 These features may effect
16003 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16004
16005 RETURN VALUE
16006 NONE
16007
16008===========================================================================*/
16009void WDA_TransportChannelDebug
16010(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]16011 tpAniSirGlobal pMac,
16012 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16013 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16014)
16015{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]16016 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]16017 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16018}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]16019
16020/*==========================================================================
16021 FUNCTION WDA_SetEnableSSR
16022
16023 DESCRIPTION
16024 API to enable/disable SSR on WDI timeout
16025
16026 PARAMETERS
16027 enableSSR : enable/disable SSR
16028
16029 RETURN VALUE
16030 NONE
16031
16032===========================================================================*/
16033void WDA_SetEnableSSR(v_BOOL_t enableSSR)
16034{
16035 WDI_SetEnableSSR(enableSSR);
16036}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]16037
16038#ifdef FEATURE_WLAN_LPHB
16039/*
16040 * FUNCTION: WDA_LPHBconfRspCallback
16041 *
16042 */
16043void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
16044{
16045 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16046
16047 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16048 "<------ %s " ,__func__);
16049 if (NULL == pWdaParams)
16050 {
16051 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16052 "%s: pWdaParams received NULL", __func__);
16053 VOS_ASSERT(0) ;
16054 return ;
16055 }
16056
16057 /* Do not need to send notification to upper layer
16058 * Just free allocated resources */
16059 if (pWdaParams != NULL)
16060 {
16061 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16062 {
16063 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16064 }
16065 vos_mem_free(pWdaParams->wdaMsgParam) ;
16066 vos_mem_free(pWdaParams) ;
16067 }
16068
16069 return;
16070}
16071
16072/*
16073 * FUNCTION: WDA_ProcessLPHBConfReq
16074 *
16075 */
16076VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
16077 tSirLPHBReq *pData)
16078{
16079 WDI_Status wdiStatus;
16080 tWDA_ReqParams *pWdaParams ;
16081
16082 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16083 "------> %s " , __func__);
16084
16085 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
16086 if (NULL == pWdaParams)
16087 {
16088 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16089 "%s: VOS MEM Alloc Failure", __func__);
16090 VOS_ASSERT(0);
16091 vos_mem_free(pData);
16092 return VOS_STATUS_E_NOMEM;
16093 }
16094
16095 pWdaParams->pWdaContext = pWDA;
16096 pWdaParams->wdaMsgParam = (void *)pData;
16097 pWdaParams->wdaWdiApiMsgParam = NULL;
16098
16099 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
16100 if (WDI_STATUS_PENDING == wdiStatus)
16101 {
16102 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16103 "Pending received for %s:%d ", __func__, __LINE__);
16104 }
16105 else if (WDI_STATUS_SUCCESS != wdiStatus)
16106 {
16107 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16108 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
16109 vos_mem_free(pWdaParams->wdaMsgParam);
16110 vos_mem_free(pWdaParams);
16111 }
16112
16113 return CONVERT_WDI2VOS_STATUS(wdiStatus);
16114}
16115#endif /* FEATURE_WLAN_LPHB */
16116
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]16117void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
16118 void* pUserData)
16119{
16120 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
16121
16122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16123 "<------ %s " ,__func__);
16124 if (NULL == pBcnMissRateInfo)
16125 {
16126 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16127 "%s: pWdaParams received NULL", __func__);
16128 VOS_ASSERT(0) ;
16129 return ;
16130 }
16131 if (pBcnMissRateInfo->callback)
16132 {
16133 pBcnMissRateInfo->callback(status, bcnMissRate,
16134 pBcnMissRateInfo->data);
16135 }
16136 vos_mem_free(pUserData);
16137
16138 return;
16139}
16140
16141v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
16142 tSirBcnMissRateReq *pData)
16143{
16144 WDI_Status wdiStatus;
16145 tSirBcnMissRateInfo *pBcnMissRateInfo;
16146
16147 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16148 "------> %s " , __func__);
16149
16150 pBcnMissRateInfo =
16151 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
16152 if (NULL == pBcnMissRateInfo)
16153 {
16154 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16155 "%s: VOS MEM Alloc Failure", __func__);
16156 VOS_ASSERT(0);
16157 vos_mem_free(pData);
16158 return;
16159 }
16160
16161 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
16162 pBcnMissRateInfo->data = pData->data;
16163
16164 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
16165 WDA_GetBcnMissRateCallback,
16166 pData->bssid);
16167 if (WDI_STATUS_PENDING == wdiStatus)
16168 {
16169 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16170 "Pending received for %s:%d ", __func__, __LINE__);
16171 }
16172 else if (WDI_STATUS_SUCCESS != wdiStatus)
16173 {
16174 if (pBcnMissRateInfo->callback)
16175 {
16176 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
16177 -1, pBcnMissRateInfo->data);
16178 }
16179 }
16180 vos_mem_free(pData);
16181}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16182
16183#ifdef WLAN_FEATURE_EXTSCAN
16184
16185/*==========================================================================
16186 FUNCTION WDA_EXTScanStartRspCallback
16187
16188 DESCRIPTION
16189 API to send EXTScan Start Response to HDD
16190
16191 PARAMETERS
16192 pEventData: Response from FW
16193 pUserData:
16194===========================================================================*/
16195void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
16196{
16197 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16198 tWDA_CbContext *pWDA = NULL;
16199 void *pCallbackContext;
16200 tpAniSirGlobal pMac;
16201
16202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16203 "%s:", __func__);
16204 if (NULL == pWdaParams)
16205 {
16206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16207 "%s: pWdaParams received NULL", __func__);
16208 VOS_ASSERT(0);
16209 return;
16210 }
16211
16212 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16213
16214 if (NULL == pWDA)
16215 {
16216 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16217 "%s: pWDA received NULL", __func__);
16218 VOS_ASSERT(0);
16219 goto error;
16220 }
16221
16222 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16223 if (NULL == pMac)
16224 {
16225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16226 "%s:pMac is NULL", __func__);
16227 VOS_ASSERT(0);
16228 goto error;
16229 }
16230
16231 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16232
16233 if (pMac->sme.pEXTScanIndCb)
16234 {
16235 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
16236 pEventData);
16237 }
16238 else
16239 {
16240 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16241 "%s:HDD callback is null", __func__);
16242 VOS_ASSERT(0);
16243 }
16244
16245error:
16246
16247 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16248 {
16249 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16250 }
16251 if (pWdaParams->wdaMsgParam != NULL)
16252 {
16253 vos_mem_free(pWdaParams->wdaMsgParam);
16254 }
16255 vos_mem_free(pWdaParams) ;
16256
16257 return;
16258}
16259
16260/*==========================================================================
16261 FUNCTION WDA_EXTScanStopRspCallback
16262
16263 DESCRIPTION
16264 API to send EXTScan Stop Response to HDD
16265
16266 PARAMETERS
16267 pEventData: Response from FW
16268 pUserData:
16269===========================================================================*/
16270void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
16271{
16272 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16273 tWDA_CbContext *pWDA = NULL;
16274 void *pCallbackContext;
16275 tpAniSirGlobal pMac;
16276
16277 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16278 "%s:", __func__);
16279 if (NULL == pWdaParams)
16280 {
16281 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16282 "%s: pWdaParams received NULL", __func__);
16283 VOS_ASSERT(0);
16284 return;
16285 }
16286
16287 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16288
16289 if (NULL == pWDA)
16290 {
16291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16292 "%s: pWDA received NULL", __func__);
16293 VOS_ASSERT(0);
16294 goto error;
16295 }
16296
16297 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16298 if (NULL == pMac)
16299 {
16300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16301 "%s:pMac is NULL", __func__);
16302 VOS_ASSERT(0);
16303 goto error;
16304 }
16305 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16306
16307 if (pMac->sme.pEXTScanIndCb)
16308 {
16309 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16310 "%s:HDD call back function called", __func__);
16311 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
16312 pEventData);
16313 }
16314 else
16315 {
16316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16317 "%s:HDD callback is null", __func__);
16318 VOS_ASSERT(0);
16319 }
16320
16321error:
16322
16323 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16324 {
16325 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16326 }
16327 if (pWdaParams->wdaMsgParam != NULL)
16328 {
16329 vos_mem_free(pWdaParams->wdaMsgParam);
16330 }
16331 vos_mem_free(pWdaParams) ;
16332
16333
16334 return;
16335}
16336
16337/*==========================================================================
16338 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
16339
16340 DESCRIPTION
16341 API to send EXTScan Get Cached Results Response to HDD
16342
16343 PARAMETERS
16344 pEventData: Response from FW
16345 pUserData:
16346===========================================================================*/
16347void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
16348{
16349 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16350 tWDA_CbContext *pWDA = NULL;
16351 void *pCallbackContext;
16352 tpAniSirGlobal pMac;
16353
16354 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16355 "%s: ", __func__);
16356 if (NULL == pWdaParams)
16357 {
16358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16359 "%s: pWdaParams received NULL", __func__);
16360 VOS_ASSERT(0);
16361 return;
16362 }
16363
16364 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16365
16366 if (NULL == pWDA)
16367 {
16368 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16369 "%s: pWDA received NULL", __func__);
16370 VOS_ASSERT(0);
16371 goto error;
16372 }
16373
16374 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16375 if (NULL == pMac)
16376 {
16377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16378 "%s:pMac is NULL", __func__);
16379 VOS_ASSERT(0);
16380 goto error;
16381 }
16382
16383 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16384
16385 if (pMac->sme.pEXTScanIndCb)
16386 {
16387 pMac->sme.pEXTScanIndCb(pCallbackContext,
16388 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
16389 pEventData);
16390 }
16391 else
16392 {
16393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16394 "%s:HDD callback is null", __func__);
16395 VOS_ASSERT(0);
16396 }
16397
16398
16399error:
16400
16401 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16402 {
16403 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16404 }
16405 if (pWdaParams->wdaMsgParam != NULL)
16406 {
16407 vos_mem_free(pWdaParams->wdaMsgParam);
16408 }
16409 vos_mem_free(pWdaParams) ;
16410
16411 return;
16412}
16413
16414/*==========================================================================
16415 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
16416
16417 DESCRIPTION
16418 API to send EXTScan Get Capabilities Response to HDD
16419
16420 PARAMETERS
16421 pEventData: Response from FW
16422 pUserData:
16423===========================================================================*/
16424void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
16425{
16426 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16427 tWDA_CbContext *pWDA = NULL;
16428 void *pCallbackContext;
16429 tpAniSirGlobal pMac;
16430
16431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16432 "%s:", __func__);
16433 if (NULL == pWdaParams)
16434 {
16435 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16436 "%s: pWdaParams received NULL", __func__);
16437 VOS_ASSERT(0);
16438 return;
16439 }
16440
16441 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16442
16443 if (NULL == pWDA)
16444 {
16445 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16446 "%s: pWDA received NULL", __func__);
16447 VOS_ASSERT(0);
16448 goto error;
16449 }
16450
16451 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16452 if (NULL == pMac)
16453 {
16454 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16455 "%s:pMac is NULL", __func__);
16456 VOS_ASSERT(0);
16457 goto error;
16458 }
16459
16460 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16461
16462 if (pMac->sme.pEXTScanIndCb)
16463 {
16464 pMac->sme.pEXTScanIndCb(pCallbackContext,
16465 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
16466 pEventData);
16467 }
16468 else
16469 {
16470 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16471 "%s:HDD callback is null", __func__);
16472 VOS_ASSERT(0);
16473 }
16474
16475
16476error:
16477
16478 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16479 {
16480 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16481 }
16482 if (pWdaParams->wdaMsgParam != NULL)
16483 {
16484 vos_mem_free(pWdaParams->wdaMsgParam);
16485 }
16486 vos_mem_free(pWdaParams) ;
16487
16488 return;
16489}
16490
16491/*==========================================================================
16492 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
16493
16494 DESCRIPTION
16495 API to send EXTScan Set BSSID Hotlist Response to HDD
16496
16497 PARAMETERS
16498 pEventData: Response from FW
16499 pUserData:
16500===========================================================================*/
16501void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16502{
16503 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16504 tWDA_CbContext *pWDA = NULL;
16505 void *pCallbackContext;
16506 tpAniSirGlobal pMac;
16507
16508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16509 "%s: ", __func__);
16510 if (NULL == pWdaParams)
16511 {
16512 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16513 "%s: pWdaParams received NULL", __func__);
16514 VOS_ASSERT(0) ;
16515 return;
16516 }
16517
16518 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16519
16520 if (NULL == pWDA)
16521 {
16522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16523 "%s: pWDA received NULL", __func__);
16524 VOS_ASSERT(0);
16525 goto error;
16526 }
16527
16528 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16529 if (NULL == pMac)
16530 {
16531 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16532 "%s:pMac is NULL", __func__);
16533 VOS_ASSERT(0);
16534 goto error;
16535 }
16536
16537 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16538
16539 if (pMac->sme.pEXTScanIndCb)
16540 {
16541 pMac->sme.pEXTScanIndCb(pCallbackContext,
16542 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
16543 pEventData);
16544 }
16545 else
16546 {
16547 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16548 "%s:HDD callback is null", __func__);
16549 VOS_ASSERT(0);
16550 }
16551
16552
16553error:
16554
16555 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16556 {
16557 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16558 }
16559 if (pWdaParams->wdaMsgParam != NULL)
16560 {
16561 vos_mem_free(pWdaParams->wdaMsgParam);
16562 }
16563 vos_mem_free(pWdaParams) ;
16564
16565 return;
16566}
16567
16568/*==========================================================================
16569 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
16570
16571 DESCRIPTION
16572 API to send EXTScan ReSet BSSID Hotlist Response to HDD
16573
16574 PARAMETERS
16575 pEventData: Response from FW
16576 pUserData:
16577===========================================================================*/
16578void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
16579{
16580 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16581 tWDA_CbContext *pWDA = NULL;
16582 void *pCallbackContext;
16583 tpAniSirGlobal pMac;
16584
16585 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16586 "%s:", __func__);
16587 if (NULL == pWdaParams)
16588 {
16589 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16590 "%s: pWdaParams received NULL", __func__);
16591 VOS_ASSERT(0) ;
16592 return;
16593 }
16594
16595 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16596
16597 if (NULL == pWDA)
16598 {
16599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16600 "%s: pWDA received NULL", __func__);
16601 VOS_ASSERT(0);
16602 goto error;
16603 }
16604
16605 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16606 if (NULL == pMac)
16607 {
16608 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16609 "%s:pMac is NULL", __func__);
16610 VOS_ASSERT(0);
16611 goto error;
16612 }
16613
16614 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16615
16616 if (pMac->sme.pEXTScanIndCb)
16617 {
16618 pMac->sme.pEXTScanIndCb(pCallbackContext,
16619 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
16620 pEventData);
16621 }
16622 else
16623 {
16624 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16625 "%s:HDD callback is null", __func__);
16626 VOS_ASSERT(0);
16627 }
16628
16629
16630error:
16631
16632 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16633 {
16634 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16635 }
16636 if (pWdaParams->wdaMsgParam != NULL)
16637 {
16638 vos_mem_free(pWdaParams->wdaMsgParam);
16639 }
16640 vos_mem_free(pWdaParams) ;
16641
16642 return;
16643}
16644
16645/*==========================================================================
16646 FUNCTION WDA_EXTScanSetSignfRSSIChangeRspCallback
16647
16648 DESCRIPTION
16649 API to send EXTScan Set Significant RSSI Change RSP to HDD
16650
16651 PARAMETERS
16652 pEventData: Response from FW
16653 pUserData:
16654===========================================================================*/
16655void WDA_EXTScanSetSignfRSSIChangeRspCallback(void *pEventData, void* pUserData)
16656{
16657 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16658 tWDA_CbContext *pWDA = NULL;
16659 void *pCallbackContext;
16660 tpAniSirGlobal pMac;
16661
16662 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16663 "%s:", __func__);
16664 if (NULL == pWdaParams)
16665 {
16666 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16667 "%s: pWdaParams received NULL", __func__);
16668 VOS_ASSERT(0) ;
16669 return;
16670 }
16671
16672 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16673
16674 if (NULL == pWDA)
16675 {
16676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16677 "%s: pWDA received NULL", __func__);
16678 VOS_ASSERT(0);
16679 goto error;
16680 }
16681
16682 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16683 if (NULL == pMac)
16684 {
16685 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16686 "%s:pMac is NULL", __func__);
16687 VOS_ASSERT(0);
16688 goto error;
16689 }
16690
16691 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16692
16693 if (pMac->sme.pEXTScanIndCb)
16694 {
16695 pMac->sme.pEXTScanIndCb(pCallbackContext,
16696 WDA_EXTSCAN_SET_SIGNF_RSSI_CHANGE_RSP,
16697 pEventData);
16698 }
16699 else
16700 {
16701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16702 "%s:HDD callback is null", __func__);
16703 VOS_ASSERT(0);
16704 }
16705
16706
16707error:
16708
16709 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16710 {
16711 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16712 }
16713 if (pWdaParams->wdaMsgParam != NULL)
16714 {
16715 vos_mem_free(pWdaParams->wdaMsgParam);
16716 }
16717 vos_mem_free(pWdaParams) ;
16718
16719 return;
16720}
16721
16722/*==========================================================================
16723 FUNCTION WDA_EXTScanResetSignfRSSIChangeRspCallback
16724
16725 DESCRIPTION
16726 API to send EXTScan Set Significant RSSI Change RSP to HDD
16727
16728 PARAMETERS
16729 pEventData: Response from FW
16730 pUserData:
16731===========================================================================*/
16732void WDA_EXTScanResetSignfRSSIChangeRspCallback(void *pEventData,
16733 void* pUserData)
16734{
16735 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16736 tWDA_CbContext *pWDA = NULL;
16737 void *pCallbackContext;
16738 tpAniSirGlobal pMac;
16739
16740 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16741 "%s:", __func__);
16742 if (NULL == pWdaParams)
16743 {
16744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16745 "%s: pWdaParams received NULL", __func__);
16746 VOS_ASSERT(0) ;
16747 return;
16748 }
16749
16750 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
16751
16752 if (NULL == pWDA)
16753 {
16754 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16755 "%s: pWDA received NULL", __func__);
16756 VOS_ASSERT(0);
16757 goto error;
16758 }
16759
16760 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16761 if (NULL == pMac)
16762 {
16763 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16764 "%s:pMac is NULL", __func__);
16765 VOS_ASSERT(0);
16766 goto error;
16767 }
16768
16769 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16770
16771 if (pMac->sme.pEXTScanIndCb)
16772 {
16773 pMac->sme.pEXTScanIndCb(pCallbackContext,
16774 WDA_EXTSCAN_RESET_SIGNF_RSSI_CHANGE_RSP,
16775 pEventData);
16776 }
16777 else
16778 {
16779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16780 "%s:HDD callback is null", __func__);
16781 VOS_ASSERT(0);
16782 }
16783
16784
16785error:
16786
16787 if (pWdaParams->wdaWdiApiMsgParam != NULL)
16788 {
16789 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16790 }
16791 if (pWdaParams->wdaMsgParam != NULL)
16792 {
16793 vos_mem_free(pWdaParams->wdaMsgParam);
16794 }
16795 vos_mem_free(pWdaParams) ;
16796
16797 return;
16798}
16799
16800/*==========================================================================
16801 FUNCTION WDA_ProcessEXTScanStartReq
16802
16803 DESCRIPTION
16804 API to send EXTScan Start Request to WDI
16805
16806 PARAMETERS
16807 pWDA: Pointer to WDA context
16808 wdaRequest: Pointer to EXTScan req parameters
16809===========================================================================*/
16810VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
16811 tSirEXTScanStartReqParams *wdaRequest)
16812{
16813 WDI_Status status = WDI_STATUS_SUCCESS;
16814 tWDA_ReqParams *pWdaParams;
16815
16816 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16817 "%s: ", __func__);
16818 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16819 if (NULL == pWdaParams)
16820 {
16821 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16822 "%s: VOS MEM Alloc Failure", __func__);
16823 VOS_ASSERT(0);
16824 return VOS_STATUS_E_NOMEM;
16825 }
16826 pWdaParams->pWdaContext = pWDA;
16827 pWdaParams->wdaMsgParam = wdaRequest;
16828 pWdaParams->wdaWdiApiMsgParam = NULL;
16829
16830 status = WDI_EXTScanStartReq((void *)wdaRequest,
16831 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
16832 (void *)pWdaParams);
16833 if (IS_WDI_STATUS_FAILURE(status))
16834 {
16835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16836 "Failure to request. Free all the memory " );
16837 vos_mem_free(pWdaParams->wdaMsgParam);
16838 vos_mem_free(pWdaParams);
16839 }
16840 return CONVERT_WDI2VOS_STATUS(status);
16841}
16842
16843/*==========================================================================
16844 FUNCTION WDA_ProcessEXTScanStopReq
16845
16846 DESCRIPTION
16847 API to send EXTScan Start Request to WDI
16848
16849 PARAMETERS
16850 pWDA: Pointer to WDA context
16851 wdaRequest: Pointer to EXTScan req parameters
16852===========================================================================*/
16853VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
16854 tSirEXTScanStopReqParams *wdaRequest)
16855{
16856 WDI_Status status = WDI_STATUS_SUCCESS;
16857 tWDA_ReqParams *pWdaParams;
16858
16859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16860 "%s:", __func__);
16861 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16862 if (NULL == pWdaParams)
16863 {
16864 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16865 "%s: VOS MEM Alloc Failure", __func__);
16866 VOS_ASSERT(0);
16867 return VOS_STATUS_E_NOMEM;
16868 }
16869 pWdaParams->pWdaContext = pWDA;
16870 pWdaParams->wdaMsgParam = wdaRequest;
16871 pWdaParams->wdaWdiApiMsgParam = NULL;
16872
16873 status = WDI_EXTScanStopReq((void *)wdaRequest,
16874 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
16875 (void *)pWdaParams);
16876 if (IS_WDI_STATUS_FAILURE(status))
16877 {
16878 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16879 "Failure to request. Free all the memory " );
16880 vos_mem_free(pWdaParams->wdaMsgParam);
16881 vos_mem_free(pWdaParams);
16882 }
16883 return CONVERT_WDI2VOS_STATUS(status);
16884}
16885
16886/*==========================================================================
16887 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
16888
16889 DESCRIPTION
16890 API to send EXTScan Get Cached Results Request to WDI
16891
16892 PARAMETERS
16893 pWDA: Pointer to WDA context
16894 wdaRequest: Pointer to EXTScan req parameters
16895===========================================================================*/
16896VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
16897 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
16898{
16899 WDI_Status status = WDI_STATUS_SUCCESS;
16900 tWDA_ReqParams *pWdaParams;
16901
16902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16903 "%s: ", __func__);
16904 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16905 if (NULL == pWdaParams)
16906 {
16907 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16908 "%s: VOS MEM Alloc Failure", __func__);
16909 VOS_ASSERT(0);
16910 return VOS_STATUS_E_NOMEM;
16911 }
16912 pWdaParams->pWdaContext = pWDA;
16913 pWdaParams->wdaMsgParam = wdaRequest;
16914 pWdaParams->wdaWdiApiMsgParam = NULL;
16915
16916 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
16917 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
16918 (void *)pWdaParams);
16919 if (IS_WDI_STATUS_FAILURE(status))
16920 {
16921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16922 "Failure to request. Free all the memory " );
16923 vos_mem_free(pWdaParams->wdaMsgParam);
16924 vos_mem_free(pWdaParams);
16925 }
16926 return CONVERT_WDI2VOS_STATUS(status);
16927}
16928
16929/*==========================================================================
16930 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
16931
16932 DESCRIPTION
16933 API to send EXTScan Get Capabilities Request to WDI
16934
16935 PARAMETERS
16936 pWDA: Pointer to WDA context
16937 wdaRequest: Pointer to EXTScan req parameters
16938===========================================================================*/
16939VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
16940 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
16941{
16942 WDI_Status status = WDI_STATUS_SUCCESS;
16943 tWDA_ReqParams *pWdaParams;
16944
16945 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16946 "%s:", __func__);
16947 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16948 if (NULL == pWdaParams)
16949 {
16950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16951 "%s: VOS MEM Alloc Failure", __func__);
16952 VOS_ASSERT(0);
16953 return VOS_STATUS_E_NOMEM;
16954 }
16955 pWdaParams->pWdaContext = pWDA;
16956 pWdaParams->wdaMsgParam = wdaRequest;
16957 pWdaParams->wdaWdiApiMsgParam = NULL;
16958
16959 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
16960 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
16961 (void *)pWdaParams);
16962 if (IS_WDI_STATUS_FAILURE(status))
16963 {
16964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16965 "Failure to request. Free all the memory " );
16966 vos_mem_free(pWdaParams->wdaMsgParam);
16967 vos_mem_free(pWdaParams);
16968 }
16969 return CONVERT_WDI2VOS_STATUS(status);
16970}
16971
16972/*==========================================================================
16973 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
16974
16975 DESCRIPTION
16976 API to send Set BSSID Hotlist Request to WDI
16977
16978 PARAMETERS
16979 pWDA: Pointer to WDA context
16980 wdaRequest: Pointer to EXTScan req parameters
16981===========================================================================*/
16982VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
16983 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
16984{
16985 WDI_Status status = WDI_STATUS_SUCCESS;
16986 tWDA_ReqParams *pWdaParams;
16987
16988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16989 "%s: ", __func__);
16990 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
16991 if (NULL == pWdaParams)
16992 {
16993 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16994 "%s: VOS MEM Alloc Failure", __func__);
16995 VOS_ASSERT(0);
16996 return VOS_STATUS_E_NOMEM;
16997 }
16998 pWdaParams->pWdaContext = pWDA;
16999 pWdaParams->wdaMsgParam = wdaRequest;
17000 pWdaParams->wdaWdiApiMsgParam = NULL;
17001
17002 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
17003 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
17004 (void *)pWdaParams);
17005 if (IS_WDI_STATUS_FAILURE(status))
17006 {
17007 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17008 "Failure to request. Free all the memory " );
17009 vos_mem_free(pWdaParams->wdaMsgParam);
17010 vos_mem_free(pWdaParams);
17011 }
17012 return CONVERT_WDI2VOS_STATUS(status);
17013}
17014
17015/*==========================================================================
17016 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
17017
17018 DESCRIPTION
17019 API to send Reset BSSID Hotlist Request to WDI
17020
17021 PARAMETERS
17022 pWDA: Pointer to WDA context
17023 wdaRequest: Pointer to EXTScan req parameters
17024===========================================================================*/
17025VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
17026 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
17027{
17028 WDI_Status status = WDI_STATUS_SUCCESS;
17029 tWDA_ReqParams *pWdaParams;
17030
17031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17032 "%s:", __func__);
17033 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17034 if (NULL == pWdaParams)
17035 {
17036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17037 "%s: VOS MEM Alloc Failure", __func__);
17038 VOS_ASSERT(0);
17039 return VOS_STATUS_E_NOMEM;
17040 }
17041 pWdaParams->pWdaContext = pWDA;
17042 pWdaParams->wdaMsgParam = wdaRequest;
17043 pWdaParams->wdaWdiApiMsgParam = NULL;
17044
17045 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
17046 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
17047 (void *)pWdaParams);
17048 if (IS_WDI_STATUS_FAILURE(status))
17049 {
17050 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17051 "Failure to request. Free all the memory " );
17052 vos_mem_free(pWdaParams->wdaMsgParam);
17053 vos_mem_free(pWdaParams);
17054 }
17055 return CONVERT_WDI2VOS_STATUS(status);
17056}
17057
17058/*==========================================================================
17059 FUNCTION WDA_ProcessEXTScanSetSignfRSSIChangeReq
17060
17061 DESCRIPTION
17062 API to send Set Significant RSSI Change Request to WDI
17063
17064 PARAMETERS
17065 pWDA: Pointer to WDA context
17066 wdaRequest: Pointer to EXTScan req parameters
17067===========================================================================*/
17068VOS_STATUS WDA_ProcessEXTScanSetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17069 tSirEXTScanSetSignificantChangeReqParams *wdaRequest)
17070{
17071 WDI_Status status = WDI_STATUS_SUCCESS;
17072 tWDA_ReqParams *pWdaParams;
17073
17074 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17075 "%s: ", __func__);
17076 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17077 if (NULL == pWdaParams)
17078 {
17079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17080 "%s: VOS MEM Alloc Failure", __func__);
17081 VOS_ASSERT(0);
17082 return VOS_STATUS_E_NOMEM;
17083 }
17084 pWdaParams->pWdaContext = pWDA;
17085 pWdaParams->wdaMsgParam = wdaRequest;
17086 pWdaParams->wdaWdiApiMsgParam = NULL;
17087
17088 status = WDI_EXTScanSetSignfRSSIChangeReq((void *)wdaRequest,
17089 (WDI_EXTScanSetSignfRSSIChangeRspCb)WDA_EXTScanSetSignfRSSIChangeRspCallback,
17090 (void *)pWdaParams);
17091 if (IS_WDI_STATUS_FAILURE(status))
17092 {
17093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17094 "Failure to request. Free all the memory " );
17095 vos_mem_free(pWdaParams->wdaMsgParam);
17096 vos_mem_free(pWdaParams);
17097 }
17098 return CONVERT_WDI2VOS_STATUS(status);
17099}
17100
17101/*==========================================================================
17102 FUNCTION WDA_ProcessEXTScanResetSignfRSSIChangeReq
17103
17104 DESCRIPTION
17105 API to send Reset Significant RSSI Change Request to WDI
17106
17107 PARAMETERS
17108 pWDA: Pointer to WDA context
17109 wdaRequest: Pointer to EXTScan req parameters
17110===========================================================================*/
17111VOS_STATUS WDA_ProcessEXTScanResetSignfRSSIChangeReq(tWDA_CbContext *pWDA,
17112 tSirEXTScanResetSignificantChangeReqParams *wdaRequest)
17113{
17114 WDI_Status status = WDI_STATUS_SUCCESS;
17115 tWDA_ReqParams *pWdaParams;
17116
17117 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17118 "%s:", __func__);
17119 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17120 if (NULL == pWdaParams)
17121 {
17122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17123 "%s: VOS MEM Alloc Failure", __func__);
17124 VOS_ASSERT(0);
17125 return VOS_STATUS_E_NOMEM;
17126 }
17127 pWdaParams->pWdaContext = pWDA;
17128 pWdaParams->wdaMsgParam = wdaRequest;
17129 pWdaParams->wdaWdiApiMsgParam = NULL;
17130
17131 status = WDI_EXTScanResetSignfRSSIChangeReq((void *)wdaRequest,
17132 (WDI_EXTScanResetSignfRSSIChangeRspCb)
17133 WDA_EXTScanResetSignfRSSIChangeRspCallback,
17134 (void *)pWdaParams);
17135 if (IS_WDI_STATUS_FAILURE(status))
17136 {
17137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17138 "Failure to request. Free all the memory " );
17139 vos_mem_free(pWdaParams->wdaMsgParam);
17140 vos_mem_free(pWdaParams);
17141 }
17142 return CONVERT_WDI2VOS_STATUS(status);
17143}
17144#endif /* WLAN_FEATURE_EXTSCAN */
17145
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]17146#ifdef WLAN_FEATURE_LINK_LAYER_STATS
17147
17148/*==========================================================================
17149 FUNCTION WDA_LLStatsSetRspCallback
17150
17151 DESCRIPTION
17152 API to process set link layer statistics response from FW
17153
17154 PARAMETERS
17155 pRsp: Pointer to set link layer statistics response
17156 pUserData: Pointer to user data
17157
17158 RETURN VALUE
17159 NONE
17160
17161===========================================================================*/
17162void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
17163{
17164 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17165
17166
17167 if (NULL == pWdaParams)
17168 {
17169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17170 "%s: pWdaParams received NULL", __func__);
17171 VOS_ASSERT(0) ;
17172 return ;
17173 }
17174
17175 /* Do not need to send notification to upper layer
17176 * Just free allocated resources */
17177 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17178 {
17179 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17180 }
17181 if (pWdaParams->wdaMsgParam != NULL)
17182 {
17183 vos_mem_free(pWdaParams->wdaMsgParam);
17184 }
17185 vos_mem_free(pWdaParams) ;
17186
17187 return;
17188}
17189
17190/*==========================================================================
17191 FUNCTION WDA_ProcessLLStatsSetReq
17192
17193 DESCRIPTION
17194 API to send Set Link Layer Stats request to WDI
17195
17196 PARAMETERS
17197 pWDA: Pointer to WDA context
17198 wdaRequest: Pointer to set Link Layer Stats req parameters
17199===========================================================================*/
17200VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
17201 tSirLLStatsSetReq *wdaRequest)
17202{
17203 WDI_Status status = WDI_STATUS_SUCCESS;
17204 tWDA_ReqParams *pWdaParams;
17205
17206 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17207 if (NULL == pWdaParams)
17208 {
17209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17210 "%s: VOS MEM Alloc Failure", __func__);
17211 VOS_ASSERT(0);
17212 return VOS_STATUS_E_NOMEM;
17213 }
17214 pWdaParams->pWdaContext = pWDA;
17215 pWdaParams->wdaMsgParam = wdaRequest;
17216 pWdaParams->wdaWdiApiMsgParam = NULL;
17217
17218 status = WDI_LLStatsSetReq((void *)wdaRequest,
17219 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
17220 (void *)pWdaParams);
17221 if (IS_WDI_STATUS_FAILURE(status))
17222 {
17223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17224 "Failure to request. Free all the memory " );
17225 vos_mem_free(pWdaParams->wdaMsgParam);
17226 vos_mem_free(pWdaParams);
17227 }
17228 return CONVERT_WDI2VOS_STATUS(status);
17229}
17230
17231/*==========================================================================
17232 FUNCTION WDA_LLStatsGetRspCallback
17233
17234 DESCRIPTION
17235 API to process get link layer statistics response from FW
17236
17237 PARAMETERS
17238 pRsp: Pointer to get link layer statistics response
17239 pUserData: Pointer to user data
17240
17241 RETURN VALUE
17242 NONE
17243
17244===========================================================================*/
17245void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
17246{
17247 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17248
17249 if (NULL == pWdaParams)
17250 {
17251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17252 "%s: pWdaParams received NULL", __func__);
17253 VOS_ASSERT(0) ;
17254 return ;
17255 }
17256
17257 /* Do not need to send notification to upper layer
17258 * Just free allocated resources */
17259 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17260 {
17261 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17262 }
17263 if (pWdaParams->wdaMsgParam != NULL)
17264 {
17265 vos_mem_free(pWdaParams->wdaMsgParam);
17266 }
17267 vos_mem_free(pWdaParams) ;
17268
17269 return;
17270}
17271
17272/*==========================================================================
17273 FUNCTION WDA_ProcessLLStatsGetReq
17274
17275 DESCRIPTION
17276 API to send Get Link Layer Stats request to WDI
17277
17278 PARAMETERS
17279 pWDA: Pointer to WDA context
17280 wdaRequest: Pointer to get Link Layer Stats req parameters
17281===========================================================================*/
17282VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
17283 tSirLLStatsGetReq *wdaRequest)
17284{
17285 WDI_Status status = WDI_STATUS_SUCCESS;
17286 tWDA_ReqParams *pWdaParams;
17287
17288 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17289 if (NULL == pWdaParams)
17290 {
17291 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17292 "%s: VOS MEM Alloc Failure", __func__);
17293 VOS_ASSERT(0);
17294 return VOS_STATUS_E_NOMEM;
17295 }
17296 pWdaParams->pWdaContext = pWDA;
17297 pWdaParams->wdaMsgParam = wdaRequest;
17298 pWdaParams->wdaWdiApiMsgParam = NULL;
17299
17300 status = WDI_LLStatsGetReq((void *) wdaRequest,
17301 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
17302 (void *)pWdaParams);
17303 if (IS_WDI_STATUS_FAILURE(status))
17304 {
17305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17306 "Failure to request. Free all the memory " );
17307 vos_mem_free(pWdaParams->wdaMsgParam);
17308 vos_mem_free(pWdaParams);
17309 }
17310 return CONVERT_WDI2VOS_STATUS(status);
17311}
17312
17313/*==========================================================================
17314 FUNCTION WDA_LLStatsClearRspCallback
17315
17316 DESCRIPTION
17317 API to process clear link layer statistics response from FW
17318
17319 PARAMETERS
17320 pRsp: Pointer to clear link layer statistics response
17321 pUserData: Pointer to user data
17322
17323 RETURN VALUE
17324 NONE
17325
17326===========================================================================*/
17327void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
17328{
17329 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17330
17331
17332 if (NULL == pWdaParams)
17333 {
17334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17335 "%s: pWdaParams received NULL", __func__);
17336 VOS_ASSERT(0) ;
17337 return ;
17338 }
17339 /* Do not need to send notification to upper layer
17340 * Just free allocated resources */
17341 if (pWdaParams->wdaWdiApiMsgParam != NULL)
17342 {
17343 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17344 }
17345 if (pWdaParams->wdaMsgParam != NULL)
17346 {
17347 vos_mem_free(pWdaParams->wdaMsgParam);
17348 }
17349 vos_mem_free(pWdaParams) ;
17350 return;
17351}
17352
17353/*==========================================================================
17354 FUNCTION WDA_ProcessLLStatsClearReq
17355
17356 DESCRIPTION
17357 API to send Clear Link Layer Stats request to WDI
17358
17359 PARAMETERS
17360 pWDA: Pointer to WDA context
17361 wdaRequest: Pointer to earLink Layer Stats req
17362===========================================================================*/
17363VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
17364 tSirLLStatsClearReq *wdaRequest)
17365{
17366 WDI_Status status = WDI_STATUS_SUCCESS;
17367 tWDA_ReqParams *pWdaParams;
17368
17369 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
17370 if (NULL == pWdaParams)
17371 {
17372 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17373 "%s: VOS MEM Alloc Failure", __func__);
17374 VOS_ASSERT(0);
17375 return VOS_STATUS_E_NOMEM;
17376 }
17377 pWdaParams->pWdaContext = pWDA;
17378 pWdaParams->wdaMsgParam = wdaRequest;
17379 pWdaParams->wdaWdiApiMsgParam = NULL;
17380
17381 status = WDI_LLStatsClearReq((void *) wdaRequest,
17382 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
17383 (void *)pWdaParams);
17384 if (IS_WDI_STATUS_FAILURE(status))
17385 {
17386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17387 "Failure to request. Free all the memory " );
17388 vos_mem_free(pWdaParams->wdaMsgParam);
17389 vos_mem_free(pWdaParams);
17390 }
17391 return CONVERT_WDI2VOS_STATUS(status);
17392}
17393
17394#endif /* WLAN_FEATURE_LINK_LAYER_STATS */