Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / vendor / qcom-opensource / wlan / prima / b4d7a29b51ba2641a541ca77607a0261fc578d65 / . / CORE / WDA / src / wlan_qct_wda.c
blob: 9e1e7a93cc13b5cbf58561643111aa4609db02c9 [file] [log] [blame]
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1/*
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]2 * Copyright (c) 2012-2015 The Linux Foundation. All rights reserved.
Kiet Lam1ed83fc2014-02-19 01:15:45 -0800[diff] [blame]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===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]41/*===========================================================================
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]42 EDIT HISTORY FOR FILE
43
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]44 This section contains comments describing changes made to the module.
45 Notice that changes are listed in reverse chronological order.
46
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]47 $Header$$DateTime$$Author$
48
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]49 when who what, where, why
50---------- --- -------------------------------------------------
5110/05/2011 haparna Adding support for Keep Alive Feature
522010-12-30 smiryala UMAC convergence changes
532010-08-19 adwivedi WLAN DAL AL(WDA) layer for Prima
54===========================================================================*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]55#include "vos_mq.h"
56#include "vos_api.h"
57#include "vos_packet.h"
58#include "vos_nvitem.h"
59#include "sirApi.h"
60#include "wlan_qct_pal_packet.h"
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]61#include "wlan_qct_pal_device.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]62#include "wlan_qct_wda.h"
63#include "wlan_qct_wda_msg.h"
64#include "wlan_qct_wdi_cfg.h"
65#include "wlan_qct_wdi.h"
66#include "wlan_qct_wdi_ds.h"
67#include "wlan_hal_cfg.h"
68/**********************/
69#include "wniApi.h"
70#include "cfgApi.h"
71#include "limApi.h"
72#include "wlan_qct_tl.h"
73#include "wlan_qct_tli_ba.h"
74#include "limUtils.h"
75#include "btcApi.h"
76#include "vos_sched.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]77#include "pttMsgApi.h"
78#include "wlan_qct_sys.h"
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]79/* Used MACRO's */
80/* Get WDA context from vOSS module */
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]81#define WDA_2_4_GHZ_MAX_FREQ 3000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]82#define VOS_GET_WDA_CTXT(a) vos_get_context(VOS_MODULE_ID_WDA, a)
83#define VOS_GET_MAC_CTXT(a) vos_get_context(VOS_MODULE_ID_PE, a)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]84#define WDA_BA_TX_FRM_THRESHOLD (5)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]85#define CONVERT_WDI2SIR_STATUS(x) \
86 ((WDI_STATUS_SUCCESS != (x)) ? eSIR_FAILURE : eSIR_SUCCESS)
87
Abhishek Singh447839d2015-11-30 14:22:10 +0530[diff] [blame]88/* Threshold to print tx time taken in ms*/
89#define WDA_TX_TIME_THRESHOLD 1000
90/* Recover with ssr if tx timeouts continuously
91 * for threshold number of times.
92 */
93#define WDA_TX_FAILURE_RECOVERY_THRESHOLD 3
94
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]95#define IS_WDI_STATUS_FAILURE(status) \
96 ((WDI_STATUS_SUCCESS != (status)) && (WDI_STATUS_PENDING != (status)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]97#define CONVERT_WDI2VOS_STATUS(x) \
98 ((IS_WDI_STATUS_FAILURE(x)) ? VOS_STATUS_E_FAILURE : VOS_STATUS_SUCCESS)
99
100/* macro's for acessing TL API/data structures */
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]101#define WDA_TL_GET_STA_STATE(a, b, c) WLANTL_GetSTAState(a, b, c)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]102#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]103#define WDA_GET_BA_TXFLAG(a, b, c) \
104 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) & (1 << (c)))
105
106#define WDA_SET_BA_TXFLAG(a, b, c) \
107 (((a)->wdaStaInfo[(b)].ucUseBaBitmap) |= (1 << (c)))
108
109#define WDA_CLEAR_BA_TXFLAG(a, b, c) \
110 (((a)->wdaStaInfo[b].ucUseBaBitmap) &= ~(1 << c))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]111#define WDA_TL_BA_SESSION_ADD(a, b, c, d, e, f, g) \
112 WLANTL_BaSessionAdd(a, b, c, d, e, f, g)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]113/* timer related Macros */
114#define WDA_CREATE_TIMER(a, b, c, d, e, f, g) \
115 tx_timer_create(a, b, c, d, e, f, g)
116#define WDA_START_TIMER(a) tx_timer_activate(a)
117#define WDA_STOP_TIMER(a) tx_timer_deactivate(a)
118#define WDA_DESTROY_TIMER(a) tx_timer_delete(a)
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]119#define WDA_WDI_START_TIMEOUT (WDI_RESPONSE_TIMEOUT + 5000)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]120
121#define WDA_LAST_POLLED_THRESHOLD(a, curSta, tid) \
122 ((a)->wdaStaInfo[curSta].framesTxed[tid] + WDA_BA_TX_FRM_THRESHOLD)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]123#define WDA_BA_MAX_WINSIZE (64)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]124#define WDA_INVALID_KEY_INDEX 0xFF
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]125#define WDA_NUM_PWR_SAVE_CFG 11
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]126#define WDA_TX_COMPLETE_TIME_OUT_VALUE 1000
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]127#define WDA_TRAFFIC_STATS_TIME_OUT_VALUE 1000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]128
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]129#define WDA_MAX_RETRIES_TILL_RING_EMPTY 1000 /* MAX 10000 msec = 10 seconds wait */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]130
Jeff Johnson04dd8a82012-06-29 20:41:40 -0700[diff] [blame]131#define WDA_WAIT_MSEC_TILL_RING_EMPTY 10 /* 10 msec wait per cycle */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]132#define WDA_IS_NULL_MAC_ADDRESS(mac_addr) \
133 ((mac_addr[0] == 0x00) && (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) &&\
134 (mac_addr[1] == 0x00) && (mac_addr[2] == 0x00) && (mac_addr[3] == 0x00))
135
136#define WDA_MAC_ADDR_ARRAY(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
137#define WDA_MAC_ADDRESS_STR "%02x:%02x:%02x:%02x:%02x:%02x"
Gopichand Nakkalafab3fae2013-01-07 15:01:01 -0800[diff] [blame]138#define WDA_DUMPCMD_WAIT_TIMEOUT 10000
139
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]140/* extern declarations */
141extern void vos_WDAComplete_cback(v_PVOID_t pVosContext);
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]142extern wpt_uint8 WDI_GetActiveSessionsCount (void *pWDICtx, wpt_macAddr macBSSID, wpt_boolean skipBSSID);
143
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]144/* forward declarations */
145void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
146 void *pBodyptr, tANI_U32 bodyVal) ;
147VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
148 WDI_StartReqParamsType *wdiStartParams ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]149VOS_STATUS WDA_wdiCompleteCB(v_PVOID_t pVosContext) ;
150VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams);
151
152extern v_BOOL_t sys_validateStaConfig( void *pImage, unsigned long cbFile,
153 void **ppStaConfig, v_SIZE_t *pcbStaConfig ) ;
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]154void processCfgDownloadReq(tpAniSirGlobal pMac) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]155void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
156 WDI_ConfigBSSReqInfoType *wdiBssParams, tAddBssParams *wdaBssParams) ;
157void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
158 WDI_ConfigStaReqInfoType *wdiStaParams, tAddStaParams *wdaStaParams) ;
159void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
160 void* pUserData ) ;
161static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA) ;
162static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA);
163void WDA_BaCheckActivity(tWDA_CbContext *pWDA) ;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]164void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]165void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams, void* pUserData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]166#ifdef WLAN_FEATURE_VOWIFI_11R
167VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA, tAggrAddTsParams *pAggrAddTsReqParams);
168#endif /* WLAN_FEATURE_VOWIFI_11R */
169
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]170void WDA_TimerHandler(v_VOID_t *pWDA, tANI_U32 timerInfo) ;
171void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pContext) ;
172VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]173#ifdef FEATURE_WLAN_SCAN_PNO
174static VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA, tSirPNOScanReq *pPNOScanReqParams);
175static VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA, tSirSetRSSIFilterReq* pRssiFilterParams);
176static VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA, tSirUpdateScanParams *pUpdateScanParams);
177#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]178#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]179VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,tSirRoamOffloadScanReq *pRoamOffloadScanReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]180void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData);
181void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType);
182void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType);
183#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]184#ifdef WLAN_FEATURE_PACKET_FILTERING
185static VOS_STATUS WDA_Process8023MulticastListReq (
186 tWDA_CbContext *pWDA,
187 tSirRcvFltMcAddrList *pRcvFltMcAddrLis
188 );
189static VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (
190 tWDA_CbContext *pWDA,
191 tSirRcvPktFilterCfgType *pRcvPktFilterCfg
192 );
193static VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (
194 tWDA_CbContext *pWDA,
195 tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp
196 );
197static VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (
198 tWDA_CbContext *pWDA,
199 tSirRcvFltPktClearParam *pRcvFltPktClearParam
200 );
201#endif // WLAN_FEATURE_PACKET_FILTERING
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]202VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA, tSirSetPowerParamsReq *pPowerParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]203static VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
204 tpTxControlParams pTxCtrlParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]205VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
206 v_U8_t *pDefaultKeyId,
207 v_U8_t *pNumKeys,
208 WDI_KeysType *pWdiKeys );
209
210#ifdef WLAN_FEATURE_GTK_OFFLOAD
211static VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA, tpSirGtkOffloadParams pGtkOffloadParams);
212static VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA, tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp);
213#endif // WLAN_FEATURE_GTK_OFFLOAD
214
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]215v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
216 tSirBcnMissRateReq *pData);
217
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]218VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
219 tAniSetTmLevelReq *setTmLevelReq);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]220#ifdef WLAN_FEATURE_11AC
221VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
222 tUpdateVHTOpMode *pData);
223#endif
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]224
225#ifdef FEATURE_WLAN_LPHB
226VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
227 tSirLPHBReq *pData);
228#endif /* FEATURE_WLAN_LPHB */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]229
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]230#ifdef WLAN_FEATURE_EXTSCAN
231VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
232 tSirEXTScanStartReqParams *wdaRequest);
233VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
234 tSirEXTScanStopReqParams *wdaRequest);
235VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
236 tSirEXTScanGetCachedResultsReqParams *wdaRequest);
237VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
238 tSirGetEXTScanCapabilitiesReqParams *wdaRequest);
239VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
240 tSirEXTScanSetBssidHotListReqParams *wdaRequest);
241VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
242 tSirEXTScanResetBssidHotlistReqParams *wdaRequest);
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]243VOS_STATUS WDA_ProcessEXTScanSetSSIDHotlistReq(tWDA_CbContext *pWDA,
244 tSirEXTScanSetSsidHotListReqParams *wdaRequest);
245VOS_STATUS WDA_ProcessEXTScanResetSSIDHotlistReq(tWDA_CbContext *pWDA,
246 tSirEXTScanResetSsidHotlistReqParams *wdaRequest);
Padma, Santhosh Kumarc1f7f052015-08-26 12:29:01 +0530[diff] [blame]247VOS_STATUS WDA_ProcessHighPriorityDataInfoInd(tWDA_CbContext *pWDA,
248 tSirHighPriorityDataInfoInd *wdaRequest);
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]249#endif /* WLAN_FEATURE_EXTSCAN */
250
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]251#ifdef WLAN_FEATURE_LINK_LAYER_STATS
252VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
253 tSirLLStatsSetReq *wdaRequest);
254
255VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
256 tSirLLStatsGetReq *wdaRequest);
257
258VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
259 tSirLLStatsClearReq *wdaRequest);
260#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Abhishek Singh85b74712014-10-08 11:38:19 +0530[diff] [blame]261
262v_VOID_t WDA_ProcessFWStatsGetReq(tWDA_CbContext *pWDA,
263 tSirFWStatsGetReq *wdaRequest);
264
Srinivas Dasari4dae48f2014-11-26 21:14:16 +0530[diff] [blame]265VOS_STATUS WDA_ProcessEncryptMsgReq(tWDA_CbContext *pWDA,
266 u8 *wdaRequest);
Abhishek Singh41988ba2015-05-25 19:42:29 +0530[diff] [blame]267VOS_STATUS
268WDA_ProcessSetRtsCtsHTVhtInd(tWDA_CbContext *pWDA,
269 tANI_U32 val);
Srinivas Dasari4dae48f2014-11-26 21:14:16 +0530[diff] [blame]270
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]271VOS_STATUS
272WDA_ProcessFwrMemDumpReq(tWDA_CbContext *pWDA,
273 tAniFwrDumpReq* pFwrMemDumpReq);
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]274
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]275VOS_STATUS WDA_ProcessMonStartReq( tWDA_CbContext *pWDA, void* wdaRequest);
276VOS_STATUS WDA_ProcessMonStopReq( tWDA_CbContext *pWDA, void* wdaRequest);
Mahesh A Saptasagarbeca12c2015-09-07 16:21:06 +0530[diff] [blame]277VOS_STATUS WDA_ProcessEnableDisableCAEventInd(tWDA_CbContext *pWDA, tANI_U8 val);
Arun Khandavalli7eeb1592015-10-19 21:36:57 +0530[diff] [blame]278
279VOS_STATUS WDA_ProcessWifiConfigReq(tWDA_CbContext *pWDA,
280 tSetWifiConfigParams *pwdaWificonfig);
Padma, Santhosh Kumar2ccac212015-10-20 17:27:27 +0530[diff] [blame]281
282VOS_STATUS WDA_ProcessStartOemDataReqIndNew(tWDA_CbContext *pWDA,
283 tOemDataReqNewConfig *pOemDataReqNewConfig);
284
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]285/*
286 * FUNCTION: WDA_ProcessNanRequest
287 * Process NAN request
288 */
289VOS_STATUS WDA_ProcessNanRequest(tWDA_CbContext *pWDA,
290 tNanRequest *wdaRequest)
291{
292 WDI_Status status = WDI_STATUS_SUCCESS;
293 tWDA_ReqParams *pWdaParams;
294 WDI_NanRequestType *wdiRequest = NULL;
295 size_t wdiReqLength = sizeof(WDI_NanRequestType)
296 - sizeof(wdiRequest->request_data)
297 + wdaRequest->request_data_len;
298
299 wdiRequest = (WDI_NanRequestType *)vos_mem_malloc(wdiReqLength);
300
301 if (NULL == wdiRequest)
302 {
303 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
304 "%s: VOS MEM Alloc Failure, size : %zu", __func__,
305 wdiReqLength);
306 vos_mem_free(wdaRequest);
307 return VOS_STATUS_E_NOMEM;
308 }
309
310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
311 "WDA: Process Nan Request length: %zu", wdiReqLength);
312
313 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
314 if (NULL == pWdaParams)
315 {
316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
317 "%s: VOS MEM Alloc Failure for tWDA_ReqParams", __func__);
318 VOS_ASSERT(0);
319 vos_mem_free(wdaRequest);
320 vos_mem_free(wdiRequest);
321 return VOS_STATUS_E_NOMEM;
322 }
323
324 wdiRequest->request_data_len = wdaRequest->request_data_len;
325
326 vos_mem_copy( wdiRequest->request_data,
327 wdaRequest->request_data,
328 wdaRequest->request_data_len);
329
330 vos_mem_free(wdaRequest);
331
332 pWdaParams->pWdaContext = pWDA;
333 pWdaParams->wdaMsgParam = NULL;
334 pWdaParams->wdaWdiApiMsgParam = wdiRequest;
335
336 status = WDI_NanRequest(wdiRequest, pWdaParams);
337
338 if (IS_WDI_STATUS_FAILURE(status))
339 {
340 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
341 "Failure to request. Free all the memory " );
342 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
343 vos_mem_free(pWdaParams);
344 }
345
346 return CONVERT_WDI2VOS_STATUS(status) ;
347}
348
Padma, Santhosh Kumar9093b202015-07-21 15:37:38 +0530[diff] [blame]349/**
350 * wda_state_info_dump() - prints state information of wda layer
351 */
352static void wda_state_info_dump(void)
353{
354 v_CONTEXT_t vos_ctx_ptr = NULL;
355 tWDA_CbContext *wda = NULL ;
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]356
Padma, Santhosh Kumar9093b202015-07-21 15:37:38 +0530[diff] [blame]357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
358 "<------ %s " ,__func__);
359
360 /* Get the Global VOSS Context */
361 vos_ctx_ptr = vos_get_global_context(VOS_MODULE_ID_VOSS, NULL);
362
363 if (NULL != vos_ctx_ptr)
364 wda = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA,
365 vos_ctx_ptr );
366 else {
367 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
368 "%s: Invalid Global VOSS Context", __func__);
369 VOS_ASSERT(0);
370 return;
371 }
372
373 if (NULL != wda)
374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
375 "wdaState: %d linkState: %d", wda->wdaState,
376 wda->linkState);
377 else {
378 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
379 "%s: Invalid WDA Context", __func__);
380 VOS_ASSERT(0);
381 }
382}
383
384/**
385 * wda_register_debug_callback() - registration function for wda layer
386 * to print wda state information
387 */
388static void wda_register_debug_callback(void)
389{
390 vos_register_debug_callback(VOS_MODULE_ID_WDA, &wda_state_info_dump);
391}
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]392
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]393/*
394 * FUNCTION: WDA_open
395 * Allocate the WDA context
396 */
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]397VOS_STATUS WDA_open(v_PVOID_t pVosContext, v_PVOID_t devHandle,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]398 tMacOpenParameters *pMacParams )
399{
400 tWDA_CbContext *wdaContext;
401 VOS_STATUS status;
402 WDI_DeviceCapabilityType wdiDevCapability = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]403 /* Allocate WDA context */
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]404 status = vos_alloc_context(pVosContext, VOS_MODULE_ID_WDA,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]405 (v_VOID_t **)&wdaContext, sizeof(tWDA_CbContext)) ;
406 if(!VOS_IS_STATUS_SUCCESS(status))
407 {
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "%s: Failed to "
409 "allocate context for WDA - status = %d",__func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]410 return VOS_STATUS_E_NOMEM;
411 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]412 /*__asm int 3;*/
413 vos_mem_zero(wdaContext,sizeof(tWDA_CbContext));
414
415 /* Initialize data structures */
416 wdaContext->pVosContext = pVosContext;
417 wdaContext->wdaState = WDA_INIT_STATE;
418 wdaContext->uTxFlowMask = WDA_TXFLOWMASK;
419
420 /* Initialize WDA-WDI synchronization event */
421 status = vos_event_init(&wdaContext->wdaWdiEvent);
422 if(!VOS_IS_STATUS_SUCCESS(status))
423 {
424 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]425 "WDI Sync Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]426 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]427 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]428 /* Init Frame transfer event */
429 status = vos_event_init(&wdaContext->txFrameEvent);
430 if(!VOS_IS_STATUS_SUCCESS(status))
431 {
432 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]433 "VOS Mgmt Frame Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]434 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]435 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]436 status = vos_event_init(&wdaContext->suspendDataTxEvent);
437 if(!VOS_IS_STATUS_SUCCESS(status))
438 {
439 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]440 "VOS suspend data tx Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]441 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]442 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]443 status = vos_event_init(&wdaContext->waitOnWdiIndicationCallBack);
444 if(!VOS_IS_STATUS_SUCCESS(status))
445 {
446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]447 "VOS wait On Wdi Ind Event init failed - status = %d", status);
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]448 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]449 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]450 vos_trace_setLevel(VOS_MODULE_ID_WDA,VOS_TRACE_LEVEL_ERROR);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]451 wdaContext->driverMode = pMacParams->driverType;
Arun Kumar Khandavalliebb19482014-03-25 13:56:53 +0530[diff] [blame]452 if(WDI_STATUS_SUCCESS != WDI_Init(devHandle, &wdaContext->pWdiContext,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]453 &wdiDevCapability, pMacParams->driverType))
454 {
455 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
456 "WDI Init failed" );
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]457 goto error;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]458 }
459 else
460 {
461 pMacParams->maxStation = wdiDevCapability.ucMaxSTASupported ;
462 pMacParams->maxBssId = wdiDevCapability.ucMaxBSSSupported;
463 pMacParams->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]464 /* update max STA in WDA used for BA */
465 wdaContext->wdaMaxSta = pMacParams->maxStation;
466 /* store the frameTransRequired flag in wdaContext, to send this to HAL
467 * in WDA_Start
468 */
469 wdaContext->frameTransRequired = wdiDevCapability.bFrameXtlSupported;
470 }
Padma, Santhosh Kumar9093b202015-07-21 15:37:38 +0530[diff] [blame]471
472 wda_register_debug_callback();
473
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]474 return status;
Madan Mohan Koyyalamudi0b78e152012-11-28 15:46:51 -0800[diff] [blame]475
476error:
477 vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
478 return VOS_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]479}
480
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]481/*
482 * FUNCTION: WDA_preStart
483 * Trigger DAL-AL to start CFG download
484 */
485VOS_STATUS WDA_preStart(v_PVOID_t pVosContext)
486{
487 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
488 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]489 /*
490 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
491 */
492 wdaMsg.type = WNI_CFG_DNLD_REQ ;
493 wdaMsg.bodyptr = NULL;
494 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]495 /* post the message.. */
496 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
497 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
498 {
499 vosStatus = VOS_STATUS_E_BADMSG;
500 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]501 return( vosStatus );
502}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]503/*
504 * FUNCTION: WDA_wdiStartCallback
505 * Once WDI_Start is finished, WDI start callback will be called by WDI
506 * to indicate completion of WDI_Start.
507 */
508void WDA_wdiStartCallback(WDI_StartRspParamsType *wdiRspParams,
509 void *pVosContext)
510{
511 tWDA_CbContext *wdaContext;
512 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]513 if (NULL == pVosContext)
514 {
515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]516 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]517 return;
518 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]519 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
520 if (NULL == wdaContext)
521 {
522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]523 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]524 return;
525 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]526 if (WDI_STATUS_SUCCESS != wdiRspParams->wdiStatus)
527 {
528 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]529 "%s: WDI_Start() failure reported", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]530 }
531 else
532 {
533 wdaContext->wdaState = WDA_START_STATE;
534 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]535 /* extract and save version information from the Start Response */
536 wdaContext->wcnssWlanCompiledVersion.major =
537 wdiRspParams->wlanCompiledVersion.major;
538 wdaContext->wcnssWlanCompiledVersion.minor =
539 wdiRspParams->wlanCompiledVersion.minor;
540 wdaContext->wcnssWlanCompiledVersion.version =
541 wdiRspParams->wlanCompiledVersion.version;
542 wdaContext->wcnssWlanCompiledVersion.revision =
543 wdiRspParams->wlanCompiledVersion.revision;
544 wdaContext->wcnssWlanReportedVersion.major =
545 wdiRspParams->wlanReportedVersion.major;
546 wdaContext->wcnssWlanReportedVersion.minor =
547 wdiRspParams->wlanReportedVersion.minor;
548 wdaContext->wcnssWlanReportedVersion.version =
549 wdiRspParams->wlanReportedVersion.version;
550 wdaContext->wcnssWlanReportedVersion.revision =
551 wdiRspParams->wlanReportedVersion.revision;
552 wpalMemoryCopy(wdaContext->wcnssSoftwareVersionString,
553 wdiRspParams->wcnssSoftwareVersion,
554 sizeof(wdaContext->wcnssSoftwareVersionString));
555 wpalMemoryCopy(wdaContext->wcnssHardwareVersionString,
556 wdiRspParams->wcnssHardwareVersion,
557 sizeof(wdaContext->wcnssHardwareVersionString));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]558 /* Notify WDA_start that WDI_Start has completed */
559 status = vos_event_set(&wdaContext->wdaWdiEvent);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]560 if (VOS_STATUS_SUCCESS != status)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]561 {
562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]563 "%s: Unable to unblock WDA_start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]564 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]565 return;
566}
567
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]568/*
569 * FUNCTION: WDA_start
570 * Prepare TLV configuration and call WDI_Start.
571 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]572VOS_STATUS WDA_start(v_PVOID_t pVosContext)
573{
574 tWDA_CbContext *wdaContext;
575 VOS_STATUS status;
576 WDI_Status wdiStatus;
577 WDI_StartReqParamsType wdiStartParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]578 if (NULL == pVosContext)
579 {
580 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]581 "%s: Invoked with invalid pVosContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]582 return VOS_STATUS_E_FAILURE;
583 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]584 wdaContext = VOS_GET_WDA_CTXT(pVosContext);
585 if (NULL == wdaContext)
586 {
587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]588 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]589 return VOS_STATUS_E_FAILURE;
590 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]591 /* Non-FTM mode, WDA status for START must be INIT
592 * FTM mode, WDA Status for START can be INIT or STOP */
593 if ( (WDA_INIT_STATE != wdaContext->wdaState) &&
594 (WDA_STOP_STATE != wdaContext->wdaState) )
595 {
596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
597 "%s: Invoked from wrong state %d",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]598 __func__, wdaContext->wdaState );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]599 return VOS_STATUS_E_FAILURE;
600 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]601 /* initialize the wdiStartParam. Note that we can create this on
602 the stack since we won't exit until WDI_Start() completes or
603 times out */
604 vos_mem_set(&wdiStartParam, sizeof(wdiStartParam), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]605 wdiStartParam.wdiDriverType = wdaContext->driverMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]606 /* prepare the config TLV for the WDI */
607 status = WDA_prepareConfigTLV(pVosContext, &wdiStartParam);
608 if ( !VOS_IS_STATUS_SUCCESS(status) )
609 {
610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]611 "%s: Unable to prepare Config TLV", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]612 return VOS_STATUS_E_FAILURE;
613 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]614 /* note from here onwards if an error occurs we must
615 reclaim the config TLV buffer */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]616 wdiStartParam.wdiLowLevelIndCB = WDA_lowLevelIndCallback;
617 wdiStartParam.pIndUserData = (v_PVOID_t *)wdaContext;
618 wdiStartParam.wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]619 /* initialize the WDA-WDI synchronization event */
620 vos_event_reset(&wdaContext->wdaWdiEvent);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]621 /* call WDI start */
622 wdiStatus = WDI_Start(&wdiStartParam,
623 (WDI_StartRspCb)WDA_wdiStartCallback,
624 (v_VOID_t *)pVosContext);
625 if ( IS_WDI_STATUS_FAILURE(wdiStatus) )
626 {
627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]628 "%s: WDI Start failed", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]629 vos_mem_free(wdiStartParam.pConfigBuffer);
630 return VOS_STATUS_E_FAILURE;
631 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]632 /* wait for WDI start to invoke our callback */
633 status = vos_wait_single_event( &wdaContext->wdaWdiEvent,
634 WDA_WDI_START_TIMEOUT );
635 if ( !VOS_IS_STATUS_SUCCESS(status) )
636 {
637 if ( VOS_STATUS_E_TIMEOUT == status )
638 {
639 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]640 "%s: Timeout occurred during WDI_Start", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]641 }
642 else
643 {
644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
645 "%s: Error %d while waiting for WDI_Start",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]646 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]647 }
648 vos_mem_free(wdiStartParam.pConfigBuffer);
Siddharth Bhalbea38ad2014-10-12 14:10:52 +0530[diff] [blame]649 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]650 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]651 /* WDI_Start() has completed so we can resume our work */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]652 /* we no longer need the config TLV */
653 vos_mem_free(wdiStartParam.pConfigBuffer);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]654 /* if we are not in the START state then WDI_Start() failed */
655 if (WDA_START_STATE != wdaContext->wdaState)
656 {
657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]658 "%s: WDI_Start() failure detected", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]659 return VOS_STATUS_E_FAILURE;
660 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]661 /* FTM mode does not need to monitor BA activity */
662 if ( eDRIVER_TYPE_MFG != wdaContext->driverMode )
663 {
664 status = wdaCreateTimers(wdaContext) ;
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]665 if(VOS_STATUS_SUCCESS == status)
666 {
667 wdaContext->wdaTimersCreated = VOS_TRUE;
668 }
Hanumantha Reddy Pothulab5c67c02015-07-14 21:27:50 +0530[diff] [blame]669 else
670 {
671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
672 FL("wda create timers failed"));
673 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]674 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]675 else
676 {
677 vos_event_init(&wdaContext->ftmStopDoneEvent);
678 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]679 return status;
680}
681
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]682/*
683 * FUNCTION: WDA_prepareConfigTLV
684 * Function to prepare CFG for DAL(WDA)
685 */
686VOS_STATUS WDA_prepareConfigTLV(v_PVOID_t pVosContext,
687 WDI_StartReqParamsType *wdiStartParams )
688{
689 /* get pMac to acess CFG data base */
690 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
691 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
692 tHalCfg *tlvStruct = NULL ;
693 tANI_U8 *tlvStructStart = NULL ;
694 tANI_U32 strLength = WNI_CFG_STA_ID_LEN;
695 v_PVOID_t *configParam;
696 tANI_U32 configParamSize;
697 tANI_U32 *configDataValue;
698 WDI_WlanVersionType wcnssCompiledApiVersion;
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]699 tANI_U8 i;
700
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]701 if ((NULL == pMac)||(NULL == wdaContext))
702 {
703 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]704 "%s: Invoked with invalid wdaContext or pMac", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]705 VOS_ASSERT(0);
706 return VOS_STATUS_E_FAILURE;
707 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]708 configParamSize = (sizeof(tHalCfg) * QWLAN_HAL_CFG_MAX_PARAMS) +
709 WNI_CFG_STA_ID_LEN +
710 WNI_CFG_EDCA_WME_ACBK_LEN +
711 WNI_CFG_EDCA_WME_ACBE_LEN +
712 WNI_CFG_EDCA_WME_ACVI_LEN +
713 WNI_CFG_EDCA_WME_ACVO_LEN +
714 + (QWLAN_HAL_CFG_INTEGER_PARAM * sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]715 /* malloc memory for all configs in one shot */
716 configParam = vos_mem_malloc(configParamSize);
717
718 if(NULL == configParam )
719 {
720 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]721 "%s:configParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]722 VOS_ASSERT(0) ;
723 return VOS_STATUS_E_NOMEM;
724 }
725 vos_mem_set(configParam, configParamSize, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]726 wdiStartParams->pConfigBuffer = configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]727 tlvStruct = (tHalCfg *)configParam;
728 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]729 /* TODO: Remove Later */
730 /* QWLAN_HAL_CFG_STA_ID */
731 tlvStruct->type = QWLAN_HAL_CFG_STA_ID;
732 configDataValue = (tANI_U32*)((tANI_U8 *) tlvStruct + sizeof(tHalCfg));
733 if(wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8*)configDataValue, &strLength) !=
734 eSIR_SUCCESS)
735 {
736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
737 "Failed to get value for WNI_CFG_STA_ID");
738 goto handle_failure;
739 }
740 tlvStruct->length = strLength ;
741 /* calculate the pad bytes to have the CFG in aligned format */
742 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
743 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]744 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
745 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]746 /* QWLAN_HAL_CFG_CURRENT_TX_ANTENNA */
747 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
748 tlvStruct->length = sizeof(tANI_U32);
749 configDataValue = (tANI_U32 *)(tlvStruct + 1);
750 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_TX_ANTENNA, configDataValue )
751 != eSIR_SUCCESS)
752 {
753 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
754 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
755 goto handle_failure;
756 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]757 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
758 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]759 /* QWLAN_HAL_CFG_CURRENT_RX_ANTENNA */
760 tlvStruct->type = QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
761 tlvStruct->length = sizeof(tANI_U32);
762 configDataValue = (tANI_U32 *)(tlvStruct + 1);
763 if(wlan_cfgGetInt(pMac, WNI_CFG_CURRENT_RX_ANTENNA, configDataValue) !=
764 eSIR_SUCCESS)
765 {
766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
767 "Failed to get value for WNI_CFG_CURRENT_RX_ANTENNA");
768 goto handle_failure;
769 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]770 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
771 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]772 /* QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE */
773 tlvStruct->type = QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
774 tlvStruct->length = sizeof(tANI_U32);
775 configDataValue = (tANI_U32 *)(tlvStruct + 1);
776 if(wlan_cfgGetInt(pMac, WNI_CFG_LOW_GAIN_OVERRIDE, configDataValue )
777 != eSIR_SUCCESS)
778 {
779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
780 "Failed to get value for WNI_CFG_LOW_GAIN_OVERRIDE");
781 goto handle_failure;
782 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]783 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
784 + sizeof(tHalCfg) + tlvStruct->length)) ;
785
786 /* QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN */
787 tlvStruct->type = QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
788 tlvStruct->length = sizeof(tANI_U32);
789 configDataValue = (tANI_U32 *)(tlvStruct + 1);
790 if(wlan_cfgGetInt(pMac, WNI_CFG_POWER_STATE_PER_CHAIN,
791 configDataValue ) != eSIR_SUCCESS)
792 {
793 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
794 "Failed to get value for WNI_CFG_POWER_STATE_PER_CHAIN");
795 goto handle_failure;
796 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]797 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
798 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]799 /* QWLAN_HAL_CFG_CAL_PERIOD */
800 tlvStruct->type = QWLAN_HAL_CFG_CAL_PERIOD;
801 tlvStruct->length = sizeof(tANI_U32);
802 configDataValue = (tANI_U32 *)(tlvStruct + 1);
803 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_PERIOD, configDataValue )
804 != eSIR_SUCCESS)
805 {
806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
807 "Failed to get value for WNI_CFG_CAL_PERIOD");
808 goto handle_failure;
809 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]810 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
811 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]812 /* QWLAN_HAL_CFG_CAL_CONTROL */
813 tlvStruct->type = QWLAN_HAL_CFG_CAL_CONTROL ;
814 tlvStruct->length = sizeof(tANI_U32);
815 configDataValue = (tANI_U32 *)(tlvStruct + 1);
816 if(wlan_cfgGetInt(pMac, WNI_CFG_CAL_CONTROL, configDataValue )
817 != eSIR_SUCCESS)
818 {
819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
820 "Failed to get value for WNI_CFG_CAL_CONTROL");
821 goto handle_failure;
822 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]823 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
824 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]825 /* QWLAN_HAL_CFG_PROXIMITY */
826 tlvStruct->type = QWLAN_HAL_CFG_PROXIMITY ;
827 tlvStruct->length = sizeof(tANI_U32);
828 configDataValue = (tANI_U32 *)(tlvStruct + 1);
829 if(wlan_cfgGetInt(pMac, WNI_CFG_PROXIMITY, configDataValue )
830 != eSIR_SUCCESS)
831 {
832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
833 "Failed to get value for WNI_CFG_PROXIMITY");
834 goto handle_failure;
835 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]836 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
837 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]838 /* QWLAN_HAL_CFG_NETWORK_DENSITY */
839 tlvStruct->type = QWLAN_HAL_CFG_NETWORK_DENSITY ;
840 tlvStruct->length = sizeof(tANI_U32);
841 configDataValue = (tANI_U32 *)(tlvStruct + 1);
842 if(wlan_cfgGetInt(pMac, WNI_CFG_NETWORK_DENSITY, configDataValue )
843 != eSIR_SUCCESS)
844 {
845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
846 "Failed to get value for WNI_CFG_NETWORK_DENSITY");
847 goto handle_failure;
848 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]849 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
850 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]851 /* QWLAN_HAL_CFG_MAX_MEDIUM_TIME */
852 tlvStruct->type = QWLAN_HAL_CFG_MAX_MEDIUM_TIME ;
853 tlvStruct->length = sizeof(tANI_U32);
854 configDataValue = (tANI_U32 *)(tlvStruct + 1);
855 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MEDIUM_TIME, configDataValue ) !=
856 eSIR_SUCCESS)
857 {
858 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
859 "Failed to get value for WNI_CFG_MAX_MEDIUM_TIME");
860 goto handle_failure;
861 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]862 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
863 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]864 /* QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU */
865 tlvStruct->type = QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU ;
866 tlvStruct->length = sizeof(tANI_U32);
867 configDataValue = (tANI_U32 *)(tlvStruct + 1);
868 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_MPDUS_IN_AMPDU,
869 configDataValue ) != eSIR_SUCCESS)
870 {
871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
872 "Failed to get value for WNI_CFG_MAX_MPDUS_IN_AMPDU");
873 goto handle_failure;
874 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]875 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
876 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]877 /* QWLAN_HAL_CFG_RTS_THRESHOLD */
878 tlvStruct->type = QWLAN_HAL_CFG_RTS_THRESHOLD ;
879 tlvStruct->length = sizeof(tANI_U32);
880 configDataValue = (tANI_U32 *)(tlvStruct + 1);
881 if(wlan_cfgGetInt(pMac, WNI_CFG_RTS_THRESHOLD, configDataValue ) !=
882 eSIR_SUCCESS)
883 {
884 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
885 "Failed to get value for WNI_CFG_RTS_THRESHOLD");
886 goto handle_failure;
887 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]888 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
889 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]890 /* QWLAN_HAL_CFG_SHORT_RETRY_LIMIT */
891 tlvStruct->type = QWLAN_HAL_CFG_SHORT_RETRY_LIMIT ;
892 tlvStruct->length = sizeof(tANI_U32);
893 configDataValue = (tANI_U32 *)(tlvStruct + 1);
894 if(wlan_cfgGetInt(pMac, WNI_CFG_SHORT_RETRY_LIMIT, configDataValue ) !=
895 eSIR_SUCCESS)
896 {
897 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
898 "Failed to get value for WNI_CFG_SHORT_RETRY_LIMIT");
899 goto handle_failure;
900 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]901 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
902 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]903 /* QWLAN_HAL_CFG_LONG_RETRY_LIMIT */
904 tlvStruct->type = QWLAN_HAL_CFG_LONG_RETRY_LIMIT ;
905 tlvStruct->length = sizeof(tANI_U32);
906 configDataValue = (tANI_U32 *)(tlvStruct + 1);
907 if(wlan_cfgGetInt(pMac, WNI_CFG_LONG_RETRY_LIMIT, configDataValue ) !=
908 eSIR_SUCCESS)
909 {
910 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
911 "Failed to get value for WNI_CFG_LONG_RETRY_LIMIT");
912 goto handle_failure;
913 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]914 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
915 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]916 /* QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD */
917 tlvStruct->type = QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD ;
918 tlvStruct->length = sizeof(tANI_U32);
919 configDataValue = (tANI_U32 *)(tlvStruct + 1);
920 if(wlan_cfgGetInt(pMac, WNI_CFG_FRAGMENTATION_THRESHOLD,
921 configDataValue ) != eSIR_SUCCESS)
922 {
923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
924 "Failed to get value for WNI_CFG_FRAGMENTATION_THRESHOLD");
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_DYNAMIC_THRESHOLD_ZERO */
930 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO ;
931 tlvStruct->length = sizeof(tANI_U32);
932 configDataValue = (tANI_U32 *)(tlvStruct + 1);
933 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ZERO,
934 configDataValue ) != eSIR_SUCCESS)
935 {
936 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
937 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ZERO");
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));
942
943 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE */
944 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE ;
945 tlvStruct->length = sizeof(tANI_U32);
946 configDataValue = (tANI_U32 *)(tlvStruct + 1);
947 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_ONE,
948 configDataValue ) != eSIR_SUCCESS)
949 {
950 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
951 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_ONE");
952 goto handle_failure;
953 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]954 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
955 + sizeof(tHalCfg) + tlvStruct->length));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]956 /* QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO */
957 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO ;
958 tlvStruct->length = sizeof(tANI_U32);
959 configDataValue = (tANI_U32 *)(tlvStruct + 1);
960 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_THRESHOLD_TWO,
961 configDataValue ) != eSIR_SUCCESS)
962 {
963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
964 "Failed to get value for WNI_CFG_DYNAMIC_THRESHOLD_TWO");
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));
969
970 /* QWLAN_HAL_CFG_FIXED_RATE */
971 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE ;
972 tlvStruct->length = sizeof(tANI_U32);
973 configDataValue = (tANI_U32 *)(tlvStruct + 1);
974 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE, configDataValue)
975 != eSIR_SUCCESS)
976 {
977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
978 "Failed to get value for WNI_CFG_FIXED_RATE");
979 goto handle_failure;
980 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]981 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
982 + sizeof(tHalCfg) + tlvStruct->length));
983
984 /* QWLAN_HAL_CFG_RETRYRATE_POLICY */
985 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_POLICY ;
986 tlvStruct->length = sizeof(tANI_U32);
987 configDataValue = (tANI_U32 *)(tlvStruct + 1);
988 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_POLICY, configDataValue )
989 != eSIR_SUCCESS)
990 {
991 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
992 "Failed to get value for WNI_CFG_RETRYRATE_POLICY");
993 goto handle_failure;
994 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]995 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
996 + sizeof(tHalCfg) + tlvStruct->length));
997
998 /* QWLAN_HAL_CFG_RETRYRATE_SECONDARY */
999 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_SECONDARY ;
1000 tlvStruct->length = sizeof(tANI_U32);
1001 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1002 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_SECONDARY,
1003 configDataValue ) != eSIR_SUCCESS)
1004 {
1005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1006 "Failed to get value for WNI_CFG_RETRYRATE_SECONDARY");
1007 goto handle_failure;
1008 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1009 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
1010 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1011 /* QWLAN_HAL_CFG_RETRYRATE_TERTIARY */
1012 tlvStruct->type = QWLAN_HAL_CFG_RETRYRATE_TERTIARY ;
1013 tlvStruct->length = sizeof(tANI_U32);
1014 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1015 if(wlan_cfgGetInt(pMac, WNI_CFG_RETRYRATE_TERTIARY,
1016 configDataValue ) != eSIR_SUCCESS)
1017 {
1018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1019 "Failed to get value for WNI_CFG_RETRYRATE_TERTIARY");
1020 goto handle_failure;
1021 }
1022 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
1023 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1024 /* QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION */
1025 tlvStruct->type = QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION ;
1026 tlvStruct->length = sizeof(tANI_U32);
1027 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1028 if(wlan_cfgGetInt(pMac, WNI_CFG_FORCE_POLICY_PROTECTION,
1029 configDataValue ) != eSIR_SUCCESS)
1030 {
1031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1032 "Failed to get value for WNI_CFG_FORCE_POLICY_PROTECTION");
1033 goto handle_failure;
1034 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1035 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1036 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1037 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ */
1038 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ ;
1039 tlvStruct->length = sizeof(tANI_U32);
1040 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1041 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_24GHZ,
1042 configDataValue ) != eSIR_SUCCESS)
1043 {
1044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1045 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_24GHZ");
1046 goto handle_failure;
1047 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1048 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1049 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1050 /* QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ */
1051 tlvStruct->type = QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ ;
1052 tlvStruct->length = sizeof(tANI_U32);
1053 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1054 if(wlan_cfgGetInt(pMac, WNI_CFG_FIXED_RATE_MULTICAST_5GHZ,
1055 configDataValue ) != eSIR_SUCCESS)
1056 {
1057 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1058 "Failed to get value for WNI_CFG_FIXED_RATE_MULTICAST_5GHZ");
1059 goto handle_failure;
1060 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1061 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1062 + sizeof(tHalCfg) + tlvStruct->length);
1063
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1064 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ */
1065 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ ;
1066 tlvStruct->length = sizeof(tANI_U32);
1067 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1068 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_24GHZ,
1069 configDataValue ) != eSIR_SUCCESS)
1070 {
1071 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1072 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_24GHZ");
1073 goto handle_failure;
1074 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1075 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1076 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1077 /* QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ */
1078 tlvStruct->type = QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ ;
1079 tlvStruct->length = sizeof(tANI_U32);
1080 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1081 if(wlan_cfgGetInt(pMac, WNI_CFG_DEFAULT_RATE_INDEX_5GHZ,
1082 configDataValue ) != eSIR_SUCCESS)
1083 {
1084 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1085 "Failed to get value for WNI_CFG_DEFAULT_RATE_INDEX_5GHZ");
1086 goto handle_failure;
1087 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1088 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1089 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1090 /* QWLAN_HAL_CFG_MAX_BA_SESSIONS */
1091 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_SESSIONS ;
1092 tlvStruct->length = sizeof(tANI_U32);
1093 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1094 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_SESSIONS, configDataValue ) !=
1095 eSIR_SUCCESS)
1096 {
1097 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1098 "Failed to get value for WNI_CFG_MAX_BA_SESSIONS");
1099 goto handle_failure;
1100 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1101 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1102 + sizeof(tHalCfg) + tlvStruct->length);
1103
1104 /* QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT */
1105 tlvStruct->type = QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT ;
1106 tlvStruct->length = sizeof(tANI_U32);
1107 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1108 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT,
1109 configDataValue ) != eSIR_SUCCESS)
1110 {
1111 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1112 "Failed to get value for WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT");
1113 goto handle_failure;
1114 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1115 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1116 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1117 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER */
1118 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER ;
1119 tlvStruct->length = sizeof(tANI_U32);
1120 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1121 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_BCN_FILTER,
1122 configDataValue ) != eSIR_SUCCESS)
1123 {
1124 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1125 "Failed to get value for WNI_CFG_PS_ENABLE_BCN_FILTER");
1126 goto handle_failure;
1127 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1128 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1129 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1130 /* QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR */
1131 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR ;
1132 tlvStruct->length = sizeof(tANI_U32);
1133 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1134 if(wlan_cfgGetInt(pMac, WNI_CFG_PS_ENABLE_RSSI_MONITOR,
1135 configDataValue ) != eSIR_SUCCESS)
1136 {
1137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1138 "Failed to get value for WNI_CFG_PS_ENABLE_RSSI_MONITOR");
1139 goto handle_failure;
1140 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1141 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1142 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1143 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
1144 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE ;
1145 tlvStruct->length = sizeof(tANI_U32);
1146 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1147 if(wlan_cfgGetInt(pMac, WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE,
1148 configDataValue ) != eSIR_SUCCESS)
1149 {
1150 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1151 "Failed to get value for WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE");
1152 goto handle_failure;
1153 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1154 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1155 + sizeof(tHalCfg) + tlvStruct->length);
1156
1157 /* QWLAN_HAL_CFG_STATS_PERIOD */
1158 tlvStruct->type = QWLAN_HAL_CFG_STATS_PERIOD ;
1159 tlvStruct->length = sizeof(tANI_U32);
1160 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1161 if(wlan_cfgGetInt(pMac, WNI_CFG_STATS_PERIOD, configDataValue ) !=
1162 eSIR_SUCCESS)
1163 {
1164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1165 "Failed to get value for WNI_CFG_STATS_PERIOD");
1166 goto handle_failure;
1167 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1168 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1169 + sizeof(tHalCfg) + tlvStruct->length);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1170 /* QWLAN_HAL_CFG_CFP_MAX_DURATION */
1171 tlvStruct->type = QWLAN_HAL_CFG_CFP_MAX_DURATION ;
1172 tlvStruct->length = sizeof(tANI_U32);
1173 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1174 if(wlan_cfgGetInt(pMac, WNI_CFG_CFP_MAX_DURATION, configDataValue ) !=
1175 eSIR_SUCCESS)
1176 {
1177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1178 "Failed to get value for WNI_CFG_CFP_MAX_DURATION");
1179 goto handle_failure;
1180 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1181 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1182 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1183 /* QWLAN_HAL_CFG_FRAME_TRANS_ENABLED */
1184 tlvStruct->type = QWLAN_HAL_CFG_FRAME_TRANS_ENABLED ;
1185 tlvStruct->length = sizeof(tANI_U32);
1186 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1187 vos_mem_copy(configDataValue, &wdaContext->frameTransRequired,
1188 sizeof(tANI_U32));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1189 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1190 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1191 /* QWLAN_HAL_CFG_DTIM_PERIOD */
1192 tlvStruct->type = QWLAN_HAL_CFG_DTIM_PERIOD ;
1193 tlvStruct->length = sizeof(tANI_U32);
1194 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1195 if(wlan_cfgGetInt(pMac, WNI_CFG_DTIM_PERIOD, configDataValue)
1196 != eSIR_SUCCESS)
1197 {
1198 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1199 "Failed to get value for WNI_CFG_DTIM_PERIOD");
1200 goto handle_failure;
1201 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1202 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1203 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1204 /* QWLAN_HAL_CFG_EDCA_WMM_ACBK */
1205 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBK ;
1206 strLength = WNI_CFG_EDCA_WME_ACBK_LEN;
1207 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1208 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBK, (tANI_U8 *)configDataValue,
1209 &strLength) != eSIR_SUCCESS)
1210 {
1211 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1212 "Failed to get value for WNI_CFG_EDCA_WME_ACBK");
1213 goto handle_failure;
1214 }
1215 tlvStruct->length = strLength;
1216 /* calculate the pad bytes to have the CFG in aligned format */
1217 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1218 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1219 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1220 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1221 /* QWLAN_HAL_CFG_EDCA_WMM_ACBE */
1222 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACBE ;
1223 strLength = WNI_CFG_EDCA_WME_ACBE_LEN;
1224 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1225 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACBE, (tANI_U8 *)configDataValue,
1226 &strLength) != eSIR_SUCCESS)
1227 {
1228 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1229 "Failed to get value for WNI_CFG_EDCA_WME_ACBE");
1230 goto handle_failure;
1231 }
1232 tlvStruct->length = strLength;
1233 /* calculate the pad bytes to have the CFG in aligned format */
1234 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1235 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1236 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1237 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1238 /* QWLAN_HAL_CFG_EDCA_WMM_ACVI */
1239 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVO ;
1240 strLength = WNI_CFG_EDCA_WME_ACVI_LEN;
1241 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1242 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVO, (tANI_U8 *)configDataValue,
1243 &strLength) != eSIR_SUCCESS)
1244 {
1245 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1246 "Failed to get value for WNI_CFG_EDCA_WME_ACVI");
1247 goto handle_failure;
1248 }
1249 tlvStruct->length = strLength;
1250 /* calculate the pad bytes to have the CFG in aligned format */
1251 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1252 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1253 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1254 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1255 /* QWLAN_HAL_CFG_EDCA_WMM_ACVO */
1256 tlvStruct->type = QWLAN_HAL_CFG_EDCA_WMM_ACVI ;
1257 strLength = WNI_CFG_EDCA_WME_ACVO_LEN;
1258 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1259 if(wlan_cfgGetStr(pMac, WNI_CFG_EDCA_WME_ACVI, (tANI_U8 *)configDataValue,
1260 &strLength) != eSIR_SUCCESS)
1261 {
1262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1263 "Failed to get value for WNI_CFG_EDCA_WME_ACVO");
1264 goto handle_failure;
1265 }
1266 tlvStruct->length = strLength;
1267 /* calculate the pad bytes to have the CFG in aligned format */
1268 tlvStruct->padBytes = ALIGNED_WORD_SIZE -
1269 (tlvStruct->length & (ALIGNED_WORD_SIZE - 1));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1270 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1271 + sizeof(tHalCfg) + tlvStruct->length + tlvStruct->padBytes) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1272 /* QWLAN_HAL_CFG_BA_THRESHOLD_HIGH */
1273 tlvStruct->type = QWLAN_HAL_CFG_BA_THRESHOLD_HIGH ;
1274 tlvStruct->length = sizeof(tANI_U32);
1275 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1276 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_THRESHOLD_HIGH, configDataValue)
1277 != eSIR_SUCCESS)
1278 {
1279 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1280 "Failed to get value for WNI_CFG_BA_THRESHOLD_HIGH");
1281 goto handle_failure;
1282 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1283 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1284 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1285 /* QWLAN_HAL_CFG_MAX_BA_BUFFERS */
1286 tlvStruct->type = QWLAN_HAL_CFG_MAX_BA_BUFFERS ;
1287 tlvStruct->length = sizeof(tANI_U32);
1288 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1289 if(wlan_cfgGetInt(pMac, WNI_CFG_MAX_BA_BUFFERS, configDataValue)
1290 != eSIR_SUCCESS)
1291 {
1292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1293 "Failed to get value for WNI_CFG_MAX_BA_BUFFERS");
1294 goto handle_failure;
1295 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1296 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1297 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1298 /* QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE */
1299 tlvStruct->type = QWLAN_HAL_CFG_DYNAMIC_PS_POLL_VALUE ;
1300 tlvStruct->length = sizeof(tANI_U32);
1301 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1302 if(wlan_cfgGetInt(pMac, WNI_CFG_DYNAMIC_PS_POLL_VALUE, configDataValue)
1303 != eSIR_SUCCESS)
1304 {
1305 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1306 "Failed to get value for WNI_CFG_DYNAMIC_PS_POLL_VALUE");
1307 goto handle_failure;
1308 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1309 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1310 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1311 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI */
1312 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI ;
1313 tlvStruct->length = sizeof(tANI_U32);
1314 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1315 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI, configDataValue)
1316 != eSIR_SUCCESS)
1317 {
1318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1319 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI");
1320 goto handle_failure;
1321 }
1322 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1323 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1324 /* QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS */
1325 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS ;
1326 tlvStruct->length = sizeof(tANI_U32);
1327 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1328 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS, configDataValue)
1329 != eSIR_SUCCESS)
1330 {
1331 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1332 "Failed to get value for WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS");
1333 goto handle_failure;
1334 }
1335 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1336 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1337 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI */
1338 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI ;
1339 tlvStruct->length = sizeof(tANI_U32);
1340 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1341 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI, configDataValue)
1342 != eSIR_SUCCESS)
1343 {
1344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1345 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI");
1346 goto handle_failure;
1347 }
1348 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1349 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1350 /* QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS */
1351 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS ;
1352 tlvStruct->length = sizeof(tANI_U32);
1353 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1354 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS, configDataValue)
1355 != eSIR_SUCCESS)
1356 {
1357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1358 "Failed to get value for WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS");
1359 goto handle_failure;
1360 }
1361 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1362 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1363 /* QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN */
1364 tlvStruct->type = QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN ;
1365 tlvStruct->length = sizeof(tANI_U32);
1366 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1367 if(wlan_cfgGetInt(pMac, WNI_CFG_TELE_BCN_WAKEUP_EN, configDataValue)
1368 != eSIR_SUCCESS)
1369 {
1370 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1371 "Failed to get value for WNI_CFG_TELE_BCN_WAKEUP_EN");
1372 goto handle_failure;
1373 }
1374 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1375 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1376 /* QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD */
1377 tlvStruct->type = QWLAN_HAL_CFG_INFRA_STA_KEEP_ALIVE_PERIOD ;
1378 tlvStruct->length = sizeof(tANI_U32);
1379 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1380 if(wlan_cfgGetInt(pMac, WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD, configDataValue)
1381 != eSIR_SUCCESS)
1382 {
1383 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1384 "Failed to get value for WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD");
1385 goto handle_failure;
1386 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1387 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1388 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1389 /*QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE*/
1390 tlvStruct->type = QWLAN_HAL_CFG_TX_PWR_CTRL_ENABLE ;
1391 tlvStruct->length = sizeof(tANI_U32);
1392 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1393 if(wlan_cfgGetInt(pMac, WNI_CFG_TX_PWR_CTRL_ENABLE, configDataValue)
1394 != eSIR_SUCCESS)
1395 {
1396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1397 "Failed to get value for WNI_CFG_TX_PWR_CTRL_ENABLE");
1398 goto handle_failure;
1399 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1400 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1401 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1402 /* QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP */
1403 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP ;
1404 tlvStruct->length = sizeof(tANI_U32);
1405 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1406 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_CLOSE_LOOP, configDataValue)
1407 != eSIR_SUCCESS)
1408 {
1409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1410 "Failed to get value for WNI_CFG_ENABLE_CLOSE_LOOP");
1411 goto handle_failure;
1412 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1413 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1414 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1415 /* [COEX] strictly speaking, the Coex parameters are not part of the WLAN_CFG_FILE binary,
1416 * but are from the WLAN_INI_FILE file. However, this is the only parameter download routine
1417 * into FW, so the parameters are added here.
1418 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1419 /* [COEX] QWLAN_HAL_CFG_BTC_EXECUTION_MODE */
1420 tlvStruct->type = QWLAN_HAL_CFG_BTC_EXECUTION_MODE ;
1421 tlvStruct->length = sizeof(tANI_U32);
1422 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1423 *configDataValue = pMac->btc.btcConfig.btcExecutionMode;
1424 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1425 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1426 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK */
1427 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_BT_SLOTS_TO_BLOCK ;
1428 tlvStruct->length = sizeof(tANI_U32);
1429 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1430 *configDataValue = pMac->btc.btcConfig.btcConsBtSlotsToBlockDuringDhcp;
1431 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1432 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1433 /* [COEX] QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS */
1434 tlvStruct->type = QWLAN_HAL_CFG_BTC_A2DP_DHCP_BT_SUB_INTERVALS ;
1435 tlvStruct->length = sizeof(tANI_U32);
1436 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1437 *configDataValue = pMac->btc.btcConfig.btcA2DPBtSubIntervalsDuringDhcp;
1438 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1439 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1440 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT */
1441 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_BT ;
1442 tlvStruct->length = sizeof(tANI_U32);
1443 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1444 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqBt;
1445 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1446 + sizeof(tHalCfg) + tlvStruct->length) ;
1447
1448 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT */
1449 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_BT ;
1450 tlvStruct->length = sizeof(tANI_U32);
1451 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1452 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageBt;
1453 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1454 + sizeof(tHalCfg) + tlvStruct->length) ;
1455
1456 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT */
1457 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_BT ;
1458 tlvStruct->length = sizeof(tANI_U32);
1459 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1460 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnBt;
1461 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1462 + sizeof(tHalCfg) + tlvStruct->length) ;
1463
1464 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT */
1465 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_BT ;
1466 tlvStruct->length = sizeof(tANI_U32);
1467 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1468 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeBt;
1469 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1470 + sizeof(tHalCfg) + tlvStruct->length) ;
1471
1472 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN */
1473 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_INQ_WLAN ;
1474 tlvStruct->length = sizeof(tANI_U32);
1475 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1476 *configDataValue = pMac->btc.btcConfig.btcStaticLenInqWlan;
1477 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1478 + sizeof(tHalCfg) + tlvStruct->length) ;
1479
1480 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN */
1481 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_PAGE_WLAN ;
1482 tlvStruct->length = sizeof(tANI_U32);
1483 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1484 *configDataValue = pMac->btc.btcConfig.btcStaticLenPageWlan;
1485 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1486 + sizeof(tHalCfg) + tlvStruct->length) ;
1487
1488 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN */
1489 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_CONN_WLAN ;
1490 tlvStruct->length = sizeof(tANI_U32);
1491 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1492 *configDataValue = pMac->btc.btcConfig.btcStaticLenConnWlan;
1493 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1494 + sizeof(tHalCfg) + tlvStruct->length) ;
1495
1496 /* [COEX] QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN */
1497 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_LEN_LE_WLAN ;
1498 tlvStruct->length = sizeof(tANI_U32);
1499 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1500 *configDataValue = pMac->btc.btcConfig.btcStaticLenLeWlan;
1501 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1502 + sizeof(tHalCfg) + tlvStruct->length) ;
1503
1504 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT */
1505 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_BT ;
1506 tlvStruct->length = sizeof(tANI_U32);
1507 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1508 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenBt;
1509 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1510 + sizeof(tHalCfg) + tlvStruct->length) ;
1511
1512 /* [COEX] QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN */
1513 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_MAX_LEN_WLAN ;
1514 tlvStruct->length = sizeof(tANI_U32);
1515 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1516 *configDataValue = pMac->btc.btcConfig.btcDynMaxLenWlan;
1517 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1518 + sizeof(tHalCfg) + tlvStruct->length) ;
1519
1520 /* [COEX] QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC */
1521 tlvStruct->type = QWLAN_HAL_CFG_BTC_MAX_SCO_BLOCK_PERC ;
1522 tlvStruct->length = sizeof(tANI_U32);
1523 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1524 *configDataValue = pMac->btc.btcConfig.btcMaxScoBlockPerc;
1525 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1526 + sizeof(tHalCfg) + tlvStruct->length) ;
1527
1528 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP */
1529 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_A2DP ;
1530 tlvStruct->length = sizeof(tANI_U32);
1531 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1532 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnA2dp;
1533 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1534 + sizeof(tHalCfg) + tlvStruct->length) ;
1535
1536 /* [COEX] QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO */
1537 tlvStruct->type = QWLAN_HAL_CFG_BTC_DHCP_PROT_ON_SCO ;
1538 tlvStruct->length = sizeof(tANI_U32);
1539 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1540 *configDataValue = pMac->btc.btcConfig.btcDhcpProtOnSco;
1541 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1542 + sizeof(tHalCfg) + tlvStruct->length) ;
1543
Wilson Tsaof8b37942013-09-06 10:49:00 -0700[diff] [blame]1544 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_VICTIM; i++)
1545 {
1546 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WAN_FREQ */
1547 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WAN_FREQ + i*4;
1548 tlvStruct->length = sizeof(tANI_U32);
1549 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1550 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWANFreq[i];
1551 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1552 + sizeof(tHalCfg) + tlvStruct->length) ;
1553
1554 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_WLAN_FREQ */
1555 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_WLAN_FREQ + i*4;
1556 tlvStruct->length = sizeof(tANI_U32);
1557 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1558 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimWLANFreq[i];
1559 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1560 + sizeof(tHalCfg) + tlvStruct->length) ;
1561
1562 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG */
1563 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG + i*4;
1564 tlvStruct->length = sizeof(tANI_U32);
1565 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1566 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig[i];
1567 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1568 + sizeof(tHalCfg) + tlvStruct->length) ;
1569
1570 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_VX_CONFIG2 */
1571 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_V1_CONFIG2 + i*4;
1572 tlvStruct->length = sizeof(tANI_U32);
1573 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1574 *configDataValue = pMac->btc.btcConfig.mwsCoexVictimConfig2[i];
1575 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1576 + sizeof(tHalCfg) + tlvStruct->length) ;
1577 }
1578
1579 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF */
1580 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_MODEM_BACKOFF ;
1581 tlvStruct->length = sizeof(tANI_U32);
1582 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1583 *configDataValue = pMac->btc.btcConfig.mwsCoexModemBackoff;
1584 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1585 + sizeof(tHalCfg) + tlvStruct->length) ;
1586
1587 for (i = 0; i < QWLAN_HAL_CFG_MWS_COEX_MAX_CONFIG; i++)
1588 {
1589 /* [COEX] QWLAN_HAL_CFG_MWS_COEX_CONFIGX */
1590 tlvStruct->type = QWLAN_HAL_CFG_MWS_COEX_CONFIG1 + i;
1591 tlvStruct->length = sizeof(tANI_U32);
1592 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1593 *configDataValue = pMac->btc.btcConfig.mwsCoexConfig[i];
1594 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1595 + sizeof(tHalCfg) + tlvStruct->length) ;
1596 }
1597
1598 /* [COEX] QWLAN_HAL_CFG_SAR_POWER_BACKOFF */
1599 tlvStruct->type = QWLAN_HAL_CFG_SAR_POWER_BACKOFF ;
1600 tlvStruct->length = sizeof(tANI_U32);
1601 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1602 *configDataValue = pMac->btc.btcConfig.SARPowerBackoff;
1603 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1604 + sizeof(tHalCfg) + tlvStruct->length) ;
1605
Jeff Johnson32d95a32012-09-10 13:15:23 -0700[diff] [blame]1606 /* QWLAN_HAL_CFG_WCNSS_API_VERSION */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]1607 tlvStruct->type = QWLAN_HAL_CFG_WCNSS_API_VERSION ;
1608 tlvStruct->length = sizeof(tANI_U32);
1609 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1610 WDI_GetWcnssCompiledApiVersion(&wcnssCompiledApiVersion);
1611 *configDataValue = WLAN_HAL_CONSTRUCT_API_VERSION(wcnssCompiledApiVersion.major,
1612 wcnssCompiledApiVersion.minor,
1613 wcnssCompiledApiVersion.version,
1614 wcnssCompiledApiVersion.revision);
1615 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1616 + sizeof(tHalCfg) + tlvStruct->length) ;
1617
Jeff Johnsond13512a2012-07-17 11:42:19 -0700[diff] [blame]1618 /* QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT */
1619 tlvStruct->type = QWLAN_HAL_CFG_AP_KEEPALIVE_TIMEOUT ;
1620 tlvStruct->length = sizeof(tANI_U32);
1621 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1622 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_KEEP_ALIVE_TIMEOUT,
1623 configDataValue ) != eSIR_SUCCESS)
1624 {
1625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1626 "Failed to get value for WNI_CFG_AP_KEEP_ALIVE_TIMEOUT");
1627 goto handle_failure;
1628 }
1629
1630 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1631 + sizeof(tHalCfg) + tlvStruct->length) ;
1632 /* QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT */
1633 tlvStruct->type = QWLAN_HAL_CFG_GO_KEEPALIVE_TIMEOUT ;
1634 tlvStruct->length = sizeof(tANI_U32);
1635 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1636 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_KEEP_ALIVE_TIMEOUT,
1637 configDataValue ) != eSIR_SUCCESS)
1638 {
1639 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1640 "Failed to get value for WNI_CFG_GO_KEEP_ALIVE_TIMEOUT");
1641 goto handle_failure;
1642 }
1643
1644 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1645 + sizeof(tHalCfg) + tlvStruct->length) ;
1646
1647 /* QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST */
1648 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MC_ADDR_LIST;
1649 tlvStruct->length = sizeof(tANI_U32);
1650 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1651 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MC_ADDR_LIST, configDataValue)
1652 != eSIR_SUCCESS)
1653 {
1654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1655 "Failed to get value for WNI_CFG_ENABLE_MC_ADDR_LIST");
1656 goto handle_failure;
1657 }
1658
1659 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1660 + sizeof(tHalCfg) + tlvStruct->length) ;
1661
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]1662 /* QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION */
1663 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION ;
1664 tlvStruct->length = sizeof(tANI_U32);
1665 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1666 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_LPWR_IMG_TRANSITION, configDataValue)
1667 != eSIR_SUCCESS)
1668 {
1669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1670 "Failed to get value for WNI_CFG_ENABLE_LPWR_IMG_TRANSITION");
1671 goto handle_failure;
1672 }
1673
1674 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1675 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]1676#ifdef WLAN_SOFTAP_VSTA_FEATURE
1677 tlvStruct->type = QWLAN_HAL_CFG_MAX_ASSOC_LIMIT;
1678 tlvStruct->length = sizeof(tANI_U32);
1679 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1680 if(wlan_cfgGetInt(pMac, WNI_CFG_ASSOC_STA_LIMIT, configDataValue)
1681 != eSIR_SUCCESS)
1682 {
1683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1684 "Failed to get value for WNI_CFG_ASSOC_STA_LIMIT");
1685 goto handle_failure;
1686 }
1687
1688 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1689 + sizeof(tHalCfg) + tlvStruct->length) ;
1690#endif
1691
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]1692 /* QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER */
1693 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_MCC_ADAPTIVE_SCHEDULER;
1694 tlvStruct->length = sizeof(tANI_U32);
1695 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1696
1697 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, configDataValue)
1698 != eSIR_SUCCESS)
1699 {
1700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1701 "Failed to get value for WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
1702 goto handle_failure;
1703 }
1704
1705 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1706 + sizeof(tHalCfg) + tlvStruct->length) ;
1707
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1708/* QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT */
1709 tlvStruct->type = QWLAN_HAL_CFG_AP_LINK_MONITOR_TIMEOUT ;
1710 tlvStruct->length = sizeof(tANI_U32);
1711 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1712 if(wlan_cfgGetInt(pMac, WNI_CFG_AP_LINK_MONITOR_TIMEOUT,
1713 configDataValue ) != eSIR_SUCCESS)
1714 {
1715 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1716 "Failed to get value for WNI_CFG_AP_LINK_MONITOR_TIMEOUT");
1717 goto handle_failure;
1718 }
1719
1720 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1721 + sizeof(tHalCfg) + tlvStruct->length) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1722#ifdef FEATURE_WLAN_TDLS
1723 /* QWLAN_HAL_CFG_TDLS_PUAPSD_MASK */
1724 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_MASK;
1725 tlvStruct->length = sizeof(tANI_U32);
1726 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1727 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK,
1728 configDataValue ) != eSIR_SUCCESS)
1729 {
1730 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1731 "Failed to get value for WNI_CFG_TDLS_QOS_WMM_UAPSD_MASK");
1732 goto handle_failure;
1733 }
1734 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1735 + sizeof(tHalCfg) + tlvStruct->length) ;
1736
1737 /* QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE */
1738 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_BUFFER_STA_CAPABLE;
1739 tlvStruct->length = sizeof(tANI_U32);
1740 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1741 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_BUF_STA_ENABLED,
1742 configDataValue ) != eSIR_SUCCESS)
1743 {
1744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1745 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1746 goto handle_failure;
1747 }
1748 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1749 + sizeof(tHalCfg) + tlvStruct->length) ;
1750 /* QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME */
1751 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_INACTIVITY_TIME;
1752 tlvStruct->length = sizeof(tANI_U32);
1753 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1754 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_PUAPSD_INACT_TIME,
1755 configDataValue ) != eSIR_SUCCESS)
1756 {
1757 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1758 "Failed to get value for WNI_CFG_TDLS_PUAPSD_INACT_TIME");
1759 goto handle_failure;
1760 }
1761 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1762 + sizeof(tHalCfg) + tlvStruct->length) ;
1763 /* QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP */
1764 tlvStruct->type = QWLAN_HAL_CFG_TDLS_PUAPSD_RX_FRAME_THRESHOLD_IN_SP;
1765 tlvStruct->length = sizeof(tANI_U32);
1766 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1767 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_RX_FRAME_THRESHOLD,
1768 configDataValue ) != eSIR_SUCCESS)
1769 {
1770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1771 "Failed to get value for WNI_CFG_TDLS_RX_FRAME_THRESHOLD");
1772 goto handle_failure;
1773 }
1774 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1775 + sizeof(tHalCfg) + tlvStruct->length) ;
Naresh Jayaramf73f3762014-02-04 16:13:20 +0530[diff] [blame]1776 /* QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE */
1777 tlvStruct->type = QWLAN_HAL_CFG_TDLS_OFF_CHANNEL_CAPABLE;
1778 tlvStruct->length = sizeof(tANI_U32);
1779 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1780 if(wlan_cfgGetInt(pMac, WNI_CFG_TDLS_OFF_CHANNEL_ENABLED,
1781 configDataValue ) != eSIR_SUCCESS)
1782 {
1783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1784 "Failed to get value for WNI_CFG_TDLS_BUF_STA_ENABLED");
1785 goto handle_failure;
1786 }
1787 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1788 + sizeof(tHalCfg) + tlvStruct->length) ;
1789
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]1790#endif
Sejal Chauhanbcde8bc2013-03-04 18:06:36 +0530[diff] [blame]1791
Sudhir Sattayappa Kohallida1be202013-07-11 12:04:30 -0700[diff] [blame]1792 /* QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN */
1793 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_ADAPTIVE_RX_DRAIN_FEATURE ;
1794 tlvStruct->length = sizeof(tANI_U32);
1795 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1796 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_ADAPT_RX_DRAIN,
1797 configDataValue ) != eSIR_SUCCESS)
1798 {
1799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1800 "Failed to get value for WNI_CFG_ENABLE_ADAPT_RX_DRAIN");
1801 goto handle_failure;
1802 }
1803
1804 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1805 + sizeof(tHalCfg) + tlvStruct->length) ;
Yue Ma0fd23872013-08-01 15:56:47 -0700[diff] [blame]1806
1807 /* QWLAN_HAL_CFG_FLEX_CONNECT_POWER_FACTOR */
1808 tlvStruct->type = QWLAN_HAL_CFG_FLEXCONNECT_POWER_FACTOR;
1809 tlvStruct->length = sizeof(tANI_U32);
1810 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1811 if(wlan_cfgGetInt(pMac, WNI_CFG_FLEX_CONNECT_POWER_FACTOR, configDataValue)
1812 != eSIR_SUCCESS)
1813 {
1814 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1815 "Failed to get value for WNI_CFG_FLEX_CONNECT_POWER_FACTOR");
1816 goto handle_failure;
1817 }
1818 tlvStruct = (tHalCfg *)(((tANI_U8 *) tlvStruct
1819 + sizeof(tHalCfg) + tlvStruct->length));
1820
Madan Mohan Koyyalamudica454572013-08-07 19:57:03 +0530[diff] [blame]1821 /* QWLAN_HAL_CFG_ANTENNA_DIVERSITY */
1822 tlvStruct->type = QWLAN_HAL_CFG_ANTENNA_DIVERSITY;
1823 tlvStruct->length = sizeof(tANI_U32);
1824 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1825 if (wlan_cfgGetInt(pMac, WNI_CFG_ANTENNA_DIVESITY,
1826 configDataValue ) != eSIR_SUCCESS)
1827 {
1828 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1829 "Failed to get value for WNI_CFG_ANTENNA_DIVESITY");
1830 goto handle_failure;
1831 }
1832
1833 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1834 + sizeof(tHalCfg) + tlvStruct->length) ;
1835
Madan Mohan Koyyalamudi2558bc92013-08-24 16:54:31 +0530[diff] [blame]1836 /* QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT */
1837 tlvStruct->type = QWLAN_HAL_CFG_GO_LINK_MONITOR_TIMEOUT ;
1838 tlvStruct->length = sizeof(tANI_U32);
1839 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1840 if(wlan_cfgGetInt(pMac, WNI_CFG_GO_LINK_MONITOR_TIMEOUT,
1841 configDataValue ) != eSIR_SUCCESS)
1842 {
1843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1844 "Failed to get value for WNI_CFG_GO_LINK_MONITOR_TIMEOUT");
1845 goto handle_failure;
1846 }
1847 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1848 + sizeof(tHalCfg) + tlvStruct->length) ;
1849
Kiet Lam4bbd3cb2013-11-07 20:03:49 +0530[diff] [blame]1850 /* QWLAN_HAL_CFG_ATH_DISABLE */
1851 tlvStruct->type = QWLAN_HAL_CFG_ATH_DISABLE ;
1852 tlvStruct->length = sizeof(tANI_U32);
1853 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1854 if(wlan_cfgGetInt(pMac, WNI_CFG_ATH_DISABLE,
1855 configDataValue ) != eSIR_SUCCESS)
1856 {
1857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1858 "Failed to get value for WNI_CFG_ATH_DISABLE");
1859 goto handle_failure;
1860 }
1861 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1862 + sizeof(tHalCfg) + tlvStruct->length) ;
1863
c_hpothu6d7dc922013-12-02 12:36:41 +0530[diff] [blame]1864 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_WLAN_LEN */
1865 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1866 tlvStruct->length = sizeof(tANI_U32);
1867 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1868 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_WLAN_LEN,
1869 configDataValue ) != eSIR_SUCCESS)
1870 {
1871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1872 "Failed to get value for WNI_CFG_BTC_ACTIVE_WLAN_LEN");
1873 goto handle_failure;
1874 }
1875 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1876 + sizeof(tHalCfg) + tlvStruct->length) ;
1877
1878 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1879 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1880 tlvStruct->length = sizeof(tANI_U32);
1881 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1882 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_ACTIVE_BT_LEN,
1883 configDataValue ) != eSIR_SUCCESS)
1884 {
1885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1886 "Failed to get value for WNI_CFG_BTC_ACTIVE_BT_LEN");
1887 goto handle_failure;
1888 }
1889 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1890 + sizeof(tHalCfg) + tlvStruct->length) ;
1891
1892 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN */
1893 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN ;
1894 tlvStruct->length = sizeof(tANI_U32);
1895 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1896 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN,
1897 configDataValue ) != eSIR_SUCCESS)
1898 {
1899 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1900 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_WLAN_LEN");
1901 goto handle_failure;
1902 }
1903 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1904 + sizeof(tHalCfg) + tlvStruct->length) ;
1905
1906 /* QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_BTC_ACTIVE_BT_LEN */
1907 tlvStruct->type = QWLAN_HAL_CFG_BTC_SAP_STATIC_OPP_WLAN_ACTIVE_BT_LEN ;
1908 tlvStruct->length = sizeof(tANI_U32);
1909 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1910 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_SAP_ACTIVE_BT_LEN,
1911 configDataValue ) != eSIR_SUCCESS)
1912 {
1913 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1914 "Failed to get value for WNI_CFG_BTC_SAP_ACTIVE_BT_LEN");
1915 goto handle_failure;
1916 }
1917 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1918 + sizeof(tHalCfg) + tlvStruct->length) ;
1919
AnjaneeDevi Kapparapu50239e32014-01-07 18:09:33 +0530[diff] [blame]1920 /* QWLAN_HAL_CFG_ASD_PROBE_INTERVAL */
1921 tlvStruct->type = QWLAN_HAL_CFG_ASD_PROBE_INTERVAL ;
1922 tlvStruct->length = sizeof(tANI_U32);
1923 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1924 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_PROBE_INTERVAL,
1925 configDataValue ) != eSIR_SUCCESS)
1926 {
1927 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1928 "Failed to get value for WNI_CFG_ASD_PROBE_INTERVAL");
1929 goto handle_failure;
1930 }
1931 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1932 + sizeof(tHalCfg) + tlvStruct->length) ;
1933
1934 /* QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD */
1935 tlvStruct->type = QWLAN_HAL_CFG_ASD_TRIGGER_THRESHOLD ;
1936 tlvStruct->length = sizeof(tANI_U32);
1937 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1938 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_TRIGGER_THRESHOLD,
1939 configDataValue ) != eSIR_SUCCESS)
1940 {
1941 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1942 "Failed to get value for WNI_CFG_ASD_TRIGGER_THRESHOLD");
1943 goto handle_failure;
1944 }
1945 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1946 + sizeof(tHalCfg) + tlvStruct->length) ;
1947
1948 /* QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD */
1949 tlvStruct->type = QWLAN_HAL_CFG_ASD_RTT_RSSI_HYST_THRESHOLD ;
1950 tlvStruct->length = sizeof(tANI_U32);
1951 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1952 if(wlan_cfgGetInt(pMac, WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD,
1953 configDataValue ) != eSIR_SUCCESS)
1954 {
1955 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1956 "Failed to get value for WNI_CFG_ASD_RTT_RSSI_HYST_THRESHOLD");
1957 goto handle_failure;
1958 }
1959 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1960 + sizeof(tHalCfg) + tlvStruct->length) ;
1961
Leela Venkata Kiran Kumar Reddy Chirala22c159b2013-12-23 18:19:13 -0800[diff] [blame]1962 /* QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO */
1963 tlvStruct->type = QWLAN_HAL_CFG_BTC_CTS2S_ON_STA_DURING_SCO ;
1964 tlvStruct->length = sizeof(tANI_U32);
1965 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1966 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CTS2S_DURING_SCO,
1967 configDataValue ) != eSIR_SUCCESS)
1968 {
1969 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1970 "Failed to get value for WNI_CFG_BTC_CTS2S_DURING_SCO");
1971 goto handle_failure;
1972 }
1973 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1974 + sizeof(tHalCfg) + tlvStruct->length) ;
1975
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1976 /* QWLAN_HAL_CFG_RA_FILTER_ENABLE */
1977 tlvStruct->type = QWLAN_HAL_CFG_RA_FILTER_ENABLE ;
1978 tlvStruct->length = sizeof(tANI_U32);
1979 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1980
1981 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_FILTER_ENABLE,
1982 configDataValue ) != eSIR_SUCCESS)
1983 {
1984 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
1985 "Failed to get value for WNI_CFG_RA_FILTER_ENABLE");
1986 goto handle_failure;
1987 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]1988 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
1989 + sizeof(tHalCfg) + tlvStruct->length) ;
1990
1991 /* QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL */
1992 tlvStruct->type = QWLAN_HAL_CFG_RA_RATE_LIMIT_INTERVAL ;
1993 tlvStruct->length = sizeof(tANI_U32);
1994 configDataValue = (tANI_U32 *)(tlvStruct + 1);
1995
1996 if (wlan_cfgGetInt(pMac, WNI_CFG_RA_RATE_LIMIT_INTERVAL,
1997 configDataValue ) != eSIR_SUCCESS)
1998 {
1999 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2000 "Failed to get value for WNI_CFG_RA_RATE_LIMIT_INTERVAL");
2001 goto handle_failure;
2002 }
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]2003 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2004 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]2005
c_hpothu2d0f1c42014-04-01 18:38:51 +0530[diff] [blame]2006 /* QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE */
2007 tlvStruct->type = QWLAN_HAL_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE ;
2008 tlvStruct->length = sizeof(tANI_U32);
2009 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2010
2011 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE,
2012 configDataValue ) != eSIR_SUCCESS)
2013 {
2014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2015 "Failed to get value for WNI_CFG_BTC_FATAL_HID_NSNIFF_BLK_GUIDANCE");
2016 goto handle_failure;
2017 }
2018 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2019 + sizeof(tHalCfg) + tlvStruct->length) ;
2020
2021 /* QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE */
2022 tlvStruct->type = QWLAN_HAL_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE ;
2023 tlvStruct->length = sizeof(tANI_U32);
2024 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2025
2026 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE,
2027 configDataValue ) != eSIR_SUCCESS)
2028 {
2029 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2030 "Failed to get value for WNI_CFG_BTC_CRITICAL_HID_NSNIFF_BLK_GUIDANCE");
2031 goto handle_failure;
2032 }
2033 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2034 + sizeof(tHalCfg) + tlvStruct->length) ;
2035
2036 /* QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD */
2037 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD ;
2038 tlvStruct->length = sizeof(tANI_U32);
2039 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2040
2041 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD,
2042 configDataValue ) != eSIR_SUCCESS)
2043 {
2044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2045 "Failed to get value for WNI_CFG_BTC_DYN_A2DP_TX_QUEUE_THOLD");
2046 goto handle_failure;
2047 }
2048 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2049 + sizeof(tHalCfg) + tlvStruct->length) ;
2050
2051 /* QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD */
2052 tlvStruct->type = QWLAN_HAL_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD ;
2053 tlvStruct->length = sizeof(tANI_U32);
2054 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2055
2056 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD,
2057 configDataValue ) != eSIR_SUCCESS)
2058 {
2059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2060 "Failed to get value for WNI_CFG_BTC_DYN_OPP_TX_QUEUE_THOLD");
2061 goto handle_failure;
2062 }
c_hpothu5bd1ae42014-03-07 20:28:22 +0530[diff] [blame]2063 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2064 + sizeof(tHalCfg) + tlvStruct->length) ;
2065
Mihir Shetec34258c2014-07-30 17:50:27 +0530[diff] [blame]2066 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP */
2067 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_SP ;
2068 tlvStruct->length = sizeof(tANI_U32);
2069 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2070
2071 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_SP,
2072 configDataValue ) != eSIR_SUCCESS)
2073 {
2074 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2075 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_SP");
2076 goto handle_failure;
2077 }
2078 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2079 + sizeof(tHalCfg) + tlvStruct->length) ;
2080
2081 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT */
2082 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT ;
2083 tlvStruct->length = sizeof(tANI_U32);
2084 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2085
2086 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT,
2087 configDataValue ) != eSIR_SUCCESS)
2088 {
2089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2090 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT");
2091 goto handle_failure;
2092 }
2093 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2094 + sizeof(tHalCfg) + tlvStruct->length) ;
2095
2096 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT */
2097 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT ;
2098 tlvStruct->length = sizeof(tANI_U32);
2099 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2100
2101 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT,
2102 configDataValue ) != eSIR_SUCCESS)
2103 {
2104 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2105 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT");
2106 goto handle_failure;
2107 }
2108 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2109 + sizeof(tHalCfg) + tlvStruct->length) ;
2110
2111 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW */
2112 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW ;
2113 tlvStruct->length = sizeof(tANI_U32);
2114 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2115
2116 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW,
2117 configDataValue ) != eSIR_SUCCESS)
2118 {
2119 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2120 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW");
2121 goto handle_failure;
2122 }
2123 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2124 + sizeof(tHalCfg) + tlvStruct->length) ;
2125
2126 /* QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW */
2127 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW ;
2128 tlvStruct->length = sizeof(tANI_U32);
2129 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2130
2131 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW,
2132 configDataValue ) != eSIR_SUCCESS)
2133 {
2134 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2135 "Failed to get value for WNI_CFG_MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW");
2136 goto handle_failure;
2137 }
2138 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2139 + sizeof(tHalCfg) + tlvStruct->length) ;
2140
2141 /* QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE */
2142 tlvStruct->type = QWLAN_HAL_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE ;
2143 tlvStruct->length = sizeof(tANI_U32);
2144 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2145
2146 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE,
2147 configDataValue ) != eSIR_SUCCESS)
2148 {
2149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2150 "Failed to get value for WNI_CFG_MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE");
2151 goto handle_failure;
2152 }
2153 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2154 + sizeof(tHalCfg) + tlvStruct->length) ;
2155
2156 /* QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS */
2157 tlvStruct->type = QWLAN_HAL_CFG_MAX_UAPSD_INACTIVITY_INTERVALS ;
2158 tlvStruct->length = sizeof(tANI_U32);
2159 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2160
2161 if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS,
2162 configDataValue ) != eSIR_SUCCESS)
2163 {
2164 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2165 "Failed to get value for WNI_CFG_MAX_UAPSD_INACTIVITY_INTERVALS");
2166 goto handle_failure;
2167 }
2168 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2169 + sizeof(tHalCfg) + tlvStruct->length) ;
2170
2171 /* QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS */
2172 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_DYNAMIC_WMMPS ;
2173 tlvStruct->length = sizeof(tANI_U32);
2174 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2175
2176 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_DYNAMIC_WMMPS,
2177 configDataValue ) != eSIR_SUCCESS)
2178 {
2179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2180 "Failed to get value for WNI_CFG_ENABLE_DYNAMIC_WMMPS");
2181 goto handle_failure;
2182 }
2183 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2184 + sizeof(tHalCfg) + tlvStruct->length) ;
c_hpothu03d961b2014-09-19 16:45:00 +0530[diff] [blame]2185
2186 /* QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE */
2187 tlvStruct->type = QWLAN_HAL_CFG_BURST_MODE_BE_TXOP_VALUE ;
2188 tlvStruct->length = sizeof(tANI_U32);
2189 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2190
2191 if (wlan_cfgGetInt(pMac, WNI_CFG_BURST_MODE_BE_TXOP_VALUE,
2192 configDataValue ) != eSIR_SUCCESS)
2193 {
2194 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2195 "Failed to get value for WNI_CFG_BURST_MODE_BE_TXOP_VALUE");
2196 goto handle_failure;
2197 }
2198 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2199 + sizeof(tHalCfg) + tlvStruct->length) ;
2200
Deepthi Gowri9025aa62014-11-07 19:45:36 +0530[diff] [blame]2201 /* QWLAN_HAL_CFG_ENABLE_DYNAMIC_RA_START_RATE */
2202 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_DYNAMIC_RA_START_RATE ;
2203 tlvStruct->length = sizeof(tANI_U32);
2204 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2205
2206 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_DYNAMIC_RA_START_RATE,
2207 configDataValue ) != eSIR_SUCCESS)
2208 {
2209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2210 "Failed to get value for WNI_CFG_ENABLE_DYNAMIC_RA_START_RATE");
2211 goto handle_failure;
2212 }
2213 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2214 + sizeof(tHalCfg) + tlvStruct->length) ;
2215
Naresh Jayaramf5bbe3f2014-12-29 18:32:47 +0530[diff] [blame]2216 /* QWLAN_HAL_CFG_BTC_FAST_WLAN_CONN_PREF */
2217 tlvStruct->type = QWLAN_HAL_CFG_BTC_FAST_WLAN_CONN_PREF ;
2218 tlvStruct->length = sizeof(tANI_U32);
2219 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2220
2221 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_FAST_WLAN_CONN_PREF,
2222 configDataValue ) != eSIR_SUCCESS)
2223 {
2224 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2225 "Failed to get value for WNI_CFG_BTC_FAST_WLAN_CONN_PREF");
2226 goto handle_failure;
2227 }
2228 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2229 + sizeof(tHalCfg) + tlvStruct->length) ;
Deepthi Gowri9025aa62014-11-07 19:45:36 +0530[diff] [blame]2230
jagadeeshaf2d0ce2015-03-31 11:45:30 +0530[diff] [blame]2231 /* QWLAN_HAL_CFG_ENABLE_RTSCTS_HTVHT */
2232 tlvStruct->type = QWLAN_HAL_CFG_ENABLE_RTSCTS_HTVHT;
2233 tlvStruct->length = sizeof(tANI_U32);
2234 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2235
2236 if (wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_RTSCTS_HTVHT,
2237 configDataValue ) != eSIR_SUCCESS)
2238 {
2239 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2240 "Failed to get value for WNI_CFG_ENABLE_RTSCTS_HTVHT");
2241 goto handle_failure;
2242 }
2243 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2244 + sizeof(tHalCfg) + tlvStruct->length) ;
2245
Sachin Ahuja41b61902015-06-18 18:32:15 +0530[diff] [blame]2246
2247 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN */
2248 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN ;
2249 tlvStruct->length = sizeof(tANI_U32);
2250 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2251
2252 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN,
2253 configDataValue ) != eSIR_SUCCESS)
2254 {
2255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2256 "Failed to get value for WNI_CFG_BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN");
2257 goto handle_failure;
2258 }
2259 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2260 + sizeof(tHalCfg) + tlvStruct->length) ;
2261
2262 /* QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_IDLE_BT_LEN */
2263 tlvStruct->type = QWLAN_HAL_CFG_BTC_STATIC_OPP_WLAN_IDLE_BT_LEN ;
2264 tlvStruct->length = sizeof(tANI_U32);
2265 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2266
2267 if (wlan_cfgGetInt(pMac, WNI_CFG_BTC_STATIC_OPP_WLAN_IDLE_BT_LEN,
2268 configDataValue ) != eSIR_SUCCESS)
2269 {
2270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2271 "Failed to get value for WNI_CFG_BTC_STATIC_OPP_WLAN_IDLE_BT_LEN");
2272 goto handle_failure;
2273 }
Sachin Ahuja41b61902015-06-18 18:32:15 +0530[diff] [blame]2274 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2275 + sizeof(tHalCfg) + tlvStruct->length) ;
2276
Hanumantha Reddy Pothula9a8ccab2015-07-03 14:33:17 +0530[diff] [blame]2277 /* QWLAN_HAL_CFG_LINK_FAIL_TIMEOUT */
2278 tlvStruct->type = QWLAN_HAL_CFG_LINK_FAIL_TIMEOUT ;
2279 tlvStruct->length = sizeof(tANI_U32);
2280 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2281
2282 if (wlan_cfgGetInt(pMac, WNI_CFG_LINK_FAIL_TIMEOUT,
2283 configDataValue ) != eSIR_SUCCESS)
2284 {
2285 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2286 "Failed to get value for WNI_CFG_LINK_FAIL_TIMEOUT");
2287 goto handle_failure;
2288 }
2289 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2290 + sizeof(tHalCfg) + tlvStruct->length) ;
2291
2292 /* QWLAN_HAL_CFG_LINK_FAIL_TX_CNT */
2293 tlvStruct->type = QWLAN_HAL_CFG_LINK_FAIL_TX_CNT ;
2294 tlvStruct->length = sizeof(tANI_U32);
2295 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2296
2297 if (wlan_cfgGetInt(pMac, WNI_CFG_LINK_FAIL_TX_CNT,
2298 configDataValue ) != eSIR_SUCCESS)
2299 {
2300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2301 "Failed to get value for WNI_CFG_LINK_FAIL_TX_CNT");
2302 goto handle_failure;
2303 }
2304 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2305 + sizeof(tHalCfg) + tlvStruct->length) ;
Sachin Ahuja41b61902015-06-18 18:32:15 +0530[diff] [blame]2306
Hanumantha Reddy Pothulae0216f92015-08-11 18:30:06 +0530[diff] [blame]2307 /* QWLAN_HAL_CFG_TOGGLE_ARP_BDRATES */
2308 tlvStruct->type = QWLAN_HAL_CFG_TOGGLE_ARP_BDRATES;
2309 tlvStruct->length = sizeof(tANI_U32);
2310 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2311
2312 if (wlan_cfgGetInt(pMac, WNI_CFG_TOGGLE_ARP_BDRATES,
2313 configDataValue ) != eSIR_SUCCESS)
2314 {
2315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2316 "Failed to get value for WNI_CFG_TOGGLE_ARP_BDRATES");
2317 goto handle_failure;
2318 }
2319 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2320 + sizeof(tHalCfg) + tlvStruct->length) ;
Mahesh A Saptasagarbeca12c2015-09-07 16:21:06 +0530[diff] [blame]2321 /* QWLAN_HAL_CFG_OPTIMIZE_CA_EVENT */
2322 tlvStruct->type = QWLAN_HAL_CFG_OPTIMIZE_CA_EVENT ;
2323 tlvStruct->length = sizeof(tANI_U32);
2324 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2325 if (wlan_cfgGetInt(pMac, WNI_CFG_OPTIMIZE_CA_EVENT,
2326 configDataValue ) != eSIR_SUCCESS)
2327 {
2328 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2329 "Failed to get value for WNI_CFG_OPTIMIZE_CA_EVENT");
2330 goto handle_failure;
2331 }
2332 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2333 + sizeof(tHalCfg) + tlvStruct->length) ;
Hanumantha Reddy Pothulae0216f92015-08-11 18:30:06 +0530[diff] [blame]2334
Padma, Santhosh Kumare2eb0fa2015-08-26 13:40:47 +0530[diff] [blame]2335 /* QWLAN_HAL_CFG_EXT_SCAN_CONC_MODE */
2336 tlvStruct->type = QWLAN_HAL_CFG_EXT_SCAN_CONC_MODE ;
2337 tlvStruct->length = sizeof(tANI_U32);
2338 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2339
2340 if (wlan_cfgGetInt(pMac, WNI_CFG_EXT_SCAN_CONC_MODE,
2341 configDataValue ) != eSIR_SUCCESS)
2342 {
2343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2344 "Failed to get value for WNI_CFG_EXT_SCAN_CONC_MODE");
2345 goto handle_failure;
2346 }
2347 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2348 + sizeof(tHalCfg) + tlvStruct->length) ;
2349
Sachin Ahujab4d7a292015-12-08 19:57:04 +0530[diff] [blame^]2350 /* QWLAN_HAL_CFG_BAR_WAKEUP_HOST_DISABLE */
2351 tlvStruct->type = QWLAN_HAL_CFG_BAR_WAKEUP_HOST_DISABLE;
2352 tlvStruct->length = sizeof(tANI_U32);
2353 configDataValue = (tANI_U32 *)(tlvStruct + 1);
2354
2355 if (wlan_cfgGetInt(pMac, WNI_CFG_DISABLE_BAR_WAKE_UP_HOST,
2356 configDataValue ) != eSIR_SUCCESS)
2357 {
2358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2359 "Failed to get value for WNI_CFG_DISABLE_BAR_WAKE_UP_HOST");
2360 goto handle_failure;
2361 }
2362 tlvStruct = (tHalCfg *)( (tANI_U8 *) tlvStruct
2363 + sizeof(tHalCfg) + tlvStruct->length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2364 wdiStartParams->usConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2365#ifdef WLAN_DEBUG
2366 {
2367 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2368 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2369 "****** Dumping CFG TLV ***** ");
2370 for (i=0; (i+7) < wdiStartParams->usConfigBufferLen; i+=8)
2371 {
2372 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2373 "%02x %02x %02x %02x %02x %02x %02x %02x",
2374 tlvStructStart[i],
2375 tlvStructStart[i+1],
2376 tlvStructStart[i+2],
2377 tlvStructStart[i+3],
2378 tlvStructStart[i+4],
2379 tlvStructStart[i+5],
2380 tlvStructStart[i+6],
2381 tlvStructStart[i+7]);
2382 }
2383 /* Dump the bytes in the last line*/
2384 for (; i < wdiStartParams->usConfigBufferLen; i++)
2385 {
2386 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2387 "%02x ",tlvStructStart[i]);
2388 }
2389 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
2390 "**************************** ");
2391 }
2392#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2393 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2394handle_failure:
2395 vos_mem_free(configParam);
2396 return VOS_STATUS_E_FAILURE;
2397}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2398/*
2399 * FUNCTION: WDA_wdiCompleteCB
2400 * call the voss call back function
2401 */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2402void WDA_stopCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2403{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2404 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2405 tWDA_CbContext *wdaContext;
2406
2407 if(NULL == pWdaParams)
2408 {
2409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2410 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2411 VOS_ASSERT(0) ;
2412 return ;
2413 }
2414
2415 wdaContext = (tWDA_CbContext *)pWdaParams->pWdaContext;
2416
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2417 if (NULL == wdaContext)
2418 {
2419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2420 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2421 return ;
2422 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2423
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2424 /* free the config structure */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2425 if(pWdaParams->wdaWdiApiMsgParam != NULL)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2426 {
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2427 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2428 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2429 vos_mem_free(pWdaParams);
2430
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2431 if(WDI_STATUS_SUCCESS != status)
2432 {
2433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2434 "WDI stop callback returned failure" );
2435 VOS_ASSERT(0) ;
2436 }
2437 else
2438 {
2439 wdaContext->wdaState = WDA_STOP_STATE;
2440 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2441
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2442 /* FTM Driver stop procedure should be synced.
2443 * Stop and Close will happen on same context */
2444 if (eDRIVER_TYPE_MFG == wdaContext->driverMode)
2445 {
2446 if (VOS_STATUS_SUCCESS != vos_event_set(&wdaContext->ftmStopDoneEvent))
2447 {
2448 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2449 "%s: FTM Stop Event Set Fail", __func__);
2450 VOS_ASSERT(0);
2451 }
2452 }
2453
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2454 /* Indicate VOSS about the start complete */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2455 vos_WDAComplete_cback(wdaContext->pVosContext);
2456
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2457 return ;
2458}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2459/*
2460 * FUNCTION: WDA_stop
2461 * call WDI_stop
2462 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2463VOS_STATUS WDA_stop(v_PVOID_t pVosContext, tANI_U8 reason)
2464{
2465 WDI_Status wdiStatus;
2466 VOS_STATUS status = VOS_STATUS_SUCCESS;
2467 WDI_StopReqParamsType *wdiStopReq;
2468 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2469 tWDA_ReqParams *pWdaParams ;
2470
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2471 if (NULL == pWDA)
2472 {
2473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2474 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2475 VOS_ASSERT(0);
2476 return VOS_STATUS_E_FAILURE;
2477 }
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2478 if (pWDA->wdiFailed == true)
2479 {
2480 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2481 "%s: WDI in failed state", __func__ );
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]2482 return VOS_STATUS_E_ALREADY;
2483 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2484
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2485 /* FTM mode stay START_STATE */
2486 if( (WDA_READY_STATE != pWDA->wdaState) &&
2487 (WDA_INIT_STATE != pWDA->wdaState) &&
2488 (WDA_START_STATE != pWDA->wdaState) )
2489 {
2490 VOS_ASSERT(0);
2491 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2492 wdiStopReq = (WDI_StopReqParamsType *)
2493 vos_mem_malloc(sizeof(WDI_StopReqParamsType));
2494 if(NULL == wdiStopReq)
2495 {
2496 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2497 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2498 VOS_ASSERT(0);
2499 return VOS_STATUS_E_NOMEM;
2500 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2501
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2502 wdiStopReq->wdiStopReason = reason;
2503 wdiStopReq->wdiReqStatusCB = NULL;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2504
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2505 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2506 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2507 {
2508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2509 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2510 VOS_ASSERT(0);
2511 vos_mem_free(wdiStopReq);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2512 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2513 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2514
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2515 if ( (eDRIVER_TYPE_MFG != pWDA->driverMode) &&
2516 (VOS_TRUE == pWDA->wdaTimersCreated))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2517 {
2518 wdaDestroyTimers(pWDA);
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2519 pWDA->wdaTimersCreated = VOS_FALSE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2520 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]2521
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2522 pWdaParams->wdaWdiApiMsgParam = (v_PVOID_t *)wdiStopReq;
2523 pWdaParams->wdaMsgParam = NULL;
2524 pWdaParams->pWdaContext = pWDA;
2525
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2526 /* call WDI stop */
2527 wdiStatus = WDI_Stop(wdiStopReq,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2528 (WDI_StopRspCb)WDA_stopCallback, pWdaParams);
2529
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2530 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
2531 {
2532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2533 "error in WDA Stop" );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]2534 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2535 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2536 status = VOS_STATUS_E_FAILURE;
2537 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2538
2539 /* FTM Driver stop procedure should be synced.
2540 * Stop and Close will happen on same context */
2541 if (eDRIVER_TYPE_MFG == pWDA->driverMode)
2542 {
2543 status = vos_wait_single_event(&pWDA->ftmStopDoneEvent,
2544 WDI_RESPONSE_TIMEOUT);
2545 if (status != VOS_STATUS_SUCCESS)
2546 {
2547 VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
2548 "%s: FTM Stop Timepoout", __func__);
2549 VOS_ASSERT(0);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2550 }
c_hpothu0d36bc42014-07-03 17:43:45 +0530[diff] [blame]2551 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]2552 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2553 return status;
2554}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2555/*
2556 * FUNCTION: WDA_close
2557 * call WDI_close and free the WDA context
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2558 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2559VOS_STATUS WDA_close(v_PVOID_t pVosContext)
2560{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2561 VOS_STATUS status = VOS_STATUS_SUCCESS;
2562 WDI_Status wstatus;
2563 VOS_STATUS vstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2564 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2565 if (NULL == wdaContext)
2566 {
2567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2568 "%s: Invoked with invalid wdaContext", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2569 return VOS_STATUS_E_FAILURE;
2570 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2571 if((WDA_INIT_STATE != wdaContext->wdaState) &&
2572 (WDA_STOP_STATE != wdaContext->wdaState))
2573 {
2574 VOS_ASSERT(0);
2575 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2576 /*call WDI close*/
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2577 wstatus = WDI_Close();
2578 if ( wstatus != WDI_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2579 {
2580 status = VOS_STATUS_E_FAILURE;
2581 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2582 wdaContext->wdaState = WDA_CLOSE_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2583 /* Destroy the events */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2584 vstatus = vos_event_destroy(&wdaContext->wdaWdiEvent);
2585 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2586 {
2587 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2588 "WDI Sync Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2589 status = VOS_STATUS_E_FAILURE;
2590 }
2591
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2592 vstatus = vos_event_destroy(&wdaContext->txFrameEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2593 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2594 {
2595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2596 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2597 status = VOS_STATUS_E_FAILURE;
2598 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2599 vstatus = vos_event_destroy(&wdaContext->suspendDataTxEvent);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2600 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2601 {
2602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2603 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2604 status = VOS_STATUS_E_FAILURE;
2605 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2606 vstatus = vos_event_destroy(&wdaContext->waitOnWdiIndicationCallBack);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2607 if(!VOS_IS_STATUS_SUCCESS(vstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2608 {
2609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2610 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2611 status = VOS_STATUS_E_FAILURE;
2612 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2613 /* free WDA context */
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]2614 vstatus = vos_free_context(pVosContext, VOS_MODULE_ID_WDA, wdaContext);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2615 if ( !VOS_IS_STATUS_SUCCESS(vstatus) )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2616 {
2617 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2618 "error in WDA close " );
2619 status = VOS_STATUS_E_FAILURE;
2620 }
2621 return status;
2622}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2623/*
2624 * FUNCTION: WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual
2625 * returns 1 if the compiled version is greater than or equal to the input version
2626 */
2627
2628uint8 WDA_IsWcnssWlanCompiledVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2629{
2630 VOS_STATUS status = VOS_STATUS_SUCCESS;
2631 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2632 tSirVersionType compiledVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2633 status = WDA_GetWcnssWlanCompiledVersion(vosContext, &compiledVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2634 if ((compiledVersion.major > major) || ((compiledVersion.major == major)&& (compiledVersion.minor > minor)) ||
2635 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version > version)) ||
2636 ((compiledVersion.major == major)&& (compiledVersion.minor == minor) &&(compiledVersion.version == version) &&
2637 (compiledVersion.revision >= revision)))
2638 return 1;
2639 else
2640 return 0;
2641}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2642/*
2643 * FUNCTION: WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual
2644 * returns 1 if the compiled version is greater than or equal to the input version
2645 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2646uint8 WDA_IsWcnssWlanReportedVersionGreaterThanOrEqual(uint8 major, uint8 minor, uint8 version, uint8 revision)
2647{
2648 VOS_STATUS status = VOS_STATUS_SUCCESS;
2649 v_CONTEXT_t vosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
2650 tSirVersionType reportedVersion;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2651 status = WDA_GetWcnssWlanReportedVersion(vosContext, &reportedVersion);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2652 if ((reportedVersion.major > major) || ((reportedVersion.major == major)&& (reportedVersion.minor > minor)) ||
2653 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version > version)) ||
2654 ((reportedVersion.major == major)&& (reportedVersion.minor == minor) &&(reportedVersion.version == version) &&
2655 (reportedVersion.revision >= revision)))
2656 return 1;
2657 else
2658 return 0;
2659}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2660/*
2661 * FUNCTION: WDA_GetWcnssWlanCompiledVersion
2662 * Returns the version of the WCNSS WLAN API with which the HOST
2663 * device driver was compiled
2664 */
2665VOS_STATUS WDA_GetWcnssWlanCompiledVersion(v_PVOID_t pvosGCtx,
2666 tSirVersionType *pVersion)
2667{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2668 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2669 if ((NULL == pvosGCtx) || (NULL == pVersion))
2670 {
2671 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2672 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2673 VOS_ASSERT(0);
2674 return VOS_STATUS_E_FAILURE;
2675 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2676 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2677 if (NULL == pWDA )
2678 {
2679 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2680 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2681 VOS_ASSERT(0);
2682 return VOS_STATUS_E_FAILURE;
2683 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2684 *pVersion = pWDA->wcnssWlanCompiledVersion;
2685 return VOS_STATUS_SUCCESS;
2686}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2687/*
2688 * FUNCTION: WDA_GetWcnssWlanReportedVersion
2689 * Returns the version of the WCNSS WLAN API with which the WCNSS
2690 * device driver was compiled
2691 */
2692VOS_STATUS WDA_GetWcnssWlanReportedVersion(v_PVOID_t pvosGCtx,
2693 tSirVersionType *pVersion)
2694{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2695 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2696 if ((NULL == pvosGCtx) || (NULL == pVersion))
2697 {
2698 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2699 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2700 VOS_ASSERT(0);
2701 return VOS_STATUS_E_FAILURE;
2702 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2703 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2704 if (NULL == pWDA )
2705 {
2706 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2707 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2708 VOS_ASSERT(0);
2709 return VOS_STATUS_E_FAILURE;
2710 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2711 *pVersion = pWDA->wcnssWlanReportedVersion;
2712 return VOS_STATUS_SUCCESS;
2713}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2714/*
2715 * FUNCTION: WDA_GetWcnssSoftwareVersion
2716 * Returns the WCNSS Software version string
2717 */
2718VOS_STATUS WDA_GetWcnssSoftwareVersion(v_PVOID_t pvosGCtx,
2719 tANI_U8 *pVersion,
2720 tANI_U32 versionBufferSize)
2721{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2722 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2723 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2724 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2725 if ((NULL == pvosGCtx) || (NULL == pVersion))
2726 {
2727 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2728 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2729 VOS_ASSERT(0);
2730 return VOS_STATUS_E_FAILURE;
2731 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2732 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2733 if (NULL == pWDA )
2734 {
2735 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2736 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2737 VOS_ASSERT(0);
2738 return VOS_STATUS_E_FAILURE;
2739 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2740 wpalMemoryCopy(pVersion, pWDA->wcnssSoftwareVersionString, versionBufferSize);
2741 return VOS_STATUS_SUCCESS;
2742}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2743/*
2744 * FUNCTION: WDA_GetWcnssHardwareVersion
2745 * Returns the WCNSS Hardware version string
2746 */
2747VOS_STATUS WDA_GetWcnssHardwareVersion(v_PVOID_t pvosGCtx,
2748 tANI_U8 *pVersion,
2749 tANI_U32 versionBufferSize)
2750{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2751 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2752 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2753 "%s: Entered", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2754 if ((NULL == pvosGCtx) || (NULL == pVersion))
2755 {
2756 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2757 "%s: Invoked with invalid parameter", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2758 VOS_ASSERT(0);
2759 return VOS_STATUS_E_FAILURE;
2760 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2761 pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
2762 if (NULL == pWDA )
2763 {
2764 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2765 "%s: Invalid WDA context", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2766 VOS_ASSERT(0);
2767 return VOS_STATUS_E_FAILURE;
2768 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2769 wpalMemoryCopy(pVersion, pWDA->wcnssHardwareVersionString, versionBufferSize);
2770 return VOS_STATUS_SUCCESS;
2771}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2772/*
2773 * FUNCTION: WDA_WniCfgDnld
2774 * Trigger CFG Download
2775 */
2776VOS_STATUS WDA_WniCfgDnld(tWDA_CbContext *pWDA)
2777{
2778 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2779 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnsonab81a082013-04-03 16:00:31 -0700[diff] [blame]2780
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2781 if (NULL == pMac )
2782 {
2783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2784 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2785 VOS_ASSERT(0);
2786 return VOS_STATUS_E_FAILURE;
2787 }
Sachin Ahujaa4b33a32014-06-18 13:22:00 +0530[diff] [blame]2788 processCfgDownloadReq(pMac);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2789 return vosStatus;
2790}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2791/* -----------------------------------------------------------------
2792 * WDI interface
2793 * -----------------------------------------------------------------
2794 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2795/*
2796 * FUNCTION: WDA_suspendDataTxCallback
2797 * call back function called from TL after suspend Transmission
2798 */
2799VOS_STATUS WDA_SuspendDataTxCallback( v_PVOID_t pvosGCtx,
2800 v_U8_t* ucSTAId,
2801 VOS_STATUS vosStatus)
2802{
2803 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pvosGCtx);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2804 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2805 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2806 if (NULL == pWDA )
2807 {
2808 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2809 "%s: Invoked with invalid WDA context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2810 VOS_ASSERT(0);
2811 return VOS_STATUS_E_FAILURE;
2812 }
2813 if(VOS_IS_STATUS_SUCCESS(vosStatus))
2814 {
2815 pWDA->txStatus = WDA_TL_TX_SUSPEND_SUCCESS;
2816 }
2817 else
2818 {
2819 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
2820 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2821 /* Trigger the event to bring the WDA TL suspend function to come
2822 * out of wait*/
2823 vosStatus = vos_event_set(&pWDA->suspendDataTxEvent);
2824 if(!VOS_IS_STATUS_SUCCESS(vosStatus))
2825 {
2826 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2827 "NEW VOS Event Set failed - status = %d", vosStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2828 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2829 /* If TL suspended had timedout before this callback was called, resume back
2830 * TL.*/
2831 if (pWDA->txSuspendTimedOut)
2832 {
2833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2834 "Late TLSuspendCallback, resuming TL back again");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2835 WDA_ResumeDataTx(pWDA);
2836 pWDA->txSuspendTimedOut = FALSE;
2837 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2838 return VOS_STATUS_SUCCESS;
2839}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2840/*
2841 * FUNCTION: WDA_suspendDataTx
2842 * Update TL to suspend the data Transmission
2843 */
2844VOS_STATUS WDA_SuspendDataTx(tWDA_CbContext *pWDA)
2845{
2846 VOS_STATUS status = VOS_STATUS_E_FAILURE;
2847 tANI_U8 eventIdx = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2848
2849 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2850 "%s: Entered " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2851 pWDA->txStatus = WDA_TL_TX_SUSPEND_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2852 if (pWDA->txSuspendTimedOut)
2853 {
2854 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2855 "TL suspend timedout previously, CB not called yet");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2856 return status;
2857 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2858 /* Reset the event to be not signalled */
2859 status = vos_event_reset(&pWDA->suspendDataTxEvent);
2860 if(!VOS_IS_STATUS_SUCCESS(status))
2861 {
2862 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]2863 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2864 return VOS_STATUS_E_FAILURE;
2865 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2866 /*Indicate TL to suspend transmission for all Sta Id */
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2867 status = WLANTL_SuspendDataTx(pWDA->pVosContext, NULL,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2868 WDA_SuspendDataTxCallback);
2869 if(status != VOS_STATUS_SUCCESS)
2870 {
2871 return status;
2872 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2873 /* Wait for the event to be set by the TL, to get the response of
2874 * suspending the TX queues, this event should be set by the Callback
2875 * function called by TL*/
2876 status = vos_wait_events(&pWDA->suspendDataTxEvent, 1,
2877 WDA_TL_SUSPEND_TIMEOUT, &eventIdx);
2878 if(!VOS_IS_STATUS_SUCCESS(status))
2879 {
2880 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
2881 "%s: Status %d when waiting for Suspend Data TX Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2882 __func__, status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2883 /* Set this flag to true when TL suspend times out, so that when TL
2884 * suspend eventually happens and calls the callback, TL can be resumed
2885 * right away by looking at this flag when true.*/
2886 pWDA->txSuspendTimedOut = TRUE;
2887 }
2888 else
2889 {
2890 pWDA->txSuspendTimedOut = FALSE;
2891 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2892 if(WDA_TL_TX_SUSPEND_SUCCESS == pWDA->txStatus)
2893 {
2894 status = VOS_STATUS_SUCCESS;
2895 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2896 return status;
2897}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2898/*
2899 * FUNCTION: WDA_resumeDataTx
2900 * Update TL to resume the data Transmission
2901 */
2902VOS_STATUS WDA_ResumeDataTx(tWDA_CbContext *pWDA)
2903{
2904 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2905
2906 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2907 "%s: Entered " ,__func__);
Hoonki Lee14621352013-04-16 17:51:19 -0700[diff] [blame]2908
2909 status = WLANTL_ResumeDataTx(pWDA->pVosContext, NULL);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2910 return status;
2911}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2912/*
2913 * FUNCTION: WDA_InitScanReqCallback
2914 * Trigger Init SCAN callback
2915 */
2916void WDA_InitScanReqCallback(WDI_Status wdiStatus, void* pUserData)
2917{
2918 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
2919 tWDA_CbContext *pWDA;
2920 tInitScanParams *pWDA_ScanParam ;
2921 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2922 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2923 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2924 if(NULL == pWdaParams)
2925 {
2926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2927 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2928 VOS_ASSERT(0) ;
2929 return ;
2930 }
2931 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
2932 pWDA_ScanParam = (tInitScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2933 if(NULL == pWDA_ScanParam)
2934 {
2935 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2936 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]2937 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]2938 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
2939 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2940 return ;
2941 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2942 if(WDI_STATUS_SUCCESS != wdiStatus)
2943 {
2944 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2945 if(VOS_STATUS_SUCCESS != status)
2946 {
2947 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2948 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2949 }
2950 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2951 /* free WDI command buffer */
2952 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2953 vos_mem_free(pWdaParams) ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]2954
2955
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2956 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]2957 /* without converting the Status to Failure or Success Just
2958 pass the same status to lim */
2959 pWDA_ScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2960 /* send SCAN RSP message back to PE */
2961 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2962 return ;
2963}
2964
2965/*
2966 * FUNCTION: WDA_ProcessInitScanReq
2967 * Trigger Init SCAN in DAL
2968 */
2969VOS_STATUS WDA_ProcessInitScanReq(tWDA_CbContext *pWDA,
2970 tInitScanParams *initScanParams)
2971{
2972 WDI_Status status = WDI_STATUS_SUCCESS ;
2973 WDI_InitScanReqParamsType *wdiInitScanParam =
2974 (WDI_InitScanReqParamsType *)vos_mem_malloc(
2975 sizeof(WDI_InitScanReqParamsType)) ;
2976 tWDA_ReqParams *pWdaParams;
2977 tANI_U8 i = 0;
2978
2979 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2980 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2981 if(NULL == wdiInitScanParam)
2982 {
2983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2984 "%s:VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2985 VOS_ASSERT(0);
2986 return VOS_STATUS_E_NOMEM;
2987 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2988 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
2989 if(NULL == pWdaParams)
2990 {
2991 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]2992 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]2993 VOS_ASSERT(0);
2994 vos_mem_free(wdiInitScanParam);
2995 return VOS_STATUS_E_NOMEM;
2996 }
2997
2998 /* Copy init Scan params to WDI structure */
2999 wdiInitScanParam->wdiReqInfo.wdiScanMode = initScanParams->scanMode ;
3000 vos_mem_copy(wdiInitScanParam->wdiReqInfo.macBSSID, initScanParams->bssid,
3001 sizeof(tSirMacAddr)) ;
3002 wdiInitScanParam->wdiReqInfo.bNotifyBSS = initScanParams->notifyBss ;
3003 wdiInitScanParam->wdiReqInfo.ucFrameType = initScanParams->frameType ;
3004 wdiInitScanParam->wdiReqInfo.ucFrameLength = initScanParams->frameLength ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3005 wdiInitScanParam->wdiReqInfo.bUseNOA = initScanParams->useNoA;
3006 wdiInitScanParam->wdiReqInfo.scanDuration = initScanParams->scanDuration;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3007 wdiInitScanParam->wdiReqInfo.wdiScanEntry.activeBSScnt =
3008 initScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3009 for (i=0; i < initScanParams->scanEntry.activeBSScnt; i++)
3010 {
3011 wdiInitScanParam->wdiReqInfo.wdiScanEntry.bssIdx[i] =
3012 initScanParams->scanEntry.bssIdx[i] ;
3013 }
3014
3015 /* if Frame length, copy macMgmtHdr or WDI structure */
3016 if(0 != wdiInitScanParam->wdiReqInfo.ucFrameLength)
3017 {
3018 vos_mem_copy(&wdiInitScanParam->wdiReqInfo.wdiMACMgmtHdr,
3019 &initScanParams->macMgmtHdr, sizeof(tSirMacMgmtHdr)) ;
3020 }
3021 wdiInitScanParam->wdiReqStatusCB = NULL ;
3022
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3023 /* Store Init Req pointer, as this will be used for response */
3024 pWdaParams->pWdaContext = pWDA;
3025 pWdaParams->wdaMsgParam = initScanParams;
3026 pWdaParams->wdaWdiApiMsgParam = wdiInitScanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3027 /* first try to suspend TX */
3028 status = WDA_SuspendDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3029 if(WDI_STATUS_SUCCESS != status)
3030 {
3031 goto handleWdiFailure;
3032 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3033 /* call DAL API to pass init scan request to DAL */
3034 status = WDI_InitScanReq(wdiInitScanParam,
3035 WDA_InitScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3036 if(IS_WDI_STATUS_FAILURE(status))
3037 {
3038 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3039 "error in WDA Init Scan, Resume Tx " );
3040 status = WDA_ResumeDataTx(pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3041 VOS_ASSERT(0) ;
3042
3043 goto handleWdiFailure;
3044 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3045 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3046handleWdiFailure:
3047 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3048 "Failure in WDI Api, free all the memory " );
3049 /* free WDI command buffer */
3050 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3051 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3052 /* send Failure to PE */
3053 initScanParams->status = eSIR_FAILURE ;
3054 WDA_SendMsg(pWDA, WDA_INIT_SCAN_RSP, (void *)initScanParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3055 return CONVERT_WDI2VOS_STATUS(status) ;
3056}
3057
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3058/*
3059 * FUNCTION: WDA_StartScanReqCallback
3060 * send Start SCAN RSP back to PE
3061 */
3062void WDA_StartScanReqCallback(WDI_StartScanRspParamsType *pScanRsp,
3063 void* pUserData)
3064{
3065 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3066 tWDA_CbContext *pWDA;
3067 tStartScanParams *pWDA_ScanParam;
3068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3069 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3070 if(NULL == pWdaParams)
3071 {
3072 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3073 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3074 VOS_ASSERT(0) ;
3075 return ;
3076 }
3077 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3078 pWDA_ScanParam = (tStartScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3079 if(NULL == pWDA_ScanParam)
3080 {
3081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3082 "%s: pWDA_ScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3083 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]3084 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3085 return ;
3086 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3087 if(NULL == pWdaParams->wdaWdiApiMsgParam)
3088 {
3089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3090 "%s: wdaWdiApiMsgParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3091 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]3092 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3093 return ;
3094 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3095 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3096 vos_mem_free(pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3097
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3098
3099 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3100 pWDA_ScanParam->status = pScanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3101 /* send SCAN RSP message back to PE */
3102 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)pWDA_ScanParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3103 return ;
3104}
3105
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3106/*
3107 * FUNCTION: WDA_ProcessStartScanReq
3108 * Trigger start SCAN in WDI
3109 */
3110VOS_STATUS WDA_ProcessStartScanReq(tWDA_CbContext *pWDA,
3111 tStartScanParams *startScanParams)
3112{
3113 WDI_Status status = WDI_STATUS_SUCCESS;
3114 WDI_StartScanReqParamsType *wdiStartScanParams =
3115 (WDI_StartScanReqParamsType *)vos_mem_malloc(
3116 sizeof(WDI_StartScanReqParamsType)) ;
3117 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3119 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3120 if(NULL == wdiStartScanParams)
3121 {
3122 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3123 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3124 VOS_ASSERT(0);
3125 return VOS_STATUS_E_NOMEM;
3126 }
3127 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3128 if(NULL == pWdaParams)
3129 {
3130 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3131 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3132 VOS_ASSERT(0);
3133 vos_mem_free(wdiStartScanParams);
3134 return VOS_STATUS_E_NOMEM;
3135 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3136 /* Copy init Scan params to WDI structure */
3137 wdiStartScanParams->ucChannel = startScanParams->scanChannel ;
3138 wdiStartScanParams->wdiReqStatusCB = NULL ;
3139
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3140 /* Store Init Req pointer, as this will be used for response */
3141 /* store Params pass it to WDI */
3142 pWdaParams->pWdaContext = pWDA;
3143 pWdaParams->wdaMsgParam = startScanParams;
3144 pWdaParams->wdaWdiApiMsgParam = wdiStartScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3145 /* call DAL API to pass init scan request to DAL */
3146 status = WDI_StartScanReq(wdiStartScanParams,
3147 WDA_StartScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3148 /* failure returned by WDI API */
3149 if(IS_WDI_STATUS_FAILURE(status))
3150 {
3151 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3152 "Failure in Start Scan WDI API, free all the memory "
3153 "It should be due to previous abort scan." );
3154 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3155 vos_mem_free(pWdaParams) ;
3156 startScanParams->status = eSIR_FAILURE ;
3157 WDA_SendMsg(pWDA, WDA_START_SCAN_RSP, (void *)startScanParams, 0) ;
3158 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3159 return CONVERT_WDI2VOS_STATUS(status) ;
3160}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3161/*
3162 * FUNCTION: WDA_EndScanReqCallback
3163 * END SCAN callback
3164 */
3165void WDA_EndScanReqCallback(WDI_Status status, void* pUserData)
3166{
3167 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3168 tWDA_CbContext *pWDA;
3169 tEndScanParams *endScanParam;
3170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3171 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3172 if(NULL == pWdaParams)
3173 {
3174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3175 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3176 VOS_ASSERT(0) ;
3177 return ;
3178 }
3179 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3180 endScanParam = (tEndScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3181 if(NULL == endScanParam)
3182 {
3183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3184 "%s: endScanParam received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3185 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]3186 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3187 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3188 return ;
3189 }
3190
3191 /* Free WDI command buffer */
3192 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3193 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3194 /* assign status to scan params */
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3195 endScanParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3196 /* send response back to PE */
3197 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParam, 0) ;
3198 return ;
3199}
3200
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3201/*
3202 * FUNCTION: WDA_ProcessEndScanReq
3203 * Trigger END SCAN in WDI
3204 */
3205VOS_STATUS WDA_ProcessEndScanReq(tWDA_CbContext *pWDA,
3206 tEndScanParams *endScanParams)
3207{
3208 WDI_Status status = WDI_STATUS_SUCCESS;
3209 WDI_EndScanReqParamsType *wdiEndScanParams =
3210 (WDI_EndScanReqParamsType *)vos_mem_malloc(
3211 sizeof(WDI_EndScanReqParamsType)) ;
3212 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3214 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3215 if(NULL == wdiEndScanParams)
3216 {
3217 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3218 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3219 VOS_ASSERT(0);
3220 return VOS_STATUS_E_NOMEM;
3221 }
3222 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3223 if(NULL == pWdaParams)
3224 {
3225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3226 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3227 VOS_ASSERT(0);
3228 vos_mem_free(wdiEndScanParams);
3229 return VOS_STATUS_E_NOMEM;
3230 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3231 /* Copy init Scan params to WDI structure */
3232 wdiEndScanParams->ucChannel = endScanParams->scanChannel ;
3233 wdiEndScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3234 /* Store Init Req pointer, as this will be used for response */
3235 /* store Params pass it to WDI */
3236 pWdaParams->pWdaContext = pWDA;
3237 pWdaParams->wdaMsgParam = endScanParams;
3238 pWdaParams->wdaWdiApiMsgParam = wdiEndScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3239 /* call DAL API to pass init scan request to DAL */
3240 status = WDI_EndScanReq(wdiEndScanParams,
3241 WDA_EndScanReqCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3242 if(IS_WDI_STATUS_FAILURE(status))
3243 {
3244 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3245 "Failure in End Scan WDI API, free all the memory "
3246 "It should be due to previous abort scan." );
3247 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3248 vos_mem_free(pWdaParams) ;
3249 endScanParams->status = eSIR_FAILURE ;
3250 WDA_SendMsg(pWDA, WDA_END_SCAN_RSP, (void *)endScanParams, 0) ;
3251 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3252 return CONVERT_WDI2VOS_STATUS(status) ;
3253}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3254/*
3255 * FUNCTION: WDA_FinishScanReqCallback
3256 * Trigger Finish SCAN callback
3257 */
3258void WDA_FinishScanReqCallback(WDI_Status wdiStatus, void* pUserData)
3259{
3260 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3261 tWDA_CbContext *pWDA;
3262 tFinishScanParams *finishScanParam;
3263 VOS_STATUS status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3264 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3265 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3266 if(NULL == pWdaParams)
3267 {
3268 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3269 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3270 VOS_ASSERT(0) ;
3271 return ;
3272 }
3273
3274 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3275 finishScanParam = (tFinishScanParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3276 if(NULL == finishScanParam)
3277 {
3278 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3279 "%s: finishScanParam is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3280 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]3281 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3282 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3283 return ;
3284 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3285 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3286 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3287 /*
3288 * Now Resume TX, if we reached here means, TX is already suspended, we
3289 * have to resume it unconditionaly
3290 */
3291 status = WDA_ResumeDataTx(pWDA) ;
3292
3293 if(VOS_STATUS_SUCCESS != status)
3294 {
3295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3296 "%s error in Resume Tx ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3297 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3298 finishScanParam->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3299 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParam, 0) ;
3300 return ;
3301}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3302/*
3303 * FUNCTION: WDA_ProcessFinshScanReq
3304 * Trigger Finish SCAN in WDI
3305 */
3306VOS_STATUS WDA_ProcessFinishScanReq(tWDA_CbContext *pWDA,
3307 tFinishScanParams *finishScanParams)
3308{
3309 WDI_Status status = WDI_STATUS_SUCCESS;
3310 WDI_FinishScanReqParamsType *wdiFinishScanParams =
3311 (WDI_FinishScanReqParamsType *)vos_mem_malloc(
3312 sizeof(WDI_FinishScanReqParamsType)) ;
3313 tWDA_ReqParams *pWdaParams ;
3314 tANI_U8 i = 0;
3315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3316 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3317 if(NULL == wdiFinishScanParams)
3318 {
3319 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3320 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3321 VOS_ASSERT(0);
3322 return VOS_STATUS_E_NOMEM;
3323 }
3324 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3325 if(NULL == pWdaParams)
3326 {
3327 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3328 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3329 VOS_ASSERT(0);
3330 vos_mem_free(wdiFinishScanParams);
3331 return VOS_STATUS_E_NOMEM;
3332 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3333 /* Copy init Scan params to WDI structure */
3334 wdiFinishScanParams->wdiReqInfo.wdiScanMode = finishScanParams->scanMode ;
3335 vos_mem_copy(wdiFinishScanParams->wdiReqInfo.macBSSID,
3336 finishScanParams->bssid, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3337 wdiFinishScanParams->wdiReqInfo.bNotifyBSS = finishScanParams->notifyBss ;
3338 wdiFinishScanParams->wdiReqInfo.ucFrameType = finishScanParams->frameType ;
3339 wdiFinishScanParams->wdiReqInfo.ucFrameLength =
3340 finishScanParams->frameLength ;
3341 wdiFinishScanParams->wdiReqInfo.ucCurrentOperatingChannel =
3342 finishScanParams->currentOperChannel ;
3343 wdiFinishScanParams->wdiReqInfo.wdiCBState = finishScanParams->cbState ;
3344 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.activeBSScnt =
3345 finishScanParams->scanEntry.activeBSScnt ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3346 for (i = 0; i < finishScanParams->scanEntry.activeBSScnt; i++)
3347 {
3348 wdiFinishScanParams->wdiReqInfo.wdiScanEntry.bssIdx[i] =
3349 finishScanParams->scanEntry.bssIdx[i] ;
3350 }
3351
3352
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3353 /* if Frame length, copy macMgmtHdr ro WDI structure */
3354 if(0 != wdiFinishScanParams->wdiReqInfo.ucFrameLength)
3355 {
3356 vos_mem_copy(&wdiFinishScanParams->wdiReqInfo.wdiMACMgmtHdr,
3357 &finishScanParams->macMgmtHdr,
3358 sizeof(WDI_MacMgmtHdr)) ;
3359 }
3360 wdiFinishScanParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3361 /* Store Init Req pointer, as this will be used for response */
3362 /* store Params pass it to WDI */
3363 pWdaParams->pWdaContext = pWDA;
3364 pWdaParams->wdaMsgParam = finishScanParams;
3365 pWdaParams->wdaWdiApiMsgParam = wdiFinishScanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3366 /* call DAL API to pass init scan request to DAL */
3367 status = WDI_FinishScanReq(wdiFinishScanParams,
3368 WDA_FinishScanReqCallback, pWdaParams) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]3369
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3370
3371 /*
3372 * WDI API returns failure..
3373 */
3374 if(IS_WDI_STATUS_FAILURE( status))
3375 {
3376 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3377 "Failure in Finish Scan WDI API, free all the memory " );
3378 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3379 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3380 finishScanParams->status = eSIR_FAILURE ;
3381 WDA_SendMsg(pWDA, WDA_FINISH_SCAN_RSP, (void *)finishScanParams, 0) ;
3382 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3383 return CONVERT_WDI2VOS_STATUS(status) ;
3384}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3385/*---------------------------------------------------------------------
3386 * ASSOC API's
3387 *---------------------------------------------------------------------
3388 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3389/*
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3390 * FUNCTION: WDA_JoinRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3391 * Trigger Init SCAN callback
3392 */
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3393void WDA_JoinRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3394{
3395 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3396 tWDA_CbContext *pWDA;
3397 tSwitchChannelParams *joinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3398 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3399 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3400 if(NULL == pWdaParams)
3401 {
3402 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3403 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3404 VOS_ASSERT(0) ;
3405 return ;
3406 }
3407 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3408 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3409 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
3410 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3411 /* reset macBSSID */
3412 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3413 /* reset macSTASelf */
3414 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3415 joinReqParam->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3416 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3417 return ;
3418}
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3419
3420/*
3421 * FUNCTION: WDA_JoinReqCallback
3422 * Free memory and send SWITCH CHANNEL RSP back to PE.
3423 * Invoked when Enter JOIN REQ failed in WDI and no RSP callback is generated.
3424 */
3425void WDA_JoinReqCallback(WDI_Status wdiStatus, void* pUserData)
3426{
3427 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3428 tWDA_CbContext *pWDA;
3429 tSwitchChannelParams *joinReqParam;
3430
3431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3432 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
3433
3434 if(NULL == pWdaParams)
3435 {
3436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3437 "%s: pWdaParams received NULL", __func__);
3438 VOS_ASSERT(0);
3439 return;
3440 }
3441
3442 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3443 joinReqParam = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3444 joinReqParam->status = wdiStatus;
3445
3446 if(IS_WDI_STATUS_FAILURE(wdiStatus))
3447 {
3448 /* reset macBSSID */
3449 vos_mem_set(pWDA->macBSSID, sizeof(pWDA->macBSSID),0 );
3450 /* reset macSTASelf */
3451 vos_mem_set(pWDA->macSTASelf, sizeof(pWDA->macSTASelf),0 );
3452
3453 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3454 vos_mem_free(pWdaParams);
3455 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam , 0) ;
3456 }
3457
3458 return;
3459}
3460
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3461/*
3462 * FUNCTION: WDA_ProcessJoinReq
3463 * Trigger Join REQ in WDI
3464 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3465VOS_STATUS WDA_ProcessJoinReq(tWDA_CbContext *pWDA,
3466 tSwitchChannelParams* joinReqParam)
3467{
3468 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3469 WDI_JoinReqParamsType *wdiJoinReqParam =
3470 (WDI_JoinReqParamsType *)vos_mem_malloc(
3471 sizeof(WDI_JoinReqParamsType)) ;
3472 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3474 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3475 if(NULL == wdiJoinReqParam)
3476 {
3477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3478 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3479 VOS_ASSERT(0);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3480 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3481 return VOS_STATUS_E_NOMEM;
3482 }
3483 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3484 if(NULL == pWdaParams)
3485 {
3486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3487 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3488 VOS_ASSERT(0);
3489 vos_mem_free(wdiJoinReqParam);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3490 vos_mem_free(joinReqParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3491 return VOS_STATUS_E_NOMEM;
3492 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3493
3494 /*if the BSSID or self STA in pWDA is NULL, join request can't be processed*/
3495 if(WDA_IS_NULL_MAC_ADDRESS(pWDA->macBSSID) ||
3496 WDA_IS_NULL_MAC_ADDRESS(pWDA->macSTASelf))
3497 {
3498 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3499 "%s: received join request when BSSID or self-STA is NULL "
3500 " BSSID:" WDA_MAC_ADDRESS_STR "Self-STA:" WDA_MAC_ADDRESS_STR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3501 __func__, WDA_MAC_ADDR_ARRAY(pWDA->macBSSID),
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]3502 WDA_MAC_ADDR_ARRAY(pWDA->macSTASelf));
3503 VOS_ASSERT(0);
3504 vos_mem_free(wdiJoinReqParam);
3505 vos_mem_free(pWdaParams);
3506 joinReqParam->status = eSIR_FAILURE ;
3507 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3508 return VOS_STATUS_E_INVAL;
3509 }
3510
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3511 /* copy the BSSID for pWDA */
3512 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macBSSID, pWDA->macBSSID,
3513 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3514 vos_mem_copy(wdiJoinReqParam->wdiReqInfo.macSTASelf,
3515 pWDA->macSTASelf, sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3516 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucChannel =
3517 joinReqParam->channelNumber ;
Madan Mohan Koyyalamudi83b12822012-11-02 12:43:10 -0700[diff] [blame]3518#ifdef WLAN_FEATURE_VOWIFI
3519 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.cMaxTxPower =
3520 joinReqParam->maxTxPower ;
3521#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3522 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.ucLocalPowerConstraint =
3523 joinReqParam->localPowerConstraint ;
3524#endif
3525 wdiJoinReqParam->wdiReqInfo.wdiChannelInfo.wdiSecondaryChannelOffset =
3526 joinReqParam->secondaryChannelOffset ;
3527 wdiJoinReqParam->wdiReqInfo.linkState = pWDA->linkState;
3528
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3529 wdiJoinReqParam->wdiReqStatusCB = WDA_JoinReqCallback;
3530 wdiJoinReqParam->pUserData = pWdaParams;
3531
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3532 /* Store Init Req pointer, as this will be used for response */
3533 /* store Params pass it to WDI */
3534 pWdaParams->pWdaContext = pWDA;
3535 pWdaParams->wdaMsgParam = joinReqParam;
3536 pWdaParams->wdaWdiApiMsgParam = wdiJoinReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3537 status = WDI_JoinReq(wdiJoinReqParam,
Sachin Ahuja935eda782014-07-30 14:57:41 +0530[diff] [blame]3538 (WDI_JoinRspCb )WDA_JoinRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3539 if(IS_WDI_STATUS_FAILURE(status))
3540 {
3541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3542 "Failure in Join WDI API, free all the memory " );
3543 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3544 vos_mem_free(pWdaParams) ;
3545 joinReqParam->status = eSIR_FAILURE ;
3546 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)joinReqParam, 0) ;
3547 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3548 return CONVERT_WDI2VOS_STATUS(status) ;
3549}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3550/*
3551 * FUNCTION: WDA_SwitchChannelReqCallback
3552 * send Switch channel RSP back to PE
3553 */
3554void WDA_SwitchChannelReqCallback(
3555 WDI_SwitchCHRspParamsType *wdiSwitchChanRsp, void* pUserData)
3556{
3557 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3558 tWDA_CbContext *pWDA;
3559 tSwitchChannelParams *pSwitchChanParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3560 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3561 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3562 if(NULL == pWdaParams)
3563 {
3564 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3565 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3566 VOS_ASSERT(0) ;
3567 return ;
3568 }
3569 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3570 pSwitchChanParams = (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3571
3572#ifdef WLAN_FEATURE_VOWIFI
3573 pSwitchChanParams->txMgmtPower = wdiSwitchChanRsp->ucTxMgmtPower;
3574#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3575 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3576 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3577 pSwitchChanParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3578 wdiSwitchChanRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3579 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3580 return ;
3581}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3582/*
3583 * FUNCTION: WDA_ProcessChannelSwitchReq
3584 * Request to WDI to switch channel REQ params.
3585 */
3586VOS_STATUS WDA_ProcessChannelSwitchReq(tWDA_CbContext *pWDA,
3587 tSwitchChannelParams *pSwitchChanParams)
3588{
3589 WDI_Status status = WDI_STATUS_SUCCESS ;
3590 WDI_SwitchChReqParamsType *wdiSwitchChanParam =
3591 (WDI_SwitchChReqParamsType *)vos_mem_malloc(
3592 sizeof(WDI_SwitchChReqParamsType)) ;
3593 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3594 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3595 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3596 if(NULL == wdiSwitchChanParam)
3597 {
3598 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3599 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3600 VOS_ASSERT(0);
3601 return VOS_STATUS_E_NOMEM;
3602 }
3603 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3604 if(NULL == pWdaParams)
3605 {
3606 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3607 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3608 VOS_ASSERT(0);
3609 vos_mem_free(wdiSwitchChanParam);
3610 return VOS_STATUS_E_NOMEM;
3611 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3612 wdiSwitchChanParam->wdiChInfo.ucChannel = pSwitchChanParams->channelNumber;
3613#ifndef WLAN_FEATURE_VOWIFI
3614 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3615 pSwitchChanParams->localPowerConstraint;
3616#endif
3617 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3618 pSwitchChanParams->secondaryChannelOffset;
3619 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3620 /* Store req pointer, as this will be used for response */
3621 /* store Params pass it to WDI */
3622 pWdaParams->pWdaContext = pWDA;
3623 pWdaParams->wdaMsgParam = pSwitchChanParams;
3624 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3625#ifdef WLAN_FEATURE_VOWIFI
3626 wdiSwitchChanParam->wdiChInfo.cMaxTxPower
3627 = pSwitchChanParams->maxTxPower;
3628 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3629 pSwitchChanParams ->selfStaMacAddr,
3630 sizeof(tSirMacAddr));
3631#endif
3632 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3633 pSwitchChanParams->bssId,
3634 sizeof(tSirMacAddr));
3635
3636 status = WDI_SwitchChReq(wdiSwitchChanParam,
3637 (WDI_SwitchChRspCb)WDA_SwitchChannelReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3638 if(IS_WDI_STATUS_FAILURE(status))
3639 {
3640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3641 "Failure in process channel switch Req WDI API, free all the memory " );
3642 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3643 vos_mem_free(pWdaParams) ;
3644 pSwitchChanParams->status = eSIR_FAILURE ;
3645 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP, (void *)pSwitchChanParams, 0) ;
3646 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3647 return CONVERT_WDI2VOS_STATUS(status) ;
3648}
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]3649
3650/*
3651 * FUNCTION: WDA_SwitchChannelReqCallback_V1
3652 * send Switch channel RSP back to PE
3653 */
3654void WDA_SwitchChannelReqCallback_V1(
3655 WDI_SwitchChRspParamsType_V1 *wdiSwitchChanRsp,
3656 void* pUserData)
3657{
3658 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
3659 tWDA_CbContext *pWDA;
3660 tSwitchChannelParams *pSwitchChanParams;
3661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3662 "<------ %s " ,__func__);
3663
3664 if (NULL == pWdaParams)
3665 {
3666 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3667 "%s: pWdaParams received NULL", __func__);
3668 VOS_ASSERT(0);
3669 return ;
3670 }
3671 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3672 pSwitchChanParams =
3673 (tSwitchChannelParams *)pWdaParams->wdaMsgParam;
3674 pSwitchChanParams->channelSwitchSrc =
3675 wdiSwitchChanRsp->channelSwitchSrc;
3676#ifdef WLAN_FEATURE_VOWIFI
3677 pSwitchChanParams->txMgmtPower =
3678 wdiSwitchChanRsp->ucTxMgmtPower;
3679#endif
3680 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3681 vos_mem_free(pWdaParams);
3682 pSwitchChanParams->status =
3683 wdiSwitchChanRsp->wdiStatus ;
3684 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3685 (void *)pSwitchChanParams , 0);
3686 return;
3687}
3688
3689/*
3690 * FUNCTION: WDA_ProcessChannelSwitchReq_V1
3691 * Request to WDI to switch channel REQ params.
3692 */
3693VOS_STATUS WDA_ProcessChannelSwitchReq_V1(tWDA_CbContext *pWDA,
3694 tSwitchChannelParams *pSwitchChanParams)
3695{
3696 WDI_Status status = WDI_STATUS_SUCCESS ;
3697 WDI_SwitchChReqParamsType_V1 *wdiSwitchChanParam =
3698 (WDI_SwitchChReqParamsType_V1 *)vos_mem_malloc(
3699 sizeof(WDI_SwitchChReqParamsType_V1)) ;
3700 tWDA_ReqParams *pWdaParams ;
3701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3702 "------> %s " ,__func__);
3703 if (NULL == wdiSwitchChanParam)
3704 {
3705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3706 "%s: VOS MEM Alloc Failure", __func__);
3707 VOS_ASSERT(0);
3708 return VOS_STATUS_E_NOMEM;
3709 }
3710 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3711 if (NULL == pWdaParams)
3712 {
3713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3714 "%s: VOS MEM Alloc Failure", __func__);
3715 VOS_ASSERT(0);
3716 vos_mem_free(wdiSwitchChanParam);
3717 return VOS_STATUS_E_NOMEM;
3718 }
3719 wdiSwitchChanParam->wdiChInfo.channelSwitchSrc =
3720 pSwitchChanParams->channelSwitchSrc;
3721
3722 wdiSwitchChanParam->wdiChInfo.ucChannel =
3723 pSwitchChanParams->channelNumber;
3724#ifndef WLAN_FEATURE_VOWIFI
3725 wdiSwitchChanParam->wdiChInfo.ucLocalPowerConstraint =
3726 pSwitchChanParams->localPowerConstraint;
3727#endif
3728 wdiSwitchChanParam->wdiChInfo.wdiSecondaryChannelOffset =
3729 pSwitchChanParams->secondaryChannelOffset;
3730 wdiSwitchChanParam->wdiReqStatusCB = NULL ;
3731 /* Store req pointer, as this will be used for response */
3732 /* store Params pass it to WDI */
3733 pWdaParams->pWdaContext = pWDA;
3734 pWdaParams->wdaMsgParam = pSwitchChanParams;
3735 pWdaParams->wdaWdiApiMsgParam = wdiSwitchChanParam;
3736#ifdef WLAN_FEATURE_VOWIFI
3737 wdiSwitchChanParam->wdiChInfo.cMaxTxPower =
3738 pSwitchChanParams->maxTxPower;
3739 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macSelfStaMacAddr,
3740 pSwitchChanParams ->selfStaMacAddr,
3741 sizeof(tSirMacAddr));
3742#endif
3743 vos_mem_copy(wdiSwitchChanParam->wdiChInfo.macBSSId,
3744 pSwitchChanParams->bssId,
3745 sizeof(tSirMacAddr));
3746
3747 status = WDI_SwitchChReq_V1(wdiSwitchChanParam,
3748 (WDI_SwitchChRspCb_V1)WDA_SwitchChannelReqCallback_V1,
3749 pWdaParams);
3750 if (IS_WDI_STATUS_FAILURE(status))
3751 {
3752 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3753 "Failure in process channel switch Req WDI "
3754 "API, free all the memory " );
3755 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3756 vos_mem_free(pWdaParams) ;
3757 pSwitchChanParams->status = eSIR_FAILURE ;
3758 WDA_SendMsg(pWDA, WDA_SWITCH_CHANNEL_RSP,
3759 (void *)pSwitchChanParams, 0) ;
3760 }
3761 return CONVERT_WDI2VOS_STATUS(status) ;
3762}
3763
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3764/*
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3765 * FUNCTION: WDA_ConfigBssRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3766 * config BSS Req Callback, called by WDI
3767 */
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3768void WDA_ConfigBssRspCallback(WDI_ConfigBSSRspParamsType *wdiConfigBssRsp
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3769 ,void* pUserData)
3770{
3771 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3772 tWDA_CbContext *pWDA;
3773 tAddBssParams *configBssReqParam;
3774 tAddStaParams *staConfigBssParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3776 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3777 if(NULL == pWdaParams)
3778 {
3779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3780 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3781 VOS_ASSERT(0) ;
3782 return ;
3783 }
3784 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3785 configBssReqParam = (tAddBssParams *)pWdaParams->wdaMsgParam;
3786 staConfigBssParam = &configBssReqParam->staContext ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3787 configBssReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]3788 wdiConfigBssRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3789 if(WDI_STATUS_SUCCESS == wdiConfigBssRsp->wdiStatus)
3790 {
3791 vos_mem_copy(configBssReqParam->bssId, wdiConfigBssRsp->macBSSID,
3792 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3793 configBssReqParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
3794 configBssReqParam->bcastDpuSignature = wdiConfigBssRsp->ucBcastSig;
3795 configBssReqParam->mgmtDpuSignature = wdiConfigBssRsp->ucUcastSig;
3796
3797 if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_STA)
3798 {
3799 if(configBssReqParam->bssType == eSIR_IBSS_MODE)
3800 {
3801 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_IN_IBSS_ROLE;
3802 staConfigBssParam->staType = STA_ENTRY_BSSID;
3803 }
3804 else if ((configBssReqParam->bssType == eSIR_BTAMP_STA_MODE) &&
3805 (staConfigBssParam->staType == STA_ENTRY_SELF))
3806 {
3807 /* This is the 1st add BSS Req for the BTAMP STA */
3808 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3809 staConfigBssParam->staType = STA_ENTRY_BSSID;
3810 }
3811 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3812 (staConfigBssParam->staType == STA_ENTRY_PEER))
3813 {
3814 /* This is the 2nd ADD BSS Request that is sent
3815 * on the BTAMP STA side. The Sta type is
3816 * set to STA_ENTRY_PEER here.*/
3817 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_STA_ROLE;
3818 }
3819 else if ((configBssReqParam->bssType == eSIR_BTAMP_AP_MODE) &&
3820 (staConfigBssParam->staType == STA_ENTRY_SELF))
3821 {
3822 /* statype is already set by PE.
3823 * Only 1 ADD BSS Req is sent on the BTAMP AP side.*/
3824 pWDA->wdaGlobalSystemRole = eSYSTEM_BTAMP_AP_ROLE;
3825 staConfigBssParam->staType = STA_ENTRY_BSSID;
3826 }
3827 else
3828 {
3829 pWDA->wdaGlobalSystemRole = eSYSTEM_STA_ROLE;
3830 staConfigBssParam->staType = STA_ENTRY_PEER;
3831 }
3832 }
3833 else if (configBssReqParam->operMode == BSS_OPERATIONAL_MODE_AP)
3834 {
3835 pWDA->wdaGlobalSystemRole = eSYSTEM_AP_ROLE;
3836 staConfigBssParam->staType = STA_ENTRY_SELF;
3837 }
3838 else
3839 {
3840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3841 "Invalid operation mode specified");
3842 VOS_ASSERT(0);
3843 }
3844
3845 staConfigBssParam->staIdx = wdiConfigBssRsp->ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3846 staConfigBssParam->bssIdx = wdiConfigBssRsp->ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3847 staConfigBssParam->ucUcastSig = wdiConfigBssRsp->ucUcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3848 staConfigBssParam->ucBcastSig = wdiConfigBssRsp->ucBcastSig;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3849 vos_mem_copy(staConfigBssParam->staMac, wdiConfigBssRsp->macSTA,
3850 sizeof(tSirMacAddr));
3851 staConfigBssParam->txChannelWidthSet =
3852 configBssReqParam->txChannelWidthSet;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3853 if(staConfigBssParam->staType == STA_ENTRY_PEER &&
3854 staConfigBssParam->htCapable)
3855 {
3856 pWDA->wdaStaInfo[staConfigBssParam->staIdx].bssIdx =
3857 wdiConfigBssRsp->ucBSSIdx;
3858 pWDA->wdaStaInfo[staConfigBssParam->staIdx].ucValidStaIndex =
3859 WDA_VALID_STA_INDEX ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]3860 pWDA->wdaStaInfo[staConfigBssParam->staIdx].currentOperChan =
3861 configBssReqParam->currentOperChannel;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3862 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3863 if(WDI_DS_SetStaIdxPerBssIdx(pWDA->pWdiContext,
3864 wdiConfigBssRsp->ucBSSIdx,
3865 wdiConfigBssRsp->ucSTAIdx))
3866 {
3867 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3868 "%s: fail to set STA idx associated with BSS index", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3869 VOS_ASSERT(0) ;
3870 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3871 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigBssRsp->ucSTAIdx))
3872 {
3873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3874 "%s: add BSS into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3875 VOS_ASSERT(0) ;
3876 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3877#ifdef WLAN_FEATURE_VOWIFI
3878 configBssReqParam->txMgmtPower = wdiConfigBssRsp->ucTxMgmtPower;
3879#endif
3880 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]3881 else
3882 {
3883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3884 "%s: Failure with status %d", __func__,
3885 wdiConfigBssRsp->wdiStatus);
3886 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
3887 WLAN_LOG_INDICATOR_HOST_DRIVER,
3888 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
3889 FALSE, TRUE);
3890 }
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]3891 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
3892 sizeof(WDI_ConfigBSSReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3893 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3894 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3895 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3896 return ;
3897}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3898/*
3899 * FUNCTION: WDA_UpdateEdcaParamsForAC
3900 * Update WDI EDCA params with PE edca params
3901 */
3902void WDA_UpdateEdcaParamsForAC(tWDA_CbContext *pWDA,
3903 WDI_EdcaParamRecord *wdiEdcaParam,
3904 tSirMacEdcaParamRecord *macEdcaParam)
3905{
3906 wdiEdcaParam->wdiACI.aifsn = macEdcaParam->aci.aifsn;
3907 wdiEdcaParam->wdiACI.acm= macEdcaParam->aci.acm;
3908 wdiEdcaParam->wdiACI.aci = macEdcaParam->aci.aci;
3909 wdiEdcaParam->wdiCW.min = macEdcaParam->cw.min;
3910 wdiEdcaParam->wdiCW.max = macEdcaParam->cw.max;
3911 wdiEdcaParam->usTXOPLimit = macEdcaParam->txoplimit;
3912}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3913void WDA_ConfigBssReqCallback(WDI_Status wdiStatus,
3914 void* pUserData)
3915{
3916 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
3917 tWDA_CbContext *pWDA;
3918 tAddBssParams *addBssParams;
3919
3920 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3921 "<------ %s, wdiStatus: %d",
3922 __func__, wdiStatus);
3923
3924 if (NULL == pWdaParams)
3925 {
3926 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
3927 "%s: Invalid pWdaParams pointer", __func__);
3928 VOS_ASSERT(0);
3929 return;
3930 }
3931
3932 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
3933 addBssParams = (tAddBssParams *)pWdaParams->wdaMsgParam;
3934
3935 addBssParams->status = wdiStatus;
3936
3937 if (IS_WDI_STATUS_FAILURE(wdiStatus))
3938 {
3939 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
3940 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]3941 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
3942 WLAN_LOG_INDICATOR_HOST_DRIVER,
3943 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
3944 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3945 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)addBssParams , 0);
3946 }
3947
3948 return ;
3949}
3950
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3951/*
3952 * FUNCTION: WDA_ProcessConfigBssReq
3953 * Configure BSS before starting Assoc with AP
3954 */
3955VOS_STATUS WDA_ProcessConfigBssReq(tWDA_CbContext *pWDA,
3956 tAddBssParams* configBssReqParam)
3957{
3958 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3959 WDI_ConfigBSSReqParamsType *wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3960 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3961 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3962 "------> %s " ,__func__);
Madan Mohan Koyyalamudi67b82f62013-06-21 18:35:53 +0530[diff] [blame]3963 if (NULL == configBssReqParam)
3964 {
3965 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
3966 "%s: configBssReqParam is NULL", __func__);
3967 return VOS_STATUS_E_INVAL;
3968 }
3969
3970 wdiConfigBssReqParam = (WDI_ConfigBSSReqParamsType *)vos_mem_malloc(
3971 sizeof(WDI_ConfigBSSReqParamsType)) ;
3972
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3973 if(NULL == wdiConfigBssReqParam)
3974 {
3975 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3976 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3977 VOS_ASSERT(0);
3978 return VOS_STATUS_E_NOMEM;
3979 }
3980 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
3981 if(NULL == pWdaParams)
3982 {
3983 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]3984 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3985 VOS_ASSERT(0);
3986 vos_mem_free(wdiConfigBssReqParam);
3987 return VOS_STATUS_E_NOMEM;
3988 }
Kiran4a17ebe2013-01-31 10:43:43 -0800[diff] [blame]3989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
3990 "%s: maxTxPower %d", __func__, configBssReqParam->maxTxPower);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3991 vos_mem_set(wdiConfigBssReqParam, sizeof(WDI_ConfigBSSReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3992 WDA_UpdateBSSParams(pWDA, &wdiConfigBssReqParam->wdiReqInfo,
3993 configBssReqParam) ;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]3994 wdiConfigBssReqParam->wdiReqStatusCB = WDA_ConfigBssReqCallback;
3995 wdiConfigBssReqParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]3996 /* Store Init Req pointer, as this will be used for response */
3997 /* store Params pass it to WDI */
3998 pWdaParams->pWdaContext = pWDA;
3999 pWdaParams->wdaMsgParam = configBssReqParam;
4000 pWdaParams->wdaWdiApiMsgParam = wdiConfigBssReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4001 status = WDI_ConfigBSSReq(wdiConfigBssReqParam,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4002 (WDI_ConfigBSSRspCb )WDA_ConfigBssRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4003 if(IS_WDI_STATUS_FAILURE(status))
4004 {
4005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4006 "Failure in Config BSS WDI API, free all the memory " );
4007 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4008 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4009 configBssReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4010 WDA_SendMsg(pWDA, WDA_ADD_BSS_RSP, (void *)configBssReqParam, 0) ;
4011 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4012 return CONVERT_WDI2VOS_STATUS(status) ;
4013}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4014#ifdef ENABLE_HAL_COMBINED_MESSAGES
4015/*
4016 * FUNCTION: WDA_PostAssocReqCallback
4017 * Post ASSOC req callback, send RSP back to PE
4018 */
4019void WDA_PostAssocReqCallback(WDI_PostAssocRspParamsType *wdiPostAssocRsp,
4020 void* pUserData)
4021{
4022 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
4023 tPostAssocParams *postAssocReqParam =
4024 (tPostAssocParams *)pWDA->wdaMsgParam ;
4025 /*STA context within the BSS Params*/
4026 tAddStaParams *staPostAssocParam =
4027 &postAssocReqParam->addBssParams.staContext ;
4028 /*STA Params for self STA*/
4029 tAddStaParams *selfStaPostAssocParam =
4030 &postAssocReqParam->addStaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4032 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4033 postAssocReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4034 wdiPostAssocRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4035 if(WDI_STATUS_SUCCESS == wdiPostAssocRsp->wdiStatus)
4036 {
4037 staPostAssocParam->staIdx = wdiPostAssocRsp->bssParams.ucSTAIdx ;
4038 vos_mem_copy(staPostAssocParam->staMac, wdiPostAssocRsp->bssParams.macSTA,
4039 sizeof(tSirMacAddr)) ;
4040 staPostAssocParam->ucUcastSig = wdiPostAssocRsp->bssParams.ucUcastSig ;
4041 staPostAssocParam->ucBcastSig = wdiPostAssocRsp->bssParams.ucBcastSig ;
4042 staPostAssocParam->bssIdx = wdiPostAssocRsp->bssParams.ucBSSIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4043 selfStaPostAssocParam->staIdx = wdiPostAssocRsp->staParams.ucSTAIdx;
4044 }
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]4045 vos_mem_zero(pWDA->wdaWdiApiMsgParam, sizeof(WDI_PostAssocReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4046 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
4047 pWDA->wdaWdiApiMsgParam = NULL;
4048 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4049 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4050 return ;
4051}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4052/*
4053 * FUNCTION: WDA_ProcessPostAssocReq
4054 * Trigger POST ASSOC processing in WDI
4055 */
4056VOS_STATUS WDA_ProcessPostAssocReq(tWDA_CbContext *pWDA,
4057 tPostAssocParams *postAssocReqParam)
4058{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4059 WDI_Status status = WDI_STATUS_SUCCESS ;
4060
4061 WDI_PostAssocReqParamsType *wdiPostAssocReqParam =
4062 (WDI_PostAssocReqParamsType *)vos_mem_malloc(
4063 sizeof(WDI_PostAssocReqParamsType)) ;
4064 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4065 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4066
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4067 if(NULL == wdiPostAssocReqParam)
4068 {
4069 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4070 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4071 VOS_ASSERT(0);
4072 return VOS_STATUS_E_NOMEM;
4073 }
4074
4075 if((NULL != pWDA->wdaMsgParam) || (NULL != pWDA->wdaWdiApiMsgParam))
4076 {
4077 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4078 "%s: wdaMsgParam or wdaWdiApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4079 VOS_ASSERT(0);
4080 return VOS_STATUS_E_FAILURE;
4081 }
4082
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4083 /* update BSS params into WDI structure */
4084 WDA_UpdateBSSParams(pWDA, &wdiPostAssocReqParam->wdiBSSParams,
4085 &postAssocReqParam->addBssParams) ;
4086 /* update STA params into WDI structure */
4087 WDA_UpdateSTAParams(pWDA, &wdiPostAssocReqParam->wdiSTAParams,
4088 &postAssocReqParam->addStaParams) ;
4089
4090 wdiPostAssocReqParam->wdiBSSParams.ucEDCAParamsValid =
4091 postAssocReqParam->addBssParams.highPerformance;
4092 WDA_UpdateEdcaParamsForAC(pWDA,
4093 &wdiPostAssocReqParam->wdiBSSParams.wdiBEEDCAParams,
4094 &postAssocReqParam->addBssParams.acbe);
4095 WDA_UpdateEdcaParamsForAC(pWDA,
4096 &wdiPostAssocReqParam->wdiBSSParams.wdiBKEDCAParams,
4097 &postAssocReqParam->addBssParams.acbk);
4098 WDA_UpdateEdcaParamsForAC(pWDA,
4099 &wdiPostAssocReqParam->wdiBSSParams.wdiVIEDCAParams,
4100 &postAssocReqParam->addBssParams.acvi);
4101 WDA_UpdateEdcaParamsForAC(pWDA,
4102 &wdiPostAssocReqParam->wdiBSSParams.wdiVOEDCAParams,
4103 &postAssocReqParam->addBssParams.acvo);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4104 /* Store Init Req pointer, as this will be used for response */
4105 pWDA->wdaMsgParam = (void *)postAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4106 /* store Params pass it to WDI */
4107 pWDA->wdaWdiApiMsgParam = (void *)wdiPostAssocReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4108 status = WDI_PostAssocReq(wdiPostAssocReqParam,
4109 (WDI_PostAssocRspCb )WDA_PostAssocReqCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4110 if(IS_WDI_STATUS_FAILURE(status))
4111 {
4112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4113 "Failure in Post Assoc WDI API, free all the memory " );
4114 vos_mem_free(pWDA->wdaWdiApiMsgParam) ;
4115 pWDA->wdaWdiApiMsgParam = NULL;
4116 pWDA->wdaMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4117 postAssocReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4118 WDA_SendMsg(pWDA, WDA_POST_ASSOC_RSP, (void *)postAssocReqParam, 0) ;
4119 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4120 return CONVERT_WDI2VOS_STATUS(status) ;
4121}
4122#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4123/*
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4124 * FUNCTION: WDA_AddStaRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4125 * ADD STA req callback, send RSP back to PE
4126 */
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4127void WDA_AddStaRspCallback(WDI_ConfigSTARspParamsType *wdiConfigStaRsp,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4128 void* pUserData)
4129{
4130 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4131 tWDA_CbContext *pWDA;
4132 tAddStaParams *addStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4133 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4134 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4135 if(NULL == pWdaParams)
4136 {
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4137 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]4138 VOS_ASSERT(0) ;
4139 return ;
4140 }
4141 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4142 addStaReqParam = (tAddStaParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4143 addStaReqParam->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4144 wdiConfigStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4145 if(WDI_STATUS_SUCCESS == wdiConfigStaRsp->wdiStatus)
4146 {
4147 addStaReqParam->staIdx = wdiConfigStaRsp->ucSTAIdx;
4148 /*TODO: UMAC structure doesn't have these fields*/
4149 /*addStaReqParam-> = wdiConfigStaRsp->ucDpuIndex;
4150 addStaReqParam-> = wdiConfigStaRsp->ucBcastDpuIndex;
4151 addStaReqParam-> = wdiConfigStaRsp->ucBcastMgmtDpuIdx; */
4152 addStaReqParam->ucUcastSig = wdiConfigStaRsp->ucUcastSig;
4153 addStaReqParam->ucBcastSig = wdiConfigStaRsp->ucBcastSig;
4154 /* update staIndex as valid index for BA if STA is HT capable*/
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]4155#ifdef FEATURE_WLAN_TDLS
4156 if( (addStaReqParam->staType == STA_ENTRY_PEER ||
4157 addStaReqParam->staType == STA_ENTRY_TDLS_PEER) && addStaReqParam->htCapable)
4158#else
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4159 if(addStaReqParam->staType == STA_ENTRY_PEER && addStaReqParam->htCapable)
Mohit Khanna698ba2a2012-12-04 15:08:18 -0800[diff] [blame]4160#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4161 {
4162 pWDA->wdaStaInfo[addStaReqParam->staIdx].bssIdx =
4163 wdiConfigStaRsp->ucBssIdx;
4164 pWDA->wdaStaInfo[addStaReqParam->staIdx].ucValidStaIndex =
4165 WDA_VALID_STA_INDEX ;
Abhishek Singhf08a82b2014-10-07 11:00:42 +0530[diff] [blame]4166 pWDA->wdaStaInfo[addStaReqParam->staIdx].currentOperChan =
4167 addStaReqParam->currentOperChan;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4168 }
4169 if(WDI_DS_AddSTAMemPool(pWDA->pWdiContext, wdiConfigStaRsp->ucSTAIdx))
4170 {
4171 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4172 "%s: add STA into mempool fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4173 VOS_ASSERT(0) ;
4174 return ;
4175 }
4176 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4177 else
4178 {
4179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4180 "%s: Failure with status %d", __func__,
4181 wdiConfigStaRsp->wdiStatus);
4182 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4183 WLAN_LOG_INDICATOR_HOST_DRIVER,
4184 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
4185 FALSE, TRUE);
4186 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4187 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
4188 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4189 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4190 return ;
4191}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4192void WDA_AddStaReqCallback(WDI_Status wdiStatus,
4193 void* pUserData)
4194{
4195 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4196 tWDA_CbContext *pWDA;
4197 tAddStaParams *addStaParams;
4198
4199 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4200 "<------ %s, wdiStatus: %d",
4201 __func__, wdiStatus);
4202
4203 if (NULL == pWdaParams)
4204 {
4205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4206 "%s: Invalid pWdaParams pointer", __func__);
4207 VOS_ASSERT(0);
4208 return;
4209 }
4210
4211 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4212 addStaParams = (tAddStaParams *)pWdaParams->wdaMsgParam;
4213
4214 addStaParams->status = wdiStatus;
4215
4216 if (IS_WDI_STATUS_FAILURE(wdiStatus))
4217 {
4218 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4219 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4220 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4221 WLAN_LOG_INDICATOR_HOST_DRIVER,
4222 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
4223 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4224 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaParams , 0);
4225 }
4226
4227 return ;
4228}
4229
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4230/*
4231 * FUNCTION: WDA_ConfigStaReq
4232 * Trigger Config STA processing in WDI
4233 */
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4234VOS_STATUS WDA_ProcessAddStaReq(tWDA_CbContext *pWDA,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4235 tAddStaParams *addStaReqParam)
4236{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4237 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4238 WDI_ConfigSTAReqParamsType *wdiConfigStaReqParam =
4239 (WDI_ConfigSTAReqParamsType *)vos_mem_malloc(
4240 sizeof(WDI_ConfigSTAReqParamsType)) ;
4241 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4242 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4243 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4244 if(NULL == wdiConfigStaReqParam)
4245 {
4246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4247 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4248 VOS_ASSERT(0);
4249 return VOS_STATUS_E_NOMEM;
4250 }
4251 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4252 if(NULL == pWdaParams)
4253 {
4254 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4255 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4256 VOS_ASSERT(0);
4257 vos_mem_free(wdiConfigStaReqParam);
4258 return VOS_STATUS_E_NOMEM;
4259 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4260 vos_mem_set(wdiConfigStaReqParam, sizeof(WDI_ConfigSTAReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4261 /* update STA params into WDI structure */
4262 WDA_UpdateSTAParams(pWDA, &wdiConfigStaReqParam->wdiReqInfo,
4263 addStaReqParam) ;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4264 wdiConfigStaReqParam->wdiReqStatusCB = WDA_AddStaReqCallback;
4265 wdiConfigStaReqParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4266 /* Store Init Req pointer, as this will be used for response */
4267 /* store Params pass it to WDI */
4268 pWdaParams->pWdaContext = pWDA;
4269 pWdaParams->wdaMsgParam = addStaReqParam;
4270 pWdaParams->wdaWdiApiMsgParam = wdiConfigStaReqParam;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4271
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4272 status = WDI_ConfigSTAReq(wdiConfigStaReqParam,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4273 (WDI_ConfigSTARspCb )WDA_AddStaRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4274 if(IS_WDI_STATUS_FAILURE(status))
4275 {
4276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4277 "Failure in Config STA WDI API, free all the memory " );
4278 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4279 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4280 addStaReqParam->status = eSIR_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4281 WDA_SendMsg(pWDA, WDA_ADD_STA_RSP, (void *)addStaReqParam, 0) ;
4282 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4283 return CONVERT_WDI2VOS_STATUS(status) ;
4284}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4285
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4286/*
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4287 * FUNCTION: WDA_DelBSSRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4288 * Dens DEL BSS RSP back to PE
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4289 */
4290void WDA_DelBSSRspCallback(WDI_DelBSSRspParamsType *wdiDelBssRsp,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4291 void* pUserData)
4292{
4293 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4294 tWDA_CbContext *pWDA;
4295 tDeleteBssParams *delBssReqParam;
4296 tANI_U8 staIdx,tid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4298 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4299 if(NULL == pWdaParams)
4300 {
4301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4302 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4303 VOS_ASSERT(0) ;
4304 return ;
4305 }
4306 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4307 delBssReqParam = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4308 delBssReqParam->status = wdiDelBssRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4309 if(WDI_STATUS_SUCCESS == wdiDelBssRsp->wdiStatus)
4310 {
4311 vos_mem_copy(delBssReqParam->bssid, wdiDelBssRsp->macBSSID,
4312 sizeof(tSirMacAddr)) ;
4313 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4314 else
4315 {
4316 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4317 "%s: Failure with status %d", __func__,
4318 wdiDelBssRsp->wdiStatus);
4319 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4320 WLAN_LOG_INDICATOR_HOST_DRIVER,
4321 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4322 FALSE, TRUE);
4323 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4324 if(WDI_DS_GetStaIdxFromBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, &staIdx))
4325 {
4326 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4327 "%s: Get STA index from BSS index Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4328 VOS_ASSERT(0) ;
4329 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4330 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, staIdx))
4331 {
4332 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4333 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4334 VOS_ASSERT(0) ;
4335 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4336 if(WDI_DS_ClearStaIdxPerBssIdx(pWDA->pWdiContext, delBssReqParam->bssIdx, staIdx))
4337 {
4338 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4339 "%s: Clear STA index form table Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4340 VOS_ASSERT(0) ;
4341 }
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4342
4343 WLANTL_StartForwarding(staIdx,0,0);
4344
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4345 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4346 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4347 /* reset the the system role*/
4348 pWDA->wdaGlobalSystemRole = eSYSTEM_UNKNOWN_ROLE;
4349
4350 /* Reset the BA related information */
4351 for(staIdx=0; staIdx < WDA_MAX_STA; staIdx++)
4352 {
4353 if( pWDA->wdaStaInfo[staIdx].bssIdx == wdiDelBssRsp->ucBssIdx )
4354 {
4355 pWDA->wdaStaInfo[staIdx].ucValidStaIndex = WDA_INVALID_STA_INDEX;
4356 pWDA->wdaStaInfo[staIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]4357 pWDA->wdaStaInfo[staIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4358 /* Reset framesTxed counters here */
4359 for(tid = 0; tid < STACFG_MAX_TC; tid++)
4360 {
4361 pWDA->wdaStaInfo[staIdx].framesTxed[tid] = 0;
4362 }
4363 }
4364 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4365
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4366 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4367 return ;
4368}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4369void WDA_DelBSSReqCallback(WDI_Status wdiStatus,
4370 void* pUserData)
4371{
4372 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4373 tWDA_CbContext *pWDA;
4374 tDeleteBssParams *delbssParams;
4375
4376 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4377 "<------ %s, wdiStatus: %d",
4378 __func__, wdiStatus);
4379
4380 if (NULL == pWdaParams)
4381 {
4382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4383 "%s: Invalid pWdaParams pointer", __func__);
4384 VOS_ASSERT(0);
4385 return;
4386 }
4387
4388 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4389 delbssParams = (tDeleteBssParams *)pWdaParams->wdaMsgParam;
4390
4391 delbssParams->status = wdiStatus ;
4392
4393 if (IS_WDI_STATUS_FAILURE(wdiStatus))
4394 {
4395 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4396 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4397 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4398 WLAN_LOG_INDICATOR_HOST_DRIVER,
4399 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4400 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4401 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delbssParams , 0) ;
4402 }
4403
4404 return ;
4405}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4406
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4407/*
4408 * FUNCTION: WDA_ProcessDelBssReq
4409 * Init DEL BSS req with WDI
4410 */
4411VOS_STATUS WDA_ProcessDelBssReq(tWDA_CbContext *pWDA,
4412 tDeleteBssParams *delBssParam)
4413{
4414 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4415 WDI_DelBSSReqParamsType *wdiDelBssReqParam =
4416 (WDI_DelBSSReqParamsType *)vos_mem_malloc(
4417 sizeof(WDI_DelBSSReqParamsType)) ;
4418 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4420 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4421 if(NULL == wdiDelBssReqParam)
4422 {
4423 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4424 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4425 VOS_ASSERT(0);
4426 return VOS_STATUS_E_NOMEM;
4427 }
4428 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4429 if(NULL == pWdaParams)
4430 {
4431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4432 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4433 VOS_ASSERT(0);
4434 vos_mem_free(wdiDelBssReqParam);
4435 return VOS_STATUS_E_NOMEM;
4436 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4437 wdiDelBssReqParam->ucBssIdx = delBssParam->bssIdx;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4438 wdiDelBssReqParam->wdiReqStatusCB = WDA_DelBSSReqCallback ;
4439 wdiDelBssReqParam->pUserData = pWdaParams;
4440
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4441 /* Store Init Req pointer, as this will be used for response */
4442 /* store Params pass it to WDI */
4443 pWdaParams->pWdaContext = pWDA;
4444 pWdaParams->wdaMsgParam = delBssParam;
4445 pWdaParams->wdaWdiApiMsgParam = wdiDelBssReqParam;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4446
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4447 status = WDI_DelBSSReq(wdiDelBssReqParam,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4448 (WDI_DelBSSRspCb )WDA_DelBSSRspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4449 if(IS_WDI_STATUS_FAILURE(status))
4450 {
4451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4452 "Failure in Del BSS WDI API, free all the memory " );
4453 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4454 vos_mem_free(pWdaParams) ;
4455 delBssParam->status = eSIR_FAILURE ;
4456 WDA_SendMsg(pWDA, WDA_DELETE_BSS_RSP, (void *)delBssParam, 0) ;
4457 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4458 return CONVERT_WDI2VOS_STATUS(status) ;
4459}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4460/*
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4461 * FUNCTION: WDA_DelSTARspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4462 * Dens DEL STA RSP back to PE
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4463 */
4464void WDA_DelSTARspCallback(WDI_DelSTARspParamsType *wdiDelStaRsp,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4465 void* pUserData)
4466{
4467 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4468 tWDA_CbContext *pWDA;
4469 tDeleteStaParams *delStaReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4470 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4471 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4472 if(NULL == pWdaParams)
4473 {
4474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4475 "%s: pWdaParams received NULL", __func__);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4476 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4477 return ;
4478 }
4479 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4480 delStaReqParam = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4481 delStaReqParam->status = wdiDelStaRsp->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4482 if(WDI_STATUS_SUCCESS == wdiDelStaRsp->wdiStatus)
4483 {
4484 if(WDI_DS_DelSTAMemPool(pWDA->pWdiContext, wdiDelStaRsp->ucSTAIdx))
4485 {
4486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4487 "%s: DEL STA from MemPool Fail", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4488 VOS_ASSERT(0) ;
4489 }
4490 delStaReqParam->staIdx = wdiDelStaRsp->ucSTAIdx ;
Mihir Shete2ab1d492014-06-04 14:21:05 +0530[diff] [blame]4491 WLANTL_StartForwarding(delStaReqParam->staIdx,0,0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4492 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4493 else
4494 {
4495 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4496 "%s: Failure with status %d", __func__,
4497 wdiDelStaRsp->wdiStatus);
4498 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4499 WLAN_LOG_INDICATOR_HOST_DRIVER,
4500 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4501 FALSE, TRUE);
4502 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4503 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4504 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4505 /*Reset the BA information corresponding to this STAIdx */
4506 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucValidStaIndex =
4507 WDA_INVALID_STA_INDEX;
4508 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].ucUseBaBitmap = 0;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]4509 pWDA->wdaStaInfo[wdiDelStaRsp->ucSTAIdx].currentOperChan = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4510 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaReqParam , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4511 return ;
4512}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4513void WDA_DelSTAReqCallback(WDI_Status wdiStatus,
4514 void* pUserData)
4515{
4516 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4517 tWDA_CbContext *pWDA;
4518 tDeleteStaParams *delStaParams;
4519
4520 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4521 "<------ %s, wdiStatus: %d",
4522 __func__, wdiStatus);
4523
4524 if (NULL == pWdaParams)
4525 {
4526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4527 "%s: Invalid pWdaParams pointer", __func__);
4528 VOS_ASSERT(0);
4529 return;
4530 }
4531
4532 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4533 delStaParams = (tDeleteStaParams *)pWdaParams->wdaMsgParam;
4534
4535 delStaParams->status = wdiStatus ;
4536
4537 if (IS_WDI_STATUS_FAILURE(wdiStatus))
4538 {
4539 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4540 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4541 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4542 WLAN_LOG_INDICATOR_HOST_DRIVER,
4543 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4544 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4545 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParams , 0) ;
4546 }
4547
4548 return ;
4549}
4550
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4551/*
4552 * FUNCTION: WDA_ProcessDelStaReq
4553 * Init DEL STA req with WDI
4554 */
4555VOS_STATUS WDA_ProcessDelStaReq(tWDA_CbContext *pWDA,
4556 tDeleteStaParams *delStaParam)
4557{
4558 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4559 WDI_DelSTAReqParamsType *wdiDelStaReqParam =
4560 (WDI_DelSTAReqParamsType *)vos_mem_malloc(
4561 sizeof(WDI_DelSTAReqParamsType)) ;
4562 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4563 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4564 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4565 if(NULL == wdiDelStaReqParam)
4566 {
4567 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4568 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4569 VOS_ASSERT(0);
4570 return VOS_STATUS_E_NOMEM;
4571 }
4572 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4573 if(NULL == pWdaParams)
4574 {
4575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4576 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4577 VOS_ASSERT(0);
4578 vos_mem_free(wdiDelStaReqParam);
4579 return VOS_STATUS_E_NOMEM;
4580 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4581 wdiDelStaReqParam->ucSTAIdx = delStaParam->staIdx ;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4582 wdiDelStaReqParam->wdiReqStatusCB = WDA_DelSTAReqCallback ;
4583 wdiDelStaReqParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4584 /* Store Init Req pointer, as this will be used for response */
4585 /* store Params pass it to WDI */
4586 pWdaParams->pWdaContext = pWDA;
4587 pWdaParams->wdaMsgParam = delStaParam;
4588 pWdaParams->wdaWdiApiMsgParam = wdiDelStaReqParam;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4589
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4590 status = WDI_DelSTAReq(wdiDelStaReqParam,
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4591 (WDI_DelSTARspCb )WDA_DelSTARspCallback, pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4592 if(IS_WDI_STATUS_FAILURE(status))
4593 {
4594 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4595 "Failure in Del STA WDI API, free all the memory status = %d",
4596 status );
4597 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4598 vos_mem_free(pWdaParams) ;
4599 delStaParam->status = eSIR_FAILURE ;
4600 WDA_SendMsg(pWDA, WDA_DELETE_STA_RSP, (void *)delStaParam, 0) ;
4601 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4602 return CONVERT_WDI2VOS_STATUS(status) ;
4603}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4604void WDA_ProcessAddStaSelfRspCallback(WDI_AddSTASelfRspParamsType* pwdiAddSTASelfRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4605{
4606 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4607 tWDA_CbContext *pWDA;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4608 tAddStaSelfParams *pAddStaSelfRsp = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4610 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4611 if(NULL == pWdaParams)
4612 {
4613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4614 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4615 VOS_ASSERT(0) ;
4616 return ;
4617 }
4618 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4619 pAddStaSelfRsp = (tAddStaSelfParams*)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4620 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4621 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4622 pAddStaSelfRsp->status = CONVERT_WDI2SIR_STATUS(pwdiAddSTASelfRsp->wdiStatus);
4623 vos_mem_copy(pAddStaSelfRsp->selfMacAddr,
4624 pwdiAddSTASelfRsp->macSelfSta,
4625 sizeof(pAddStaSelfRsp->selfMacAddr));
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4626 pWDA->wdaAddSelfStaParams.ucSTASelfIdx = pwdiAddSTASelfRsp->ucSTASelfIdx;
4627 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaRspCounter++;
4628 if (pAddStaSelfRsp->status == eSIR_FAILURE)
4629 {
4630 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_RSP_WDI_FAIL;
4631 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4633 "%s: Failure with status %d failcnter %d", __func__,
4634 pwdiAddSTASelfRsp->wdiStatus,
4635 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter);
4636 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4637 WLAN_LOG_INDICATOR_HOST_DRIVER,
4638 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
4639 FALSE, TRUE);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4640 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4641 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfRsp, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4642 return ;
4643}
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4644void WDA_ProcessAddStaSelfReqCallback(WDI_Status wdiStatus,
4645 void* pUserData)
4646{
4647 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4648 tWDA_CbContext *pWDA;
4649 tAddStaSelfParams *addStaSelfParams;
4650
4651 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
4652 "<------ %s, wdiStatus: %d",
4653 __func__, wdiStatus);
4654
4655 if (NULL == pWdaParams)
4656 {
4657 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4658 "%s: Invalid pWdaParams pointer", __func__);
4659 VOS_ASSERT(0);
4660 return;
4661 }
4662
4663 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4664 addStaSelfParams = (tAddStaSelfParams *)pWdaParams->wdaMsgParam;
4665
4666 addStaSelfParams->status = wdiStatus ;
4667
4668 if (IS_WDI_STATUS_FAILURE(wdiStatus))
4669 {
4670 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4671 vos_mem_free(pWdaParams) ;
4672 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason
4673 = WDA_ADDSTA_REQ_WDI_FAIL;
4674 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4676 "%s: Failure with status %d failcnter %d", __func__,
4677 wdiStatus,
4678 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter);
4679 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4680 WLAN_LOG_INDICATOR_HOST_DRIVER,
4681 WLAN_LOG_REASON_ADD_BSS_STA_FAIL,
4682 FALSE, TRUE);
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4683 WDA_SendMsg(pWDA, WDA_ADD_STA_SELF_RSP, (void *)addStaSelfParams , 0);
4684 }
4685
4686 return ;
4687}
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4688
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4689/*
4690 * FUNCTION: WDA_ProcessAddStaSelfReq
4691 *
4692 */
4693VOS_STATUS WDA_ProcessAddStaSelfReq( tWDA_CbContext *pWDA, tpAddStaSelfParams pAddStaSelfReq)
4694{
4695 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4696 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4697 WDI_AddSTASelfReqParamsType *wdiAddStaSelfReq =
4698 (WDI_AddSTASelfReqParamsType *)vos_mem_malloc(
4699 sizeof(WDI_AddSTASelfReqParamsType)) ;
4700 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4702 "------> %s " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4703 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaReqCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4704 if( NULL == wdiAddStaSelfReq )
4705 {
4706 VOS_ASSERT( 0 );
4707 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4708 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4709 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4710 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4711 return( VOS_STATUS_E_NOMEM );
4712 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4713 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4714 if( NULL == pWdaParams )
4715 {
4716 VOS_ASSERT( 0 );
4717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4718 "%s: Unable to allocate memory " ,__func__);
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4719 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_NO_MEM;
4720 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4721 vos_mem_free(wdiAddStaSelfReq) ;
4722 return( VOS_STATUS_E_NOMEM );
4723 }
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4724 wdiAddStaSelfReq->wdiReqStatusCB = WDA_ProcessAddStaSelfReqCallback;
4725 wdiAddStaSelfReq->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4726 vos_mem_copy( wdiAddStaSelfReq->wdiAddSTASelfInfo.selfMacAddr, pAddStaSelfReq->selfMacAddr, 6);
Kiran Kumar Lokere0ad5cd32013-06-25 11:26:22 -0700[diff] [blame]4727 wdiAddStaSelfReq->wdiAddSTASelfInfo.currDeviceMode = pAddStaSelfReq->currDeviceMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4728 /* Store Init Req pointer, as this will be used for response */
4729 /* store Params pass it to WDI */
4730 pWdaParams->pWdaContext = pWDA;
4731 pWdaParams->wdaMsgParam = pAddStaSelfReq;
Abhishek Singhf1221ab2015-08-04 16:38:39 +0530[diff] [blame]4732 pWdaParams->wdaWdiApiMsgParam = wdiAddStaSelfReq;
4733
4734 wstatus = WDI_AddSTASelfReq( wdiAddStaSelfReq,
4735 WDA_ProcessAddStaSelfRspCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4736
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4737 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4738 {
4739 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4740 "Failure in Add Self Sta Request API, free all the memory status = %d",
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4741 wstatus );
4742 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4743 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4744 vos_mem_free(pWdaParams) ;
Siddharth Bhal85f99b12014-05-09 08:09:07 +0530[diff] [blame]4745 pWDA->wdaAddSelfStaParams.wdaAddSelfStaFailReason = WDA_ADDSTA_REQ_WDI_FAIL;
4746 pWDA->wdaAddSelfStaParams.wdiAddStaSelfStaFailCounter++;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4747 pAddStaSelfReq->status = eSIR_FAILURE ;
4748 WDA_SendMsg( pWDA, WDA_ADD_STA_SELF_RSP, (void *)pAddStaSelfReq, 0) ;
4749 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4750 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4751}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4752/*
4753 * FUNCTION: WDA_DelSTASelfRespCallback
4754 *
4755 */
4756void WDA_DelSTASelfRespCallback(WDI_DelSTASelfRspParamsType *
4757 wdiDelStaSelfRspParams , void* pUserData)
4758{
4759 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4760 tWDA_CbContext *pWDA;
4761 tDelStaSelfParams *delStaSelfParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4762 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4763 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4764 if (NULL == pWdaParams)
4765 {
4766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4767 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4768 VOS_ASSERT(0);
4769 return;
4770 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4771 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4772 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4773 delStaSelfParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4774 wdiDelStaSelfRspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4775
4776 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4777 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4778 if (WDI_STATUS_SUCCESS != delStaSelfParams->status)
4779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
4780 "%s: Failure with status %d", __func__,
4781 wdiDelStaSelfRspParams->wdiStatus);
4782 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4783 WLAN_LOG_INDICATOR_HOST_DRIVER,
4784 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4785 FALSE, TRUE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4786 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4787 return ;
4788}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4789/*
4790 * FUNCTION: WDA_DelSTASelfReqCallback
4791 *
4792 */
4793void WDA_DelSTASelfReqCallback(WDI_Status wdiStatus,
4794 void* pUserData)
4795{
4796 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
4797 tWDA_CbContext *pWDA;
4798 tDelStaSelfParams *delStaSelfParams;
4799
4800 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]4801 "<------ %s, wdiStatus: %d pWdaParams: %p",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4802 __func__, wdiStatus, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4803
4804 if (NULL == pWdaParams)
4805 {
4806 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4807 "%s: Invalid pWdaParams pointer", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4808 VOS_ASSERT(0);
4809 return;
4810 }
4811
4812 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
4813 delStaSelfParams = (tDelStaSelfParams *)pWdaParams->wdaMsgParam;
4814
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]4815 delStaSelfParams->status = wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4816
4817 if(IS_WDI_STATUS_FAILURE(wdiStatus))
4818 {
4819 VOS_ASSERT(0);
4820 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4821 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]4822 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
4823 WLAN_LOG_INDICATOR_HOST_DRIVER,
4824 WLAN_LOG_REASON_DEL_BSS_STA_FAIL,
4825 FALSE, TRUE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4826 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)delStaSelfParams , 0) ;
4827 }
4828
4829 return ;
4830}
4831
4832/*
4833 * FUNCTION: WDA_DelSTASelfReq
4834 * Trigger Config STA processing in WDI
4835 */
4836VOS_STATUS WDA_ProcessDelSTASelfReq(tWDA_CbContext *pWDA,
4837 tDelStaSelfParams* pDelStaSelfReqParam)
4838{
4839 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4840 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4841 tWDA_ReqParams *pWdaParams = NULL;
4842 WDI_DelSTASelfReqParamsType *wdiDelStaSelfReq =
4843 (WDI_DelSTASelfReqParamsType *)vos_mem_malloc(
4844 sizeof(WDI_DelSTASelfReqParamsType)) ;
4845
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4846 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4847 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4848 if( NULL == wdiDelStaSelfReq )
4849 {
4850 VOS_ASSERT( 0 );
4851 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4852 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4853 return( VOS_STATUS_E_NOMEM );
4854 }
4855
4856 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
4857 if( NULL == pWdaParams )
4858 {
4859 VOS_ASSERT( 0 );
4860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4861 "%s: Unable to allocate memory " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4862 vos_mem_free(wdiDelStaSelfReq) ;
4863 return( VOS_STATUS_E_NOMEM );
4864 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4865 pWdaParams->pWdaContext = pWDA;
4866 /* Store param pointer as passed in by caller */
4867 pWdaParams->wdaMsgParam = pDelStaSelfReqParam;
4868 /* store Params pass it to WDI */
4869 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelStaSelfReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4870 vos_mem_copy( wdiDelStaSelfReq->wdiDelStaSelfInfo.selfMacAddr,
4871 pDelStaSelfReqParam->selfMacAddr, sizeof(tSirMacAddr));
4872
4873 wdiDelStaSelfReq->wdiReqStatusCB = WDA_DelSTASelfReqCallback;
4874 wdiDelStaSelfReq->pUserData = pWdaParams;
4875
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4876 wstatus = WDI_DelSTASelfReq(wdiDelStaSelfReq,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4877 (WDI_DelSTASelfRspCb)WDA_DelSTASelfRespCallback, pWdaParams);
4878
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4879 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4880 {
4881 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
4882 "Failure in Del Sta Self REQ WDI API, free all the memory " );
4883 VOS_ASSERT(0);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4884 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4885 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
4886 vos_mem_free(pWdaParams) ;
4887 pDelStaSelfReqParam->status = eSIR_FAILURE ;
4888 WDA_SendMsg(pWDA, WDA_DEL_STA_SELF_RSP, (void *)pDelStaSelfReqParam, 0) ;
4889 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4890 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4891}
4892
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4893/*
4894 * FUNCTION: WDA_SendMsg
4895 * Send Message back to PE
4896 */
4897void WDA_SendMsg(tWDA_CbContext *pWDA, tANI_U16 msgType,
4898 void *pBodyptr, tANI_U32 bodyVal)
4899{
4900 tSirMsgQ msg = {0} ;
4901 tANI_U32 status = VOS_STATUS_SUCCESS ;
4902 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4903 msg.type = msgType;
4904 msg.bodyval = bodyVal;
4905 msg.bodyptr = pBodyptr;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4906 status = limPostMsgApi(pMac, &msg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4907 if (VOS_STATUS_SUCCESS != status)
4908 {
4909 if(NULL != pBodyptr)
4910 {
4911 vos_mem_free(pBodyptr);
4912 }
4913 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]4914 "%s: limPostMsgApi is failed " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4915 VOS_ASSERT(0) ;
4916 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4917 return ;
4918}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4919/*
4920 * FUNCTION: WDA_UpdateBSSParams
4921 * Translated WDA/PE BSS info into WDI BSS info..
4922 */
4923void WDA_UpdateBSSParams(tWDA_CbContext *pWDA,
4924 WDI_ConfigBSSReqInfoType *wdiBssParams,
4925 tAddBssParams *wdaBssParams)
4926{
4927 v_U8_t keyIndex = 0;
Srinivas Dasari9b57b112014-11-27 12:25:23 +0530[diff] [blame]4928 v_U8_t i = 0;
4929
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4930 /* copy bssReq Params to WDI structure */
4931 vos_mem_copy(wdiBssParams->macBSSID,
4932 wdaBssParams->bssId, sizeof(tSirMacAddr)) ;
4933 vos_mem_copy(wdiBssParams->macSelfAddr, wdaBssParams->selfMacAddr,
4934 sizeof(tSirMacAddr)) ;
4935 wdiBssParams->wdiBSSType = wdaBssParams->bssType ;
4936 wdiBssParams->ucOperMode = wdaBssParams->operMode ;
4937 wdiBssParams->wdiNWType = wdaBssParams->nwType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4938 wdiBssParams->ucShortSlotTimeSupported =
4939 wdaBssParams->shortSlotTimeSupported ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4940 wdiBssParams->ucllaCoexist = wdaBssParams->llaCoexist ;
4941 wdiBssParams->ucllbCoexist = wdaBssParams->llbCoexist ;
4942 wdiBssParams->ucllgCoexist = wdaBssParams->llgCoexist ;
4943 wdiBssParams->ucHT20Coexist = wdaBssParams->ht20Coexist ;
4944 wdiBssParams->ucObssProtEnabled = wdaBssParams->obssProtEnabled ;
4945
4946 wdiBssParams->ucllnNonGFCoexist = wdaBssParams->llnNonGFCoexist ;
4947 wdiBssParams->ucTXOPProtectionFullSupport =
4948 wdaBssParams->fLsigTXOPProtectionFullSupport ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4949 wdiBssParams->ucRIFSMode = wdaBssParams->fRIFSMode ;
4950 wdiBssParams->usBeaconInterval = wdaBssParams->beaconInterval ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4951 wdiBssParams->ucDTIMPeriod = wdaBssParams->dtimPeriod ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4952 wdiBssParams->ucTXChannelWidthSet = wdaBssParams->txChannelWidthSet ;
4953 wdiBssParams->ucCurrentOperChannel = wdaBssParams->currentOperChannel ;
4954 wdiBssParams->ucCurrentExtChannel = wdaBssParams->currentExtChannel ;
4955 wdiBssParams->bHiddenSSIDEn = wdaBssParams->bHiddenSSIDEn ;
4956
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]4957 wdiBssParams->ucRMFEnabled = wdaBssParams->rmfEnabled;
4958
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4959 /* copy SSID into WDI structure */
4960 wdiBssParams->wdiSSID.ucLength = wdaBssParams->ssId.length ;
4961 vos_mem_copy(wdiBssParams->wdiSSID.sSSID,
4962 wdaBssParams->ssId.ssId, wdaBssParams->ssId.length) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4963 WDA_UpdateSTAParams(pWDA, &wdiBssParams->wdiSTAContext,
4964 &wdaBssParams->staContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4965 wdiBssParams->wdiAction = wdaBssParams->updateBss;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4966#ifdef WLAN_FEATURE_VOWIFI
4967 wdiBssParams->cMaxTxPower = wdaBssParams->maxTxPower;
4968#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4969 wdiBssParams->ucPersona = wdaBssParams->halPersona;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4970 wdiBssParams->bSpectrumMgtEn = wdaBssParams->bSpectrumMgtEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4971#ifdef WLAN_FEATURE_VOWIFI_11R
4972 wdiBssParams->bExtSetStaKeyParamValid = wdaBssParams->extSetStaKeyParamValid;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4973 if(wdiBssParams->bExtSetStaKeyParamValid)
4974 {
4975 /* copy set STA key params to WDI structure */
4976 wdiBssParams->wdiExtSetKeyParam.ucSTAIdx =
4977 wdaBssParams->extSetStaKeyParam.staIdx;
4978 wdiBssParams->wdiExtSetKeyParam.wdiEncType =
4979 wdaBssParams->extSetStaKeyParam.encType;
4980 wdiBssParams->wdiExtSetKeyParam.wdiWEPType =
4981 wdaBssParams->extSetStaKeyParam.wepType;
4982 wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx =
4983 wdaBssParams->extSetStaKeyParam.defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4984 if(wdaBssParams->extSetStaKeyParam.encType != eSIR_ED_NONE)
4985 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]4986 if( (wdiBssParams->wdiExtSetKeyParam.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4987 (WDA_INVALID_KEY_INDEX == wdaBssParams->extSetStaKeyParam.defWEPIdx) &&
4988 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
4989 {
4990 WDA_GetWepKeysFromCfg( pWDA,
4991 &wdiBssParams->wdiExtSetKeyParam.ucDefWEPIdx,
4992 &wdiBssParams->wdiExtSetKeyParam.ucNumKeys,
4993 wdiBssParams->wdiExtSetKeyParam.wdiKey );
4994 }
4995 else
4996 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]4997 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
4998 keyIndex++)
4999 {
5000 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyId =
5001 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyId;
5002 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].unicast =
5003 wdaBssParams->extSetStaKeyParam.key[keyIndex].unicast;
5004 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyDirection =
5005 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyDirection;
Srinivas Dasari9b57b112014-11-27 12:25:23 +0530[diff] [blame]5006
5007 if(WDA_getHostWlanFeatCaps(DISA) && WDA_getFwWlanFeatCaps(DISA))
5008 {
5009 for (i = 0; i < WLAN_MAX_KEY_RSC_LEN; i ++)
5010 {
5011 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc[i] =
5012 ~(wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc[i]);
5013 }
5014
5015 for (i = 0; i < SIR_MAC_MAX_KEY_LENGTH; i++)
5016 {
5017 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key[i] =
5018 ~(wdaBssParams->extSetStaKeyParam.key[keyIndex].key[i]);
5019 }
5020 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5021 FL("%s: Negated Keys"), __func__);
5022 }
5023 else
5024 {
5025 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5026 FL("%s: No change in Keys "), __func__);
5027 vos_mem_copy(
5028 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyRsc,
5029 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyRsc,
5030 WLAN_MAX_KEY_RSC_LEN);
5031 vos_mem_copy(
5032 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].key,
5033 wdaBssParams->extSetStaKeyParam.key[keyIndex].key,
5034 SIR_MAC_MAX_KEY_LENGTH);
5035 }
5036
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5037 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].paeRole =
5038 wdaBssParams->extSetStaKeyParam.key[keyIndex].paeRole;
5039 wdiBssParams->wdiExtSetKeyParam.wdiKey[keyIndex].keyLength =
5040 wdaBssParams->extSetStaKeyParam.key[keyIndex].keyLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5041 }
Srinivas Dasari9b57b112014-11-27 12:25:23 +0530[diff] [blame]5042 wdiBssParams->wdiExtSetKeyParam.ucNumKeys =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5043 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5044 }
5045 }
5046 wdiBssParams->wdiExtSetKeyParam.ucSingleTidRc = wdaBssParams->extSetStaKeyParam.singleTidRc;
5047 }
5048 else /* wdaBssParams->bExtSetStaKeyParamValid is not valid */
5049 {
5050 vos_mem_zero( &wdaBssParams->extSetStaKeyParam,
5051 sizeof(wdaBssParams->extSetStaKeyParam) );
5052 }
5053#endif /*WLAN_FEATURE_VOWIFI_11R*/
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5054#ifdef WLAN_FEATURE_11AC
5055 wdiBssParams->ucVhtCapableSta = wdaBssParams->vhtCapable;
5056 wdiBssParams->ucVhtTxChannelWidthSet = wdaBssParams->vhtTxChannelWidthSet;
5057#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5058
5059 return ;
5060}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5061/*
5062 * FUNCTION: WDA_UpdateSTAParams
5063 * Translated WDA/PE BSS info into WDI BSS info..
5064 */
5065void WDA_UpdateSTAParams(tWDA_CbContext *pWDA,
5066 WDI_ConfigStaReqInfoType *wdiStaParams,
5067 tAddStaParams *wdaStaParams)
5068{
5069 tANI_U8 i = 0;
5070 /* Update STA params */
5071 vos_mem_copy(wdiStaParams->macBSSID, wdaStaParams->bssId,
5072 sizeof(tSirMacAddr)) ;
5073 wdiStaParams->usAssocId = wdaStaParams->assocId;
5074 wdiStaParams->wdiSTAType = wdaStaParams->staType;
Gopichand Nakkalae7cbc5d2013-03-27 21:09:23 -0700[diff] [blame]5075 wdiStaParams->staIdx = wdaStaParams->staIdx;
5076
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5077 wdiStaParams->ucShortPreambleSupported =
5078 wdaStaParams->shortPreambleSupported;
5079 vos_mem_copy(wdiStaParams->macSTA, wdaStaParams->staMac,
5080 sizeof(tSirMacAddr)) ;
5081 wdiStaParams->usListenInterval = wdaStaParams->listenInterval;
5082
5083 wdiStaParams->ucWMMEnabled = wdaStaParams->wmmEnabled;
5084
5085 wdiStaParams->ucHTCapable = wdaStaParams->htCapable;
5086 wdiStaParams->ucTXChannelWidthSet = wdaStaParams->txChannelWidthSet;
5087 wdiStaParams->ucRIFSMode = wdaStaParams->rifsMode;
5088 wdiStaParams->ucLSIGTxopProtection = wdaStaParams->lsigTxopProtection;
5089 wdiStaParams->ucMaxAmpduSize = wdaStaParams->maxAmpduSize;
5090 wdiStaParams->ucMaxAmpduDensity = wdaStaParams->maxAmpduDensity;
5091 wdiStaParams->ucMaxAmsduSize = wdaStaParams->maxAmsduSize;
5092
5093 wdiStaParams->ucShortGI40Mhz = wdaStaParams->fShortGI40Mhz;
5094 wdiStaParams->ucShortGI20Mhz = wdaStaParams->fShortGI20Mhz;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5095 wdiStaParams->wdiSupportedRates.opRateMode =
5096 wdaStaParams->supportedRates.opRateMode;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5097 for(i = 0;i < WDI_NUM_11B_RATES;i++)
5098 {
5099 wdiStaParams->wdiSupportedRates.llbRates[i] =
5100 wdaStaParams->supportedRates.llbRates[i];
5101 }
5102 for(i = 0;i < WDI_NUM_11A_RATES;i++)
5103 {
5104 wdiStaParams->wdiSupportedRates.llaRates[i] =
5105 wdaStaParams->supportedRates.llaRates[i];
5106 }
5107 for(i = 0;i < SIR_NUM_POLARIS_RATES;i++)
5108 {
5109 wdiStaParams->wdiSupportedRates.aLegacyRates[i] =
5110 wdaStaParams->supportedRates.aniLegacyRates[i];
5111 }
5112 wdiStaParams->wdiSupportedRates.uEnhancedRateBitmap =
5113 wdaStaParams->supportedRates.aniEnhancedRateBitmap;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5114#ifdef WLAN_FEATURE_11AC
5115 wdiStaParams->wdiSupportedRates.vhtRxMCSMap = wdaStaParams->supportedRates.vhtRxMCSMap;
5116 wdiStaParams->wdiSupportedRates.vhtRxHighestDataRate = wdaStaParams->supportedRates.vhtRxHighestDataRate;
5117 wdiStaParams->wdiSupportedRates.vhtTxMCSMap = wdaStaParams->supportedRates.vhtTxMCSMap;
5118 wdiStaParams->wdiSupportedRates.vhtTxHighestDataRate = wdaStaParams->supportedRates.vhtTxHighestDataRate;
5119#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5120 for(i = 0;i <SIR_MAC_MAX_SUPPORTED_MCS_SET;i++)
5121 {
5122 wdiStaParams->wdiSupportedRates.aSupportedMCSSet[i] =
5123 wdaStaParams->supportedRates.supportedMCSSet[i];
5124 }
5125 wdiStaParams->wdiSupportedRates.aRxHighestDataRate =
5126 wdaStaParams->supportedRates.rxHighestDataRate;
5127
5128 wdiStaParams->ucRMFEnabled = wdaStaParams->rmfEnabled;
5129
5130 wdiStaParams->wdiAction = wdaStaParams->updateSta;
5131
5132 wdiStaParams->ucAPSD = wdaStaParams->uAPSD;
5133 wdiStaParams->ucMaxSPLen = wdaStaParams->maxSPLen;
5134 wdiStaParams->ucGreenFieldCapable = wdaStaParams->greenFieldCapable;
5135
5136 wdiStaParams->ucDelayedBASupport = wdaStaParams->delBASupport;
5137 wdiStaParams->us32MaxAmpduDuratio = wdaStaParams->us32MaxAmpduDuration;
5138 wdiStaParams->ucDsssCckMode40Mhz = wdaStaParams->fDsssCckMode40Mhz;
5139 wdiStaParams->ucEncryptType = wdaStaParams->encryptType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5140 wdiStaParams->ucP2pCapableSta = wdaStaParams->p2pCapableSta;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5141#ifdef WLAN_FEATURE_11AC
5142 wdiStaParams->ucVhtCapableSta = wdaStaParams->vhtCapable;
5143 wdiStaParams->ucVhtTxChannelWidthSet = wdaStaParams->vhtTxChannelWidthSet;
Shailender Karmuchi08f87c22013-01-17 12:51:24 -0800[diff] [blame]5144 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxBFCapable;
Abhishek Singh6927fa02014-06-27 17:19:55 +0530[diff] [blame]5145 wdiStaParams->vhtTxMUBformeeCapable = wdaStaParams->vhtTxMUBformeeCapable;
5146 /* When MU vhtTxMUBformeeCapable is set, SU ucVhtTxBFEnabled
5147 * must be set by default */
5148 if ( wdiStaParams->vhtTxMUBformeeCapable )
5149 wdiStaParams->ucVhtTxBFEnabled = wdaStaParams->vhtTxMUBformeeCapable;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5150#endif
Gopichand Nakkalab2d2c312013-01-04 11:41:02 -0800[diff] [blame]5151 wdiStaParams->ucHtLdpcEnabled= wdaStaParams->htLdpcCapable;
5152 wdiStaParams->ucVhtLdpcEnabled = wdaStaParams->vhtLdpcCapable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5153 return ;
5154}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5155/*
5156 * -------------------------------------------------------------------------
5157 * CFG update to WDI
5158 * -------------------------------------------------------------------------
5159 */
5160
5161 /*
5162 * FUNCTION: WDA_ConvertWniCfgIdToHALCfgId
5163 * Convert the WNI CFG ID to HAL CFG ID
5164 */
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]5165static inline v_U8_t WDA_ConvertWniCfgIdToHALCfgId(v_U32_t wniCfgId)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5166{
5167 switch(wniCfgId)
5168 {
5169 case WNI_CFG_STA_ID:
5170 return QWLAN_HAL_CFG_STA_ID;
5171 case WNI_CFG_CURRENT_TX_ANTENNA:
5172 return QWLAN_HAL_CFG_CURRENT_TX_ANTENNA;
5173 case WNI_CFG_CURRENT_RX_ANTENNA:
5174 return QWLAN_HAL_CFG_CURRENT_RX_ANTENNA;
5175 case WNI_CFG_LOW_GAIN_OVERRIDE:
5176 return QWLAN_HAL_CFG_LOW_GAIN_OVERRIDE;
5177 case WNI_CFG_POWER_STATE_PER_CHAIN:
5178 return QWLAN_HAL_CFG_POWER_STATE_PER_CHAIN;
5179 case WNI_CFG_CAL_PERIOD:
5180 return QWLAN_HAL_CFG_CAL_PERIOD;
5181 case WNI_CFG_CAL_CONTROL:
5182 return QWLAN_HAL_CFG_CAL_CONTROL;
5183 case WNI_CFG_PROXIMITY:
5184 return QWLAN_HAL_CFG_PROXIMITY;
5185 case WNI_CFG_NETWORK_DENSITY:
5186 return QWLAN_HAL_CFG_NETWORK_DENSITY;
5187 case WNI_CFG_MAX_MEDIUM_TIME:
5188 return QWLAN_HAL_CFG_MAX_MEDIUM_TIME;
5189 case WNI_CFG_MAX_MPDUS_IN_AMPDU:
5190 return QWLAN_HAL_CFG_MAX_MPDUS_IN_AMPDU;
5191 case WNI_CFG_RTS_THRESHOLD:
5192 return QWLAN_HAL_CFG_RTS_THRESHOLD;
5193 case WNI_CFG_SHORT_RETRY_LIMIT:
5194 return QWLAN_HAL_CFG_SHORT_RETRY_LIMIT;
5195 case WNI_CFG_LONG_RETRY_LIMIT:
5196 return QWLAN_HAL_CFG_LONG_RETRY_LIMIT;
5197 case WNI_CFG_FRAGMENTATION_THRESHOLD:
5198 return QWLAN_HAL_CFG_FRAGMENTATION_THRESHOLD;
5199 case WNI_CFG_DYNAMIC_THRESHOLD_ZERO:
5200 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ZERO;
5201 case WNI_CFG_DYNAMIC_THRESHOLD_ONE:
5202 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_ONE;
5203 case WNI_CFG_DYNAMIC_THRESHOLD_TWO:
5204 return QWLAN_HAL_CFG_DYNAMIC_THRESHOLD_TWO;
5205 case WNI_CFG_FIXED_RATE:
5206 return QWLAN_HAL_CFG_FIXED_RATE;
5207 case WNI_CFG_RETRYRATE_POLICY:
5208 return QWLAN_HAL_CFG_RETRYRATE_POLICY;
5209 case WNI_CFG_RETRYRATE_SECONDARY:
5210 return QWLAN_HAL_CFG_RETRYRATE_SECONDARY;
5211 case WNI_CFG_RETRYRATE_TERTIARY:
5212 return QWLAN_HAL_CFG_RETRYRATE_TERTIARY;
5213 case WNI_CFG_FORCE_POLICY_PROTECTION:
5214 return QWLAN_HAL_CFG_FORCE_POLICY_PROTECTION;
5215 case WNI_CFG_FIXED_RATE_MULTICAST_24GHZ:
5216 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_24GHZ;
5217 case WNI_CFG_FIXED_RATE_MULTICAST_5GHZ:
5218 return QWLAN_HAL_CFG_FIXED_RATE_MULTICAST_5GHZ;
5219 case WNI_CFG_DEFAULT_RATE_INDEX_24GHZ:
5220 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_24GHZ;
5221 case WNI_CFG_DEFAULT_RATE_INDEX_5GHZ:
5222 return QWLAN_HAL_CFG_DEFAULT_RATE_INDEX_5GHZ;
5223 case WNI_CFG_MAX_BA_SESSIONS:
5224 return QWLAN_HAL_CFG_MAX_BA_SESSIONS;
5225 case WNI_CFG_PS_DATA_INACTIVITY_TIMEOUT:
5226 return QWLAN_HAL_CFG_PS_DATA_INACTIVITY_TIMEOUT;
5227 case WNI_CFG_PS_ENABLE_BCN_FILTER:
5228 return QWLAN_HAL_CFG_PS_ENABLE_BCN_FILTER;
5229 case WNI_CFG_PS_ENABLE_RSSI_MONITOR:
5230 return QWLAN_HAL_CFG_PS_ENABLE_RSSI_MONITOR;
5231 case WNI_CFG_NUM_BEACON_PER_RSSI_AVERAGE:
5232 return QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
5233 case WNI_CFG_STATS_PERIOD:
5234 return QWLAN_HAL_CFG_STATS_PERIOD;
5235 case WNI_CFG_CFP_MAX_DURATION:
5236 return QWLAN_HAL_CFG_CFP_MAX_DURATION;
5237#if 0 /*This is not part of CFG*/
5238 case WNI_CFG_FRAME_TRANS_ENABLED:
5239 return QWLAN_HAL_CFG_FRAME_TRANS_ENABLED;
5240#endif
5241 case WNI_CFG_DTIM_PERIOD:
5242 return QWLAN_HAL_CFG_DTIM_PERIOD;
5243 case WNI_CFG_EDCA_WME_ACBK:
5244 return QWLAN_HAL_CFG_EDCA_WMM_ACBK;
5245 case WNI_CFG_EDCA_WME_ACBE:
5246 return QWLAN_HAL_CFG_EDCA_WMM_ACBE;
5247 case WNI_CFG_EDCA_WME_ACVI:
5248 return QWLAN_HAL_CFG_EDCA_WMM_ACVI;
5249 case WNI_CFG_EDCA_WME_ACVO:
5250 return QWLAN_HAL_CFG_EDCA_WMM_ACVO;
5251#if 0
5252 case WNI_CFG_TELE_BCN_WAKEUP_EN:
5253 return QWLAN_HAL_CFG_TELE_BCN_WAKEUP_EN;
5254 case WNI_CFG_TELE_BCN_TRANS_LI:
5255 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI;
5256 case WNI_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS:
5257 return QWLAN_HAL_CFG_TELE_BCN_TRANS_LI_IDLE_BCNS;
5258 case WNI_CFG_TELE_BCN_MAX_LI:
5259 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI;
5260 case WNI_CFG_TELE_BCN_MAX_LI_IDLE_BCNS:
5261 return QWLAN_HAL_CFG_TELE_BCN_MAX_LI_IDLE_BCNS;
5262#endif
5263 case WNI_CFG_ENABLE_CLOSE_LOOP:
5264 return QWLAN_HAL_CFG_ENABLE_CLOSE_LOOP;
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]5265 case WNI_CFG_ENABLE_LPWR_IMG_TRANSITION:
5266 return QWLAN_HAL_CFG_ENABLE_LPWR_IMG_TRANSITION;
jagadeeshaf2d0ce2015-03-31 11:45:30 +0530[diff] [blame]5267 case WNI_CFG_ENABLE_RTSCTS_HTVHT:
5268 return QWLAN_HAL_CFG_ENABLE_RTSCTS_HTVHT;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5269 default:
5270 {
5271 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5272 "There is no HAL CFG Id corresponding to WNI CFG Id: %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5273 wniCfgId);
5274 return VOS_STATUS_E_INVAL;
5275 }
5276 }
5277}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5278/*
5279 * FUNCTION: WDA_UpdateCfgCallback
5280 *
5281 */
5282void WDA_UpdateCfgCallback(WDI_Status wdiStatus, void* pUserData)
5283{
5284 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData ;
5285 WDI_UpdateCfgReqParamsType *wdiCfgParam =
5286 (WDI_UpdateCfgReqParamsType *)pWDA->wdaWdiCfgApiMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5287 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5288 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5289 /*
5290 * currently there is no response message is expected between PE and
5291 * WDA, Failure return from WDI is a ASSERT condition
5292 */
5293 if(WDI_STATUS_SUCCESS != wdiStatus)
5294 {
5295 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5296 "%s: CFG (%d) config failure", __func__,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5297 ((tHalCfg *)(wdiCfgParam->pConfigBuffer))->type);
5298 }
5299
5300 vos_mem_free(wdiCfgParam->pConfigBuffer) ;
5301 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
5302 pWDA->wdaWdiCfgApiMsgParam = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5303 return ;
5304}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5305/*
5306 * FUNCTION: WDA_UpdateCfg
5307 *
5308 */
5309VOS_STATUS WDA_UpdateCfg(tWDA_CbContext *pWDA, tSirMsgQ *cfgParam)
5310{
5311
5312 WDI_Status status = WDI_STATUS_SUCCESS ;
5313 tANI_U32 val =0;
5314 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
5315 tHalCfg *configData;
5316 WDI_UpdateCfgReqParamsType *wdiCfgReqParam = NULL ;
5317 tANI_U8 *configDataValue;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5319 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]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: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5324 return VOS_STATUS_E_FAILURE;
5325 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5326 if(WDA_START_STATE != pWDA->wdaState)
5327 {
5328 return VOS_STATUS_E_FAILURE;
5329 }
5330
5331 if(NULL != pWDA->wdaWdiCfgApiMsgParam)
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:wdaWdiCfgApiMsgParam is not NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5335 VOS_ASSERT(0);
5336 return VOS_STATUS_E_FAILURE;
5337 }
5338
5339 wdiCfgReqParam = (WDI_UpdateCfgReqParamsType *)vos_mem_malloc(
5340 sizeof(WDI_UpdateCfgReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5341 if(NULL == wdiCfgReqParam)
5342 {
5343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5344 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5345 VOS_ASSERT(0);
5346 return VOS_STATUS_E_NOMEM;
5347 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5348 wdiCfgReqParam->pConfigBuffer = vos_mem_malloc(sizeof(tHalCfg) +
5349 sizeof(tANI_U32)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5350 if(NULL == wdiCfgReqParam->pConfigBuffer)
5351 {
5352 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5353 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5354 vos_mem_free(wdiCfgReqParam);
5355 VOS_ASSERT(0);
5356 return VOS_STATUS_E_NOMEM;
5357 }
5358
5359 /*convert the WNI CFG Id to HAL CFG Id*/
5360 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->type =
5361 WDA_ConvertWniCfgIdToHALCfgId(cfgParam->bodyval);
5362
5363 /*TODO: revisit this for handling string parameters */
5364 if (wlan_cfgGetInt(pMac, (tANI_U16) cfgParam->bodyval,
5365 &val) != eSIR_SUCCESS)
5366 {
5367 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5368 "Failed to cfg get id %d", cfgParam->bodyval);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5369 vos_mem_free(wdiCfgReqParam->pConfigBuffer);
5370 vos_mem_free(wdiCfgReqParam);
5371 return eSIR_FAILURE;
5372 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5373 ((tHalCfg *)wdiCfgReqParam->pConfigBuffer)->length = sizeof(tANI_U32);
5374 configData =((tHalCfg *)wdiCfgReqParam->pConfigBuffer) ;
5375 configDataValue = ((tANI_U8 *)configData + sizeof(tHalCfg));
5376 vos_mem_copy( configDataValue, &val, sizeof(tANI_U32));
5377 wdiCfgReqParam->wdiReqStatusCB = NULL ;
5378
5379 /* store Params pass it to WDI */
5380 pWDA->wdaWdiCfgApiMsgParam = (void *)wdiCfgReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5381#ifdef FEATURE_HAL_SUPPORT_DYNAMIC_UPDATE_CFG
5382 status = WDI_UpdateCfgReq(wdiCfgReqParam,
5383 (WDI_UpdateCfgRspCb )WDA_UpdateCfgCallback, pWDA) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5384 if(IS_WDI_STATUS_FAILURE(status))
5385 {
5386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5387 "Failure in Update CFG WDI API, free all the memory " );
5388 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
5389 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
5390 pWDA->wdaWdiCfgApiMsgParam = NULL;
5391 /* Failure is not expected */
5392 VOS_ASSERT(0) ;
5393 }
5394#else
5395 vos_mem_free(wdiCfgReqParam->pConfigBuffer) ;
5396 vos_mem_free(pWDA->wdaWdiCfgApiMsgParam) ;
5397 pWDA->wdaWdiCfgApiMsgParam = NULL;
5398#endif
5399 return CONVERT_WDI2VOS_STATUS(status) ;
5400}
5401
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5402VOS_STATUS WDA_GetWepKeysFromCfg( tWDA_CbContext *pWDA,
5403 v_U8_t *pDefaultKeyId,
5404 v_U8_t *pNumKeys,
5405 WDI_KeysType *pWdiKeys )
5406{
5407 v_U32_t i, j, defKeyId = 0;
5408 v_U32_t val = SIR_MAC_KEY_LENGTH;
5409 VOS_STATUS status = WDI_STATUS_SUCCESS;
5410 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5411 if (NULL == pMac )
5412 {
5413 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5414 "%s: Invoked with invalid MAC context ", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5415 return VOS_STATUS_E_FAILURE;
5416 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5417 if( eSIR_SUCCESS != wlan_cfgGetInt( pMac, WNI_CFG_WEP_DEFAULT_KEYID,
5418 &defKeyId ))
5419 {
5420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5421 "Unable to retrieve defaultKeyId from CFG. Defaulting to 0...");
5422 }
5423
5424 *pDefaultKeyId = (v_U8_t)defKeyId;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5425 /* Need to extract ALL of the configured WEP Keys */
5426 for( i = 0, j = 0; i < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS; i++ )
5427 {
5428 val = SIR_MAC_KEY_LENGTH;
5429 if( eSIR_SUCCESS != wlan_cfgGetStr( pMac,
5430 (v_U16_t) (WNI_CFG_WEP_DEFAULT_KEY_1 + i),
5431 pWdiKeys[j].key,
5432 &val ))
5433 {
5434 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]5435 "WEP Key index [%d] may not configured in CFG",i);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5436 }
5437 else
5438 {
5439 pWdiKeys[j].keyId = (tANI_U8) i;
5440 /*
5441 * Actually, a DC (Don't Care) because
5442 * this is determined (and set) by PE/MLME
5443 */
5444 pWdiKeys[j].unicast = 0;
5445 /*
5446 * Another DC (Don't Care)
5447 */
5448 pWdiKeys[j].keyDirection = eSIR_TX_RX;
5449 /* Another DC (Don't Care). Unused for WEP */
5450 pWdiKeys[j].paeRole = 0;
5451 /* Determined from wlan_cfgGetStr() above.*/
5452 pWdiKeys[j].keyLength = (tANI_U16) val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5453 j++;
5454 *pNumKeys = (tANI_U8) j;
5455 }
5456 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5457 return status;
5458}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5459/*
5460 * FUNCTION: WDA_SetBssKeyReqCallback
5461 * send SET BSS key RSP back to PE
5462 */
5463void WDA_SetBssKeyReqCallback(WDI_Status status, void* pUserData)
5464{
5465 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5466 tWDA_CbContext *pWDA;
5467 tSetBssKeyParams *setBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5468 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5469 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5470 if(NULL == pWdaParams)
5471 {
5472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5473 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5474 VOS_ASSERT(0) ;
5475 return ;
5476 }
5477 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5478 setBssKeyParams = (tSetBssKeyParams *)pWdaParams->wdaMsgParam;
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]5479 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
5480 sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5481 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5482 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5483 setBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5484 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5485 return ;
5486}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5487/*
5488 * FUNCTION: WDA_ProcessSetBssKeyReq
5489 * Request to WDI for programming the BSS key( key for
5490 * broadcast/multicast frames Encryption)
5491 */
5492VOS_STATUS WDA_ProcessSetBssKeyReq(tWDA_CbContext *pWDA,
5493 tSetBssKeyParams *setBssKeyParams )
5494{
5495 WDI_Status status = WDI_STATUS_SUCCESS ;
5496 WDI_SetBSSKeyReqParamsType *wdiSetBssKeyParam =
5497 (WDI_SetBSSKeyReqParamsType *)vos_mem_malloc(
5498 sizeof(WDI_SetBSSKeyReqParamsType)) ;
5499 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5500 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5502 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5503 if(NULL == wdiSetBssKeyParam)
5504 {
5505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5506 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5507 VOS_ASSERT(0);
5508 return VOS_STATUS_E_NOMEM;
5509 }
5510 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5511 if(NULL == pWdaParams)
5512 {
5513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5514 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5515 VOS_ASSERT(0);
5516 vos_mem_free(wdiSetBssKeyParam);
5517 return VOS_STATUS_E_NOMEM;
5518 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5519 vos_mem_zero(wdiSetBssKeyParam, sizeof(WDI_SetBSSKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5520 /* copy set BSS params to WDI structure */
5521 wdiSetBssKeyParam->wdiBSSKeyInfo.ucBssIdx = setBssKeyParams->bssIdx;
5522 wdiSetBssKeyParam->wdiBSSKeyInfo.wdiEncType = setBssKeyParams->encType;
5523 wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys = setBssKeyParams->numKeys;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5524 if(setBssKeyParams->encType != eSIR_ED_NONE)
5525 {
5526 if( setBssKeyParams->numKeys == 0 &&
5527 (( setBssKeyParams->encType == eSIR_ED_WEP40)||
5528 setBssKeyParams->encType == eSIR_ED_WEP104))
5529 {
5530 tANI_U8 defaultKeyId = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5531 WDA_GetWepKeysFromCfg( pWDA, &defaultKeyId,
5532 &wdiSetBssKeyParam->wdiBSSKeyInfo.ucNumKeys,
5533 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys );
5534 }
5535 else
5536 {
5537 for( keyIndex=0; keyIndex < setBssKeyParams->numKeys; keyIndex++)
5538 {
5539 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyId =
5540 setBssKeyParams->key[keyIndex].keyId;
5541 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].unicast =
5542 setBssKeyParams->key[keyIndex].unicast;
5543 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyDirection =
5544 setBssKeyParams->key[keyIndex].keyDirection;
5545 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyRsc,
5546 setBssKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
5547 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].paeRole =
5548 setBssKeyParams->key[keyIndex].paeRole;
5549 wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].keyLength =
5550 setBssKeyParams->key[keyIndex].keyLength;
5551 vos_mem_copy(wdiSetBssKeyParam->wdiBSSKeyInfo.aKeys[keyIndex].key,
5552 setBssKeyParams->key[keyIndex].key,
5553 SIR_MAC_MAX_KEY_LENGTH);
5554 }
5555 }
5556 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5557 wdiSetBssKeyParam->wdiBSSKeyInfo.ucSingleTidRc =
5558 setBssKeyParams->singleTidRc;
5559 wdiSetBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5560 /* Store set key pointer, as this will be used for response */
5561 /* store Params pass it to WDI */
5562 pWdaParams->pWdaContext = pWDA;
5563 pWdaParams->wdaMsgParam = setBssKeyParams;
5564 pWdaParams->wdaWdiApiMsgParam = wdiSetBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5565 status = WDI_SetBSSKeyReq(wdiSetBssKeyParam,
5566 (WDI_SetBSSKeyRspCb)WDA_SetBssKeyReqCallback ,pWdaParams);
5567
5568 if(IS_WDI_STATUS_FAILURE(status))
5569 {
5570 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5571 "Failure in Set BSS Key Req WDI API, free all the memory " );
5572 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5573 vos_mem_free(pWdaParams) ;
5574 setBssKeyParams->status = eSIR_FAILURE ;
5575 WDA_SendMsg(pWDA, WDA_SET_BSSKEY_RSP, (void *)setBssKeyParams, 0) ;
5576 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5577 return CONVERT_WDI2VOS_STATUS(status) ;
5578}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5579/*
5580 * FUNCTION: WDA_RemoveBssKeyReqCallback
5581 * send SET BSS key RSP back to PE
5582 */
5583void WDA_RemoveBssKeyReqCallback(WDI_Status status, void* pUserData)
5584{
5585 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5586 tWDA_CbContext *pWDA;
5587 tRemoveBssKeyParams *removeBssKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5589 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5590 if(NULL == pWdaParams)
5591 {
5592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5593 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5594 VOS_ASSERT(0) ;
5595 return ;
5596 }
5597 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5598 removeBssKeyParams = (tRemoveBssKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5599 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5600 vos_mem_free(pWdaParams) ;
5601
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5602 removeBssKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5603 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5604 return ;
5605}
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5606
5607/*
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]5608 * FUNCTION: WDA_GetFrameLogRspCallback
5609 * recieves get frame log response from FW
5610 */
5611void WDA_GetFrameLogRspCallback(WDI_GetFrameLogRspParamType* wdiRsp,
5612 void* pUserData)
5613{
5614 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5615 tWDA_CbContext *pWDA = NULL;
5616 tAniGetFrameLogReq *pGetFrameLogReqParams = NULL;
5617
5618 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5619 "<------ Entering: %s " ,__func__);
5620 if(NULL == pWdaParams)
5621 {
5622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5623 "%s: pWdaParams received NULL", __func__);
5624 VOS_ASSERT(0) ;
5625 return ;
5626 }
5627
5628 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
5629 if (NULL == pWDA)
5630 {
5631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5632 "%s:pWDA is NULL", __func__);
5633 VOS_ASSERT(0);
5634 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5635 vos_mem_free(pWdaParams);
5636 return ;
5637 }
5638
5639 pGetFrameLogReqParams = (tAniGetFrameLogReq *)pWdaParams->wdaMsgParam;
5640 if(NULL == pGetFrameLogReqParams)
5641 {
5642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5643 "%s: pGetFrameLogReqParams received NULL", __func__);
5644 VOS_ASSERT(0);
5645 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5646 vos_mem_free(pWdaParams);
5647 return;
5648 }
5649
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]5650 if (wdiRsp->wdiStatus != WDI_STATUS_SUCCESS) {
5651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Abhishek Singh611295e2015-07-09 11:11:54 +0530[diff] [blame]5652 "%s:GetFrameLog with rsp status %d flag %d", __func__,
5653 wdiRsp->wdiStatus,pGetFrameLogReqParams->getFrameLogCmdFlag);
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]5654 }
5655
5656 /* free WDI command buffer only */
5657 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5658 vos_mem_free(pWdaParams->wdaMsgParam);
5659 vos_mem_free(pWdaParams);
5660
5661 return ;
5662
5663}
Gupta, Kapil7c34b322015-09-30 13:12:35 +0530[diff] [blame]5664
5665/*
5666 * FUNCTION: WDA_RssiMonitorStopRspCallback
5667 * recieves Rssi Monitor stop response from FW
5668 */
5669void WDA_RssiMonitorStopRspCallback(WDI_RssiMonitorStopRspParamType *wdiRsp,
5670 void* pUserData)
5671{
5672 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5673 tSirRssiMonitorReq *pRssiMonitorReqParams;
5674
5675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5676 "<------ %s " ,__func__);
5677
5678 if(NULL == pWdaParams)
5679 {
5680 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5681 "%s: pWdaParams received NULL", __func__);
5682 VOS_ASSERT(0);
5683 return ;
5684 }
5685
5686 if(NULL == pWdaParams->wdaMsgParam)
5687 {
5688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5689 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
5690 VOS_ASSERT(0);
5691 vos_mem_free(pWdaParams);
5692 return ;
5693 }
5694
5695 pRssiMonitorReqParams = (tSirRssiMonitorReq *)pWdaParams->wdaMsgParam;
5696
5697 if(pRssiMonitorReqParams->rssiMonitorCallback)
5698 {
5699 pRssiMonitorReqParams->rssiMonitorCallback(
5700 pRssiMonitorReqParams->rssiMonitorCbContext,
5701 CONVERT_WDI2VOS_STATUS(wdiRsp->status));
5702 }
5703 else
5704 {
5705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5706 "%s: pFWLoggingInitParams callback is NULL", __func__);
5707 }
5708
5709 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5710 vos_mem_free(pWdaParams->wdaMsgParam);
5711 vos_mem_free(pWdaParams);
5712
5713 return;
5714}
5715
5716/*
5717 * FUNCTION: WDA_RssiMonitorStartRspCallback
5718 * recieves Rssi Monitor start response from FW
5719 */
5720void WDA_RssiMonitorStartRspCallback(WDI_RssiMonitorStartRspParamType* wdiRsp,
5721 void* pUserData)
5722{
5723 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5724 tSirRssiMonitorReq *pRssiMonitorReqParams;
5725
5726 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5727 "<------ %s " ,__func__);
5728
5729 if(NULL == pWdaParams)
5730 {
5731 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5732 "%s: pWdaParams received NULL", __func__);
5733 VOS_ASSERT(0);
5734 return ;
5735 }
5736
5737 if(NULL == pWdaParams->wdaMsgParam)
5738 {
5739 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5740 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
5741 VOS_ASSERT(0);
5742 vos_mem_free(pWdaParams);
5743 return ;
5744 }
5745
5746 pRssiMonitorReqParams = (tSirRssiMonitorReq *)pWdaParams->wdaMsgParam;
5747
5748 if(pRssiMonitorReqParams->rssiMonitorCallback)
5749 {
5750 pRssiMonitorReqParams->rssiMonitorCallback(
5751 pRssiMonitorReqParams->rssiMonitorCbContext,
5752 CONVERT_WDI2VOS_STATUS(wdiRsp->status));
5753 }
5754 else
5755 {
5756 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5757 "%s: pFWLoggingInitParams callback is NULL", __func__);
5758 }
5759
5760 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5761 vos_mem_free(pWdaParams->wdaMsgParam);
5762 vos_mem_free(pWdaParams);
5763
5764 return;
5765}
5766
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]5767/*
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5768 * FUNCTION: WDA_FWLoggingInitRspCallback
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5769 * recieves Mgmt Logging init response from FW
5770 */
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5771void WDA_FWLoggingInitRspCallback(WDI_FWLoggingInitRspParamType* wdiRsp,
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5772 void* pUserData)
5773{
5774 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5775 tSirFWLoggingInitParam *pFWLoggingInitParams;
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5776 tAniLoggingInitRsp *pLoggingInitRsp;
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5777
5778 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5779 "<------ %s " ,__func__);
5780
5781 if(NULL == pWdaParams)
5782 {
5783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5784 "%s: pWdaParams received NULL", __func__);
5785 VOS_ASSERT(0);
5786 return ;
5787 }
5788
5789 if(NULL == pWdaParams->wdaMsgParam)
5790 {
5791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5792 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
5793 VOS_ASSERT(0);
5794 vos_mem_free(pWdaParams);
5795 return ;
5796 }
5797
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5798 pLoggingInitRsp = (tAniLoggingInitRsp *)vos_mem_malloc(sizeof(tAniLoggingInitRsp)) ;
5799 if(NULL == pWdaParams)
5800 {
5801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5802 "%s: VOS MEM Alloc Failure for pLoggingInitRsp", __func__);
5803 VOS_ASSERT(0);
5804 vos_mem_free(pWdaParams);
5805 return;
5806 }
5807
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5808 pFWLoggingInitParams = (tSirFWLoggingInitParam *)pWdaParams->wdaMsgParam;
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5809 vos_mem_copy(pLoggingInitRsp, wdiRsp, sizeof(tAniLoggingInitRsp));
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5810
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5811 if(pFWLoggingInitParams->fwlogInitCallback)
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5812 {
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5813 pFWLoggingInitParams->fwlogInitCallback(
5814 pFWLoggingInitParams->fwlogInitCbContext,
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5815 pLoggingInitRsp);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5816 }
5817 else
5818 {
5819 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]5820 "%s: pFWLoggingInitParams callback is NULL", __func__);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5821 }
5822
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]5823 vos_mem_free(pLoggingInitRsp);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]5824 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5825 vos_mem_free(pWdaParams->wdaMsgParam);
5826 vos_mem_free(pWdaParams);
5827
5828 return;
5829}
5830
5831/*
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5832 * FUNCTION: WDA_SpoofMacAddrRspCallback
5833 * recieves spoof mac addr response from FW
5834 */
5835void WDA_SpoofMacAddrRspCallback(WDI_SpoofMacAddrRspParamType* wdiRsp, void* pUserData)
5836{
5837 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5838 tWDA_CbContext *pWDA;
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5839
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
5841 "<------ %s " ,__func__);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5842
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5843 if(NULL == pWdaParams)
5844 {
5845 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5846 "%s: pWdaParams received NULL", __func__);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5847 VOS_ASSERT(0);
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5848 return ;
5849 }
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5850 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5851
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5852 if (wdiRsp->wdiStatus != WDI_STATUS_SUCCESS) {
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5853 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5854 "%s:Spoofing with rsp status %d", __func__, wdiRsp->wdiStatus);
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5855 }
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5856 WDA_SendMsg(pWDA, WDA_SPOOF_MAC_ADDR_RSP, NULL,
5857 CONVERT_WDI2SIR_STATUS(wdiRsp->wdiStatus));
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5858
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5859 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5860 vos_mem_free(pWdaParams->wdaMsgParam);
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5861 vos_mem_free(pWdaParams);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]5862
5863 return;
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]5864}
5865
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5866/*
5867 * FUNCTION: WDA_ProcessRemoveBssKeyReq
5868 * Request to WDI to remove the BSS key( key for broadcast/multicast
5869 * frames Encryption)
5870 */
5871VOS_STATUS WDA_ProcessRemoveBssKeyReq(tWDA_CbContext *pWDA,
5872 tRemoveBssKeyParams *removeBssKeyParams )
5873{
5874 WDI_Status status = WDI_STATUS_SUCCESS ;
5875 WDI_RemoveBSSKeyReqParamsType *wdiRemoveBssKeyParam =
5876 (WDI_RemoveBSSKeyReqParamsType *)vos_mem_malloc(
5877 sizeof(WDI_RemoveBSSKeyReqParamsType)) ;
5878 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5879 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5880 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5881 if(NULL == wdiRemoveBssKeyParam)
5882 {
5883 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5884 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5885 VOS_ASSERT(0);
5886 return VOS_STATUS_E_NOMEM;
5887 }
5888 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5889 if(NULL == pWdaParams)
5890 {
5891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5892 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5893 VOS_ASSERT(0);
5894 vos_mem_free(wdiRemoveBssKeyParam);
5895 return VOS_STATUS_E_NOMEM;
5896 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5897 /* copy Remove BSS key params to WDI structure*/
5898 wdiRemoveBssKeyParam->wdiKeyInfo.ucBssIdx = removeBssKeyParams->bssIdx;
5899 wdiRemoveBssKeyParam->wdiKeyInfo.wdiEncType = removeBssKeyParams->encType;
5900 wdiRemoveBssKeyParam->wdiKeyInfo.ucKeyId = removeBssKeyParams->keyId;
5901 wdiRemoveBssKeyParam->wdiKeyInfo.wdiWEPType = removeBssKeyParams->wepType;
5902 wdiRemoveBssKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5903 /* Store remove key pointer, as this will be used for response */
5904 /* store Params pass it to WDI */
5905 pWdaParams->pWdaContext = pWDA;
5906 pWdaParams->wdaMsgParam = removeBssKeyParams;
5907 pWdaParams->wdaWdiApiMsgParam = wdiRemoveBssKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5908 status = WDI_RemoveBSSKeyReq(wdiRemoveBssKeyParam,
5909 (WDI_RemoveBSSKeyRspCb)WDA_RemoveBssKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5910 if(IS_WDI_STATUS_FAILURE(status))
5911 {
5912 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
5913 "Failure in Remove BSS Key Req WDI API, free all the memory " );
5914 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5915 vos_mem_free(pWdaParams) ;
5916 removeBssKeyParams->status = eSIR_FAILURE ;
5917 WDA_SendMsg(pWDA, WDA_REMOVE_BSSKEY_RSP, (void *)removeBssKeyParams, 0) ;
5918 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5919 return CONVERT_WDI2VOS_STATUS(status) ;
5920}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5921/*
5922 * FUNCTION: WDA_SetBssKeyReqCallback
5923 * send SET BSS key RSP back to PE
5924 */
5925void WDA_SetStaKeyReqCallback(WDI_Status status, void* pUserData)
5926{
5927 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
5928 tWDA_CbContext *pWDA;
5929 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5930 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5931 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5932 if(NULL == pWdaParams)
5933 {
5934 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5935 ,"%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5936 VOS_ASSERT(0) ;
5937 return ;
5938 }
5939 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
5940 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]5941 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
5942 sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5943 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
5944 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]5945 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5946 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5947 return ;
5948}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5949/*
5950 * FUNCTION: WDA_ProcessSetStaKeyReq
5951 * Request to WDI for programming the STA key( key for Unicast frames
5952 * Encryption)
5953 */
5954VOS_STATUS WDA_ProcessSetStaKeyReq(tWDA_CbContext *pWDA,
5955 tSetStaKeyParams *setStaKeyParams )
5956{
5957 WDI_Status status = WDI_STATUS_SUCCESS ;
5958 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
5959 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
5960 sizeof(WDI_SetSTAKeyReqParamsType)) ;
5961 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5962 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5964 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5965 if(NULL == wdiSetStaKeyParam)
5966 {
5967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5968 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5969 VOS_ASSERT(0);
5970 return VOS_STATUS_E_NOMEM;
5971 }
5972 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
5973 if(NULL == pWdaParams)
5974 {
5975 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]5976 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5977 VOS_ASSERT(0);
5978 vos_mem_free(wdiSetStaKeyParam);
5979 return VOS_STATUS_E_NOMEM;
5980 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5981 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5982 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5983 /* copy set STA key params to WDI structure */
5984 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
5985 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
5986 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
5987 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5988 if(setStaKeyParams->encType != eSIR_ED_NONE)
5989 {
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]5990 if( (wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType == WDI_WEP_STATIC) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]5991 (WDA_INVALID_KEY_INDEX == setStaKeyParams->defWEPIdx) &&
5992 (eSYSTEM_AP_ROLE != pWDA->wdaGlobalSystemRole))
5993 {
5994 WDA_GetWepKeysFromCfg( pWDA,
5995 &wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx,
5996 &wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys,
5997 wdiSetStaKeyParam->wdiKeyInfo.wdiKey );
5998 }
5999 else
6000 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6001 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
6002 keyIndex++)
6003 {
6004 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
6005 setStaKeyParams->key[keyIndex].keyId;
6006 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
6007 setStaKeyParams->key[keyIndex].unicast;
6008 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
6009 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6010 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
6011 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
6012 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
6013 setStaKeyParams->key[keyIndex].paeRole;
6014 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
6015 setStaKeyParams->key[keyIndex].keyLength;
6016 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
6017 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
6018 /* set default index to index which have key direction as WDI_TX_DEFAULT */
6019 if (WDI_TX_DEFAULT == wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection)
6020 {
6021 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = keyIndex;
6022 }
6023 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6024 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
6025 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6026 }
6027 }
6028 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
6029 wdiSetStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6030 /* Store set key pointer, as this will be used for response */
6031 /* store Params pass it to WDI */
6032 pWdaParams->pWdaContext = pWDA;
6033 pWdaParams->wdaMsgParam = setStaKeyParams;
6034 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6035 status = WDI_SetSTAKeyReq(wdiSetStaKeyParam,
6036 (WDI_SetSTAKeyRspCb)WDA_SetStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6037 if(IS_WDI_STATUS_FAILURE(status))
6038 {
6039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6040 "Failure in set STA Key Req WDI API, free all the memory " );
6041 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6042 vos_mem_free(pWdaParams) ;
6043 setStaKeyParams->status = eSIR_FAILURE ;
6044 WDA_SendMsg(pWDA, WDA_SET_STAKEY_RSP, (void *)setStaKeyParams, 0) ;
6045 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6046 return CONVERT_WDI2VOS_STATUS(status) ;
6047}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6048/*
6049 * FUNCTION: WDA_SetBcastStaKeyReqCallback
6050 * send SET Bcast STA key RSP back to PE
6051 */
6052void WDA_SetBcastStaKeyReqCallback(WDI_Status status, void* pUserData)
6053{
6054 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6055 tWDA_CbContext *pWDA;
6056 tSetStaKeyParams *setStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6057 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6058 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6059 if(NULL == pWdaParams)
6060 {
6061 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6062 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6063 VOS_ASSERT(0) ;
6064 return ;
6065 }
6066 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6067 setStaKeyParams = (tSetStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6068 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6069 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6070 setStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6071 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6072 return ;
6073}
6074
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6075/*
6076 * FUNCTION: WDA_ProcessSetBcastStaKeyReq
6077 * Request to WDI for programming the Bcast STA key( key for Broadcast frames
6078 * Encryption)
6079 */
6080VOS_STATUS WDA_ProcessSetBcastStaKeyReq(tWDA_CbContext *pWDA,
6081 tSetStaKeyParams *setStaKeyParams )
6082{
6083 WDI_Status status = WDI_STATUS_SUCCESS ;
6084 WDI_SetSTAKeyReqParamsType *wdiSetStaKeyParam =
6085 (WDI_SetSTAKeyReqParamsType *)vos_mem_malloc(
6086 sizeof(WDI_SetSTAKeyReqParamsType)) ;
6087 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6088 v_U8_t keyIndex;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6090 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6091 if(NULL == wdiSetStaKeyParam)
6092 {
6093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6094 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6095 VOS_ASSERT(0);
6096 return VOS_STATUS_E_NOMEM;
6097 }
6098 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6099 if(NULL == pWdaParams)
6100 {
6101 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6102 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6103 VOS_ASSERT(0);
6104 vos_mem_free(wdiSetStaKeyParam);
6105 return VOS_STATUS_E_NOMEM;
6106 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6107 vos_mem_set(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType), 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6108 vos_mem_zero(wdiSetStaKeyParam, sizeof(WDI_SetSTAKeyReqParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6109 /* copy set STA key params to WDI structure */
6110 wdiSetStaKeyParam->wdiKeyInfo.ucSTAIdx = setStaKeyParams->staIdx;
6111 wdiSetStaKeyParam->wdiKeyInfo.wdiEncType = setStaKeyParams->encType;
6112 wdiSetStaKeyParam->wdiKeyInfo.wdiWEPType = setStaKeyParams->wepType;
6113 wdiSetStaKeyParam->wdiKeyInfo.ucDefWEPIdx = setStaKeyParams->defWEPIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6114 if(setStaKeyParams->encType != eSIR_ED_NONE)
6115 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6116 for( keyIndex=0; keyIndex < SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
6117 keyIndex++)
6118 {
6119 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyId =
6120 setStaKeyParams->key[keyIndex].keyId;
6121 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].unicast =
6122 setStaKeyParams->key[keyIndex].unicast;
6123 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyDirection =
6124 setStaKeyParams->key[keyIndex].keyDirection;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6125 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyRsc,
6126 setStaKeyParams->key[keyIndex].keyRsc, WLAN_MAX_KEY_RSC_LEN);
6127 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].paeRole =
6128 setStaKeyParams->key[keyIndex].paeRole;
6129 wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].keyLength =
6130 setStaKeyParams->key[keyIndex].keyLength;
6131 vos_mem_copy(wdiSetStaKeyParam->wdiKeyInfo.wdiKey[keyIndex].key,
6132 setStaKeyParams->key[keyIndex].key, SIR_MAC_MAX_KEY_LENGTH);
6133 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6134 wdiSetStaKeyParam->wdiKeyInfo.ucNumKeys =
6135 SIR_MAC_MAX_NUM_OF_DEFAULT_KEYS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6136 }
6137 wdiSetStaKeyParam->wdiKeyInfo.ucSingleTidRc = setStaKeyParams->singleTidRc;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6138 /* Store set key pointer, as this will be used for response */
6139 /* store Params pass it to WDI */
6140 pWdaParams->pWdaContext = pWDA;
6141 pWdaParams->wdaMsgParam = setStaKeyParams;
6142 pWdaParams->wdaWdiApiMsgParam = wdiSetStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6143 status = WDI_SetSTABcastKeyReq(wdiSetStaKeyParam,
6144 (WDI_SetSTAKeyRspCb)WDA_SetBcastStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6145 if(IS_WDI_STATUS_FAILURE(status))
6146 {
6147 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6148 "Failure in set BCAST STA Key Req WDI API, free all the memory " );
6149 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6150 vos_mem_free(pWdaParams) ;
6151 setStaKeyParams->status = eSIR_FAILURE ;
6152 WDA_SendMsg(pWDA, WDA_SET_STA_BCASTKEY_RSP, (void *)setStaKeyParams, 0) ;
6153 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6154 return CONVERT_WDI2VOS_STATUS(status) ;
6155}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6156/*
6157 * FUNCTION: WDA_RemoveStaKeyReqCallback
6158 * send SET BSS key RSP back to PE
6159 */
6160void WDA_RemoveStaKeyReqCallback(WDI_Status status, void* pUserData)
6161{
6162 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6163 tWDA_CbContext *pWDA;
6164 tRemoveStaKeyParams *removeStaKeyParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6166 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6167 if(NULL == pWdaParams)
6168 {
6169 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6170 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6171 VOS_ASSERT(0) ;
6172 return ;
6173 }
6174 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6175 removeStaKeyParams = (tRemoveStaKeyParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6176 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6177 vos_mem_free(pWdaParams) ;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6178 removeStaKeyParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6179 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6180 return ;
6181}
6182
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6183/*
6184 * FUNCTION: WDA_ProcessRemoveStaKeyReq
6185 * Request to WDI to remove the STA key( key for Unicast frames Encryption)
6186 */
6187VOS_STATUS WDA_ProcessRemoveStaKeyReq(tWDA_CbContext *pWDA,
6188 tRemoveStaKeyParams *removeStaKeyParams )
6189{
6190 WDI_Status status = WDI_STATUS_SUCCESS ;
6191 WDI_RemoveSTAKeyReqParamsType *wdiRemoveStaKeyParam =
6192 (WDI_RemoveSTAKeyReqParamsType *)vos_mem_malloc(
6193 sizeof(WDI_RemoveSTAKeyReqParamsType)) ;
6194 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6195 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6196 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6197 if(NULL == wdiRemoveStaKeyParam)
6198 {
6199 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6200 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6201 VOS_ASSERT(0);
6202 return VOS_STATUS_E_NOMEM;
6203 }
6204 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6205 if(NULL == pWdaParams)
6206 {
6207 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6208 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6209 VOS_ASSERT(0);
6210 vos_mem_free(wdiRemoveStaKeyParam);
6211 return VOS_STATUS_E_NOMEM;
6212 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6213 /* copy remove STA key params to WDI structure*/
6214 wdiRemoveStaKeyParam->wdiKeyInfo.ucSTAIdx = removeStaKeyParams->staIdx;
6215 wdiRemoveStaKeyParam->wdiKeyInfo.wdiEncType = removeStaKeyParams->encType;
6216 wdiRemoveStaKeyParam->wdiKeyInfo.ucKeyId = removeStaKeyParams->keyId;
6217 wdiRemoveStaKeyParam->wdiKeyInfo.ucUnicast = removeStaKeyParams->unicast;
6218 wdiRemoveStaKeyParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6219 /* Store remove key pointer, as this will be used for response */
6220 /* store Params pass it to WDI */
6221 pWdaParams->pWdaContext = pWDA;
6222 pWdaParams->wdaMsgParam = removeStaKeyParams;
6223 pWdaParams->wdaWdiApiMsgParam = wdiRemoveStaKeyParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6224 status = WDI_RemoveSTAKeyReq(wdiRemoveStaKeyParam,
6225 (WDI_RemoveSTAKeyRspCb)WDA_RemoveStaKeyReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6226 if(IS_WDI_STATUS_FAILURE(status))
6227 {
6228 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6229 "Failure in remove STA Key Req WDI API, free all the memory " );
6230 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6231 vos_mem_free(pWdaParams) ;
6232 removeStaKeyParams->status = eSIR_FAILURE ;
6233 WDA_SendMsg(pWDA, WDA_REMOVE_STAKEY_RSP, (void *)removeStaKeyParams, 0) ;
6234 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6235 return CONVERT_WDI2VOS_STATUS(status) ;
6236}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6237/*
6238 * FUNCTION: WDA_IsHandleSetLinkStateReq
6239 * Update the WDA state and return the status to handle this message or not
6240 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6241WDA_processSetLinkStateStatus WDA_IsHandleSetLinkStateReq(
6242 tWDA_CbContext *pWDA,
6243 tLinkStateParams *linkStateParams)
6244{
6245 WDA_processSetLinkStateStatus status = WDA_PROCESS_SET_LINK_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6246 switch(linkStateParams->state)
6247 {
6248 case eSIR_LINK_PREASSOC_STATE:
6249 case eSIR_LINK_BTAMP_PREASSOC_STATE:
6250 /*
6251 * set the WDA state to PRE ASSOC
6252 * copy the BSSID into pWDA to use it in join request and return,
6253 * No need to handle these messages.
6254 */
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6255 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->bssid) )
6256 {
6257 vos_mem_copy(pWDA->macBSSID,linkStateParams->bssid,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6258 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6259 }
6260 else
6261 {
6262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6263 "%s: BSSID in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6264 VOS_ASSERT(0);
6265 }
6266
6267 if( !WDA_IS_NULL_MAC_ADDRESS(linkStateParams->selfMacAddr) )
6268 {
6269 vos_mem_copy(pWDA->macSTASelf,linkStateParams->selfMacAddr,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6270 sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6271 }
6272 else
6273 {
6274 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6275 "%s: self mac address in set link state is NULL ", __func__);
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6276 VOS_ASSERT(0);
6277 }
6278
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6279 /* UMAC is issuing the setlink state with PREASSOC twice (before set
6280 *channel and after ) so reset the WDA state to ready when the second
6281 * time UMAC issue the link state with PREASSOC
6282 */
6283 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
6284 {
6285 /* RESET WDA state back to WDA_READY_STATE */
6286 pWDA->wdaState = WDA_READY_STATE;
6287 }
6288 else
6289 {
6290 pWDA->wdaState = WDA_PRE_ASSOC_STATE;
6291 }
6292 //populate linkState info in WDACbCtxt
6293 pWDA->linkState = linkStateParams->state;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6294 break;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6295 default:
6296 if(pWDA->wdaState != WDA_READY_STATE)
6297 {
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]6298 /*If WDA_SET_LINK_STATE is recieved with any other link state apart
6299 *from eSIR_LINK_PREASSOC_STATE and eSIR_LINK_BTAMP_PREASSOC_STATE when
6300 *pWDA->wdaState is in WDA_PRE_ASSOC_STATE(This can happen only in
6301 *error cases) so reset the WDA state to WDA_READY_STATE to avoid
6302 *the ASSERT in WDA_Stop during module unload.*/
6303 if (pWDA->wdaState == WDA_PRE_ASSOC_STATE)
6304 {
6305 pWDA->wdaState = WDA_READY_STATE;
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6306 /* Don't ignore the set link in this case*/
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]6307 }
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6308 else
6309 {
6310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]6311 "Set link state called when WDA is not in READY STATE " );
Madan Mohan Koyyalamudi35287862012-10-22 14:52:46 -0700[diff] [blame]6312 status = WDA_IGNORE_SET_LINK_STATE;
6313 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6314 }
6315 break;
6316 }
6317
6318 return status;
6319}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6320/*
6321 * FUNCTION: WDA_SetLinkStateCallback
6322 * call back function for set link state from WDI
6323 */
6324void WDA_SetLinkStateCallback(WDI_Status status, void* pUserData)
6325{
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6326 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6327 tLinkStateParams *linkStateParams;
6328 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6329 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6330 "<------ %s " ,__func__);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6331 if (NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6332 {
6333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6334 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6335 VOS_ASSERT(0) ;
6336 return ;
6337 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6338 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6339 if (NULL == pWDA)
6340 {
6341 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6342 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]6343 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6344 vos_mem_free(pWdaParams->wdaMsgParam);
6345 vos_mem_free(pWdaParams);
6346
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6347 VOS_ASSERT(0);
6348 return ;
6349 }
6350
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6351 linkStateParams = (tLinkStateParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6352 /*
6353 * In STA mode start the BA activity check timer after association
6354 * and in AP mode start BA activity check timer after BSS start */
6355 if( ((linkStateParams->state == eSIR_LINK_POSTASSOC_STATE) &&
6356 status == WDI_STATUS_SUCCESS) || ((status == WDI_STATUS_SUCCESS) &&
Shailender Karmuchia734f332013-04-19 14:02:48 -0700[diff] [blame]6357 (linkStateParams->state == eSIR_LINK_AP_STATE)) ||
6358 ((status == WDI_STATUS_SUCCESS) &&
6359 (linkStateParams->state == eSIR_LINK_IBSS_STATE)))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6360 {
6361 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
6362 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6363 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6364 /*
6365 * No respone required for WDA_SET_LINK_STATE so free the request
6366 * param here
6367 */
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]6368 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6369 vos_mem_free(pWdaParams);
6370
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6371 return ;
6372}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6373/*
6374 * FUNCTION: WDA_ProcessSetLinkState
6375 * Request to WDI to set the link status.
6376 */
6377VOS_STATUS WDA_ProcessSetLinkState(tWDA_CbContext *pWDA,
6378 tLinkStateParams *linkStateParams)
6379{
6380 WDI_Status status = WDI_STATUS_SUCCESS ;
6381 WDI_SetLinkReqParamsType *wdiSetLinkStateParam =
6382 (WDI_SetLinkReqParamsType *)vos_mem_malloc(
6383 sizeof(WDI_SetLinkReqParamsType)) ;
6384 tWDA_ReqParams *pWdaParams ;
6385 tpAniSirGlobal pMac;
6386 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
6387
6388 if(NULL == pMac)
6389 {
6390 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6391 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6392 VOS_ASSERT(0);
Madan Mohan Koyyalamudi68f53542012-09-24 14:19:32 -0700[diff] [blame]6393 vos_mem_free(wdiSetLinkStateParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6394 return VOS_STATUS_E_FAILURE;
6395 }
6396
6397 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6398 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6399 if(NULL == wdiSetLinkStateParam)
6400 {
6401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6402 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6403 VOS_ASSERT(0);
6404 return VOS_STATUS_E_NOMEM;
6405 }
6406 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6407 if(NULL == pWdaParams)
6408 {
6409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6410 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6411 VOS_ASSERT(0);
6412 vos_mem_free(wdiSetLinkStateParam);
6413 return VOS_STATUS_E_NOMEM;
6414 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6415 if(WDA_IGNORE_SET_LINK_STATE ==
6416 WDA_IsHandleSetLinkStateReq(pWDA,linkStateParams))
6417 {
6418 status = WDI_STATUS_E_FAILURE;
6419 }
6420 else
6421 {
6422 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macBSSID,
6423 linkStateParams->bssid, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6424 vos_mem_copy(wdiSetLinkStateParam->wdiLinkInfo.macSelfStaMacAddr,
6425 linkStateParams->selfMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6426 wdiSetLinkStateParam->wdiLinkInfo.wdiLinkState = linkStateParams->state;
6427 wdiSetLinkStateParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6428 pWdaParams->pWdaContext = pWDA;
6429 /* Store remove key pointer, as this will be used for response */
6430 pWdaParams->wdaMsgParam = (void *)linkStateParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6431 /* store Params pass it to WDI */
6432 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetLinkStateParam ;
6433 /* Stop Timer only other than GO role and concurrent session */
6434 if( (linkStateParams->state == eSIR_LINK_IDLE_STATE)
Hoonki Lee9af07cf2013-04-24 01:21:58 -0700[diff] [blame]6435 && (0 == WDI_GetActiveSessionsCount(pWDA->pWdiContext, linkStateParams->bssid, TRUE)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6436 (wdaGetGlobalSystemRole(pMac) != eSYSTEM_AP_ROLE) )
6437 {
6438 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
6439 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6440 status = WDI_SetLinkStateReq(wdiSetLinkStateParam,
6441 (WDI_SetLinkStateRspCb)WDA_SetLinkStateCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6442 if(IS_WDI_STATUS_FAILURE(status))
6443 {
6444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6445 "Failure in set link state Req WDI API, free all the memory " );
6446 }
6447 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6448 if(IS_WDI_STATUS_FAILURE(status))
6449 {
6450 vos_mem_free(wdiSetLinkStateParam) ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]6451 WDA_SendMsg(pWDA, WDA_SET_LINK_STATE_RSP, (void *)linkStateParams, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6452 vos_mem_free(pWdaParams);
6453 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6454 return CONVERT_WDI2VOS_STATUS(status) ;
6455}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6456/*
6457 * FUNCTION: WDA_GetStatsReqParamsCallback
6458 * send the response to PE with Stats received from WDI
6459 */
6460void WDA_GetStatsReqParamsCallback(
6461 WDI_GetStatsRspParamsType *wdiGetStatsRsp,
6462 void* pUserData)
6463{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6464 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Hanumantha Reddy Pothulab2a0c832015-11-06 19:44:55 +0530[diff] [blame]6465 vos_msg_t vosMsg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6466
6467 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6468 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6469 pGetPEStatsRspParams =
6470 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp) +
6471 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType)));
6472
6473 if(NULL == pGetPEStatsRspParams)
6474 {
6475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6476 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6477 VOS_ASSERT(0);
6478 return;
6479 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6480 vos_mem_set(pGetPEStatsRspParams, wdiGetStatsRsp->usMsgLen, 0);
Hanumantha Reddy Pothulab2a0c832015-11-06 19:44:55 +0530[diff] [blame]6481 pGetPEStatsRspParams->msgType = eWNI_SME_GET_STATISTICS_RSP;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6482 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp) +
6483 (wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6484
6485 //Fill the Session Id Properly in PE
6486 pGetPEStatsRspParams->sessionId = 0;
6487 pGetPEStatsRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6488 wdiGetStatsRsp->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6489 pGetPEStatsRspParams->staId = wdiGetStatsRsp->ucSTAIdx;
6490 pGetPEStatsRspParams->statsMask = wdiGetStatsRsp->uStatsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6491 vos_mem_copy( pGetPEStatsRspParams + 1,
6492 wdiGetStatsRsp + 1,
6493 wdiGetStatsRsp->usMsgLen - sizeof(WDI_GetStatsRspParamsType));
Hanumantha Reddy Pothulab2a0c832015-11-06 19:44:55 +0530[diff] [blame]6494
6495 vosMsg.type = eWNI_SME_GET_STATISTICS_RSP;
6496 vosMsg.bodyptr = (void *)pGetPEStatsRspParams;
6497 vosMsg.bodyval = 0;
6498 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME,
6499 (vos_msg_t*)&vosMsg))
6500 {
6501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6502 "%s: fail to post eWNI_SME_GET_STATISTICS_RSP", __func__);
6503 vos_mem_free(pGetPEStatsRspParams);
6504 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6505
6506 return;
6507}
6508
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6509/*
6510 * FUNCTION: WDA_ProcessGetStatsReq
6511 * Request to WDI to get the statistics
6512 */
6513VOS_STATUS WDA_ProcessGetStatsReq(tWDA_CbContext *pWDA,
6514 tAniGetPEStatsReq *pGetStatsParams)
6515{
6516 WDI_Status status = WDI_STATUS_SUCCESS ;
6517 WDI_GetStatsReqParamsType wdiGetStatsParam;
6518 tAniGetPEStatsRsp *pGetPEStatsRspParams;
Hanumantha Reddy Pothulab2a0c832015-11-06 19:44:55 +0530[diff] [blame]6519 vos_msg_t vosMsg;
6520
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6522 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6523 wdiGetStatsParam.wdiGetStatsParamsInfo.ucSTAIdx =
6524 pGetStatsParams->staId;
6525 wdiGetStatsParam.wdiGetStatsParamsInfo.uStatsMask =
6526 pGetStatsParams->statsMask;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6527 wdiGetStatsParam.wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6528 status = WDI_GetStatsReq(&wdiGetStatsParam,
6529 (WDI_GetStatsRspCb)WDA_GetStatsReqParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6530 if(IS_WDI_STATUS_FAILURE(status))
6531 {
6532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6533 "Failure in Get Stats Req WDI API, free all the memory " );
6534 pGetPEStatsRspParams =
6535 (tAniGetPEStatsRsp *)vos_mem_malloc(sizeof(tAniGetPEStatsRsp));
6536 if(NULL == pGetPEStatsRspParams)
6537 {
6538 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6539 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6540 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6541 vos_mem_free(pGetStatsParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6542 return VOS_STATUS_E_NOMEM;
6543 }
Hanumantha Reddy Pothulab2a0c832015-11-06 19:44:55 +0530[diff] [blame]6544 pGetPEStatsRspParams->msgType = eWNI_SME_GET_STATISTICS_RSP;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6545 pGetPEStatsRspParams->msgLen = sizeof(tAniGetPEStatsRsp);
6546 pGetPEStatsRspParams->staId = pGetStatsParams->staId;
6547 pGetPEStatsRspParams->rc = eSIR_FAILURE;
Hanumantha Reddy Pothulab2a0c832015-11-06 19:44:55 +0530[diff] [blame]6548
6549 vosMsg.type = eWNI_SME_GET_STATISTICS_RSP;
6550 vosMsg.bodyptr = (void *)pGetPEStatsRspParams;
6551 vosMsg.bodyval = 0;
6552 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME,
6553 (vos_msg_t*)&vosMsg))
6554 {
6555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6556 "%s: fail to post eWNI_SME_GET_STATISTICS_RSP", __func__);
6557 vos_mem_free(pGetPEStatsRspParams);
6558 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6559 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6560 /* Free the request message */
6561 vos_mem_free(pGetStatsParams);
6562 return CONVERT_WDI2VOS_STATUS(status);
6563}
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6564
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]6565#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6566/*
6567 * FUNCTION: WDA_GetGetRssiReqRoamRssiReqParamsCallback
6568 * send the response to PE with roam Rssi received from WDI
6569 */
6570void WDA_GetRoamRssiReqParamsCallback(
6571 WDI_GetRoamRssiRspParamsType *wdiGetRoamRssiRsp,
6572 void* pUserData)
6573{
6574 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6575 tWDA_CbContext *pWDA = NULL;
6576 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
6577 tpAniGetRssiReq pGetRoamRssiReqParams = NULL;
6578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6579 "<------ %s " ,__func__);
6580 if(NULL == pWdaParams)
6581 {
6582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6583 "%s: pWdaParams received NULL", __func__);
6584 VOS_ASSERT(0) ;
6585 return ;
6586 }
6587 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
6588 pGetRoamRssiReqParams = (tAniGetRssiReq *)pWdaParams->wdaMsgParam;
6589
6590 if(NULL == pGetRoamRssiReqParams)
6591 {
6592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6593 "%s: pGetRoamRssiReqParams received NULL", __func__);
6594 VOS_ASSERT(0);
6595 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6596 vos_mem_free(pWdaParams);
6597 return ;
6598 }
6599 pGetRoamRssiRspParams =
6600 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
6601
6602 if(NULL == pGetRoamRssiRspParams)
6603 {
6604 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6605 "%s: VOS MEM Alloc Failure", __func__);
6606 VOS_ASSERT(0);
6607 return;
6608 }
6609 vos_mem_set(pGetRoamRssiRspParams, sizeof(tAniGetRoamRssiRsp), 0);
6610 pGetRoamRssiRspParams->rc =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6611 wdiGetRoamRssiRsp->wdiStatus;
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6612 pGetRoamRssiRspParams->staId = wdiGetRoamRssiRsp->ucSTAIdx;
6613 pGetRoamRssiRspParams->rssi = wdiGetRoamRssiRsp->rssi;
6614
6615 /* Assign get roam rssi req (backup) in to the response */
6616 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiReqParams;
6617
6618 /* free WDI command buffer */
6619 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
6620 vos_mem_free(pWdaParams) ;
6621
6622 /* send response to UMAC*/
6623 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP, pGetRoamRssiRspParams , 0) ;
6624
6625 return;
6626}
6627
6628
6629
6630/*
6631 * FUNCTION: WDA_ProcessGetRoamRssiReq
6632 * Request to WDI to get the statistics
6633 */
6634VOS_STATUS WDA_ProcessGetRoamRssiReq(tWDA_CbContext *pWDA,
6635 tAniGetRssiReq *pGetRoamRssiParams)
6636{
6637 WDI_Status status = WDI_STATUS_SUCCESS ;
6638 WDI_GetRoamRssiReqParamsType wdiGetRoamRssiParam;
6639 tAniGetRoamRssiRsp *pGetRoamRssiRspParams = NULL;
6640 tWDA_ReqParams *pWdaParams = NULL;
6641
6642 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
6643 "------> %s " ,__func__);
6644 wdiGetRoamRssiParam.wdiGetRoamRssiParamsInfo.ucSTAIdx =
6645 pGetRoamRssiParams->staId;
6646 wdiGetRoamRssiParam.wdiReqStatusCB = NULL ;
6647
6648 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6649 if(NULL == pWdaParams)
6650 {
6651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6652 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]6653 vos_mem_free(pGetRoamRssiParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6654 VOS_ASSERT(0);
6655 return VOS_STATUS_E_NOMEM;
6656 }
6657
6658 /* Store Init Req pointer, as this will be used for response */
6659 pWdaParams->pWdaContext = pWDA;
6660
6661 /* Take Get roam Rssi req backup as it stores the callback to be called after
6662 receiving the response */
6663 pWdaParams->wdaMsgParam = pGetRoamRssiParams;
6664 pWdaParams->wdaWdiApiMsgParam = NULL;
6665
6666 status = WDI_GetRoamRssiReq(&wdiGetRoamRssiParam,
6667 (WDI_GetRoamRssiRspCb)WDA_GetRoamRssiReqParamsCallback, pWdaParams);
6668 if(IS_WDI_STATUS_FAILURE(status))
6669 {
6670 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6671 "Failure in Get RoamRssi Req WDI API, free all the memory status=%d", status );
6672 pGetRoamRssiRspParams =
6673 (tAniGetRoamRssiRsp *)vos_mem_malloc(sizeof(tAniGetRoamRssiRsp));
6674 if(NULL == pGetRoamRssiRspParams)
6675 {
6676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6677 "%s: VOS MEM Alloc Failure", __func__);
6678 VOS_ASSERT(0);
Abhishek Singh1e2bfa32014-01-02 15:44:15 +0530[diff] [blame]6679 vos_mem_free(pGetRoamRssiParams);
6680 vos_mem_free(pWdaParams);
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]6681 return VOS_STATUS_E_NOMEM;
6682 }
6683 pGetRoamRssiRspParams->staId = pGetRoamRssiParams->staId;
6684 pGetRoamRssiRspParams->rc = eSIR_FAILURE;
6685 pGetRoamRssiRspParams->rssi = 0;
6686 pGetRoamRssiRspParams->rssiReq = pGetRoamRssiParams;
6687 WDA_SendMsg(pWDA, WDA_GET_ROAM_RSSI_RSP,
6688 (void *)pGetRoamRssiRspParams, 0) ;
6689 }
6690 return CONVERT_WDI2VOS_STATUS(status);
6691}
6692#endif
6693
6694
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6695/*
6696 * FUNCTION: WDA_UpdateEDCAParamCallback
6697 * call back function for Update EDCA params from WDI
6698 */
6699void WDA_UpdateEDCAParamCallback(WDI_Status status, void* pUserData)
6700{
6701 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6702 tEdcaParams *pEdcaParams;
6703
6704 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6705 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6706 if(NULL == pWdaParams)
6707 {
6708 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6709 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6710 VOS_ASSERT(0) ;
6711 return ;
6712 }
6713 pEdcaParams = (tEdcaParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6714 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6715 vos_mem_free(pWdaParams);
6716 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6717 return ;
6718}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6719/*
6720 * FUNCTION: WDA_ProcessUpdateEDCAParamReq
6721 * Request to WDI to Update the EDCA params.
6722 */
6723VOS_STATUS WDA_ProcessUpdateEDCAParamReq(tWDA_CbContext *pWDA,
6724 tEdcaParams *pEdcaParams)
6725{
6726 WDI_Status status = WDI_STATUS_SUCCESS ;
6727 WDI_UpdateEDCAParamsType *wdiEdcaParam =
6728 (WDI_UpdateEDCAParamsType *)vos_mem_malloc(
6729 sizeof(WDI_UpdateEDCAParamsType)) ;
6730 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6731 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6732 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6733 if(NULL == wdiEdcaParam)
6734 {
6735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6736 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6737 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6738 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6739 return VOS_STATUS_E_NOMEM;
6740 }
6741 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6742 if(NULL == pWdaParams)
6743 {
6744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6745 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6746 VOS_ASSERT(0);
6747 vos_mem_free(wdiEdcaParam);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6748 vos_mem_free(pEdcaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6749 return VOS_STATUS_E_NOMEM;
6750 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6751 wdiEdcaParam->wdiEDCAInfo.ucBssIdx = pEdcaParams->bssIdx;
Bansidhar Gopalachari5dcf9e02013-07-29 19:53:58 -0700[diff] [blame]6752 /*
6753 Since firmware is not using highperformance flag, we have removed
6754 this flag from wdiEDCAInfo structure to match sizeof the structure
6755 between host and firmware.In future if we are planning to use
6756 highperformance flag then Please define this flag in wdiEDCAInfo
6757 structure, update it here and send it to firmware. i.e.
6758 Following is the original line which we removed as part of the fix
6759 wdiEdcaParam->wdiEDCAInfo.ucEDCAParamsValid =
6760 pEdcaParams->highPerformance;
6761 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6762 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBEInfo,
6763 &pEdcaParams->acbe);
6764 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaBKInfo,
6765 &pEdcaParams->acbk);
6766 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVIInfo,
6767 &pEdcaParams->acvi);
6768 WDA_UpdateEdcaParamsForAC(pWDA, &wdiEdcaParam->wdiEDCAInfo.wdiEdcaVOInfo,
6769 &pEdcaParams->acvo);
6770 wdiEdcaParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6771 pWdaParams->pWdaContext = pWDA;
6772 /* Store remove key pointer, as this will be used for response */
6773 pWdaParams->wdaMsgParam = (void *)pEdcaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6774 /* store Params pass it to WDI */
6775 pWdaParams->wdaWdiApiMsgParam = (void *)wdiEdcaParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6776 status = WDI_UpdateEDCAParams(wdiEdcaParam,
6777 (WDI_UpdateEDCAParamsRspCb)WDA_UpdateEDCAParamCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6778 if(IS_WDI_STATUS_FAILURE(status))
6779 {
6780 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6781 "Failure in Update EDCA Params WDI API, free all the memory " );
6782 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6783 vos_mem_free(pWdaParams);
6784 vos_mem_free(pEdcaParams);
6785 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6786 return CONVERT_WDI2VOS_STATUS(status) ;
6787}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6788/*
6789 * FUNCTION: WDA_AddBAReqCallback
6790 * send ADD BA RSP back to PE
6791 */
6792void WDA_AddBAReqCallback(WDI_AddBARspinfoType *pAddBARspParams,
6793 void* pUserData)
6794{
6795 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
6796 tWDA_CbContext *pWDA;
6797 tAddBAParams *pAddBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6799 "<------ %s " ,__func__);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6800 if (NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6801 {
6802 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6803 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6804 VOS_ASSERT(0) ;
6805 return ;
6806 }
6807 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6808 if (NULL == pWDA)
6809 {
6810 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6811 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]6812 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6813 vos_mem_free(pWdaParams->wdaMsgParam);
6814 vos_mem_free(pWdaParams);
6815
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6816 VOS_ASSERT(0);
6817 return ;
6818 }
6819
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6820 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6821 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6822 vos_mem_free(pWdaParams);
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]6823 pAddBAReqParams->status = pAddBARspParams->wdiStatus ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6824 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6825 return ;
6826}
6827
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6828/*
6829 * FUNCTION: WDA_ProcessAddBAReq
6830 * Request to WDI to Update the ADDBA REQ params.
6831 */
6832VOS_STATUS WDA_ProcessAddBAReq(tWDA_CbContext *pWDA, VOS_STATUS status,
Abhishek Singh01c73d12015-03-12 15:13:44 +0530[diff] [blame]6833 tANI_U16 baSessionID, tANI_U8 staIdx, tANI_U8 ucWinSize, tAddBAParams *pAddBAReqParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6834{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6835 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6836 WDI_AddBAReqParamsType *wdiAddBAReqParam =
6837 (WDI_AddBAReqParamsType *)vos_mem_malloc(
6838 sizeof(WDI_AddBAReqParamsType)) ;
6839 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6841 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6842 if(NULL == wdiAddBAReqParam)
6843 {
6844 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6845 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6846 VOS_ASSERT(0);
6847 return VOS_STATUS_E_NOMEM;
6848 }
6849 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6850 if(NULL == pWdaParams)
6851 {
6852 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6853 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6854 VOS_ASSERT(0);
6855 vos_mem_free(wdiAddBAReqParam);
6856 return VOS_STATUS_E_NOMEM;
6857 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6858 do
6859 {
6860 WDI_AddBAReqinfoType *wdiAddBaInfo = &wdiAddBAReqParam->wdiBAInfoType ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6861 wdiAddBaInfo->ucSTAIdx = staIdx ;
6862 wdiAddBaInfo->ucBaSessionID = baSessionID ;
Abhishek Singh01c73d12015-03-12 15:13:44 +0530[diff] [blame]6863 wdiAddBaInfo->ucWinSize = ucWinSize ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6864 } while(0) ;
6865 wdiAddBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6866 pWdaParams->pWdaContext = pWDA;
6867 /* store Params pass it to WDI */
6868 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBAReqParam ;
6869 pWdaParams->wdaMsgParam = pAddBAReqParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6870 wstatus = WDI_AddBAReq(wdiAddBAReqParam,
6871 (WDI_AddBARspCb)WDA_AddBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6872
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6873 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6874 {
6875 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6876 "Failure in ADD BA REQ Params WDI API, free all the memory" );
6877 status = CONVERT_WDI2VOS_STATUS(wstatus);
6878 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6879 vos_mem_free(pWdaParams);
6880 pAddBAReqParams->status = eSIR_FAILURE;
6881 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6882 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]6883 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6884}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6885/*
6886 * FUNCTION: WDA_AddBASessionReqCallback
6887 * send ADD BA SESSION RSP back to PE/(or TL)
6888 */
6889void WDA_AddBASessionReqCallback(
6890 WDI_AddBASessionRspParamsType *wdiAddBaSession, void* pUserData)
6891{
6892 VOS_STATUS status = VOS_STATUS_SUCCESS ;
6893 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6894 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6895 tAddBAParams *pAddBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6896 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6897 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6898 if(NULL == pWdaParams)
6899 {
6900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6901 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6902 VOS_ASSERT(0) ;
6903 return ;
6904 }
6905 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6906 if (NULL == pWDA)
6907 {
6908 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
6909 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]6910 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6911 vos_mem_free(pWdaParams->wdaMsgParam);
6912 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]6913 VOS_ASSERT(0);
6914 return ;
6915 }
6916
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6917 pAddBAReqParams = (tAddBAParams *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6918 if( NULL == pAddBAReqParams )
6919 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6920 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6921 "%s: pAddBAReqParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6922 VOS_ASSERT( 0 );
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]6923 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6924 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6925 return ;
6926 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6927 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
6928 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6929 /*
Deepthi Gowriba794fc2015-03-27 17:14:01 +0530[diff] [blame]6930 * if BA direction is for recipient, update TL with BA session params and send
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6931 * another request to HAL(/WDI) (ADD_BA_REQ)
6932 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6933 if((VOS_STATUS_SUCCESS ==
6934 CONVERT_WDI2VOS_STATUS(wdiAddBaSession->wdiStatus)) &&
Deepthi Gowriba794fc2015-03-27 17:14:01 +0530[diff] [blame]6935 (eBA_RECIPIENT == pAddBAReqParams->baDirection))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6936 {
6937 /* Update TL with BA info received from HAL/WDI */
6938 status = WDA_TL_BA_SESSION_ADD(pWDA->pVosContext,
6939 wdiAddBaSession->usBaSessionID,
6940 wdiAddBaSession->ucSTAIdx,
6941 wdiAddBaSession->ucBaTID,
6942 wdiAddBaSession->ucBaBufferSize,
6943 wdiAddBaSession->ucWinSize,
6944 wdiAddBaSession->usBaSSN );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6945 WDA_ProcessAddBAReq(pWDA, status, wdiAddBaSession->usBaSessionID,
Abhishek Singh01c73d12015-03-12 15:13:44 +0530[diff] [blame]6946 wdiAddBaSession->ucSTAIdx,
6947 wdiAddBaSession->ucWinSize, pAddBAReqParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6948 }
6949 else
6950 {
6951 pAddBAReqParams->status =
6952 CONVERT_WDI2SIR_STATUS(wdiAddBaSession->wdiStatus) ;
6953
6954 /* Setting Flag to indicate that Set BA is success */
6955 if(WDI_STATUS_SUCCESS == wdiAddBaSession->wdiStatus)
6956 {
6957 tANI_U16 curSta = wdiAddBaSession->ucSTAIdx;
6958 tANI_U8 tid = wdiAddBaSession->ucBaTID;
6959 WDA_SET_BA_TXFLAG(pWDA, curSta, tid) ;
6960 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6961 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
6962 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6963 /*Reset the WDA state to READY */
6964 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6965 return ;
6966}
6967
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6968/*
6969 * FUNCTION: WDA_ProcessAddBASessionReq
6970 * Request to WDI to Update the ADDBA REQ params.
6971 */
6972VOS_STATUS WDA_ProcessAddBASessionReq(tWDA_CbContext *pWDA,
6973 tAddBAParams *pAddBAReqParams)
6974{
6975 WDI_Status status = WDI_STATUS_SUCCESS ;
6976 WDI_AddBASessionReqParamsType *wdiAddBASessionReqParam =
6977 (WDI_AddBASessionReqParamsType *)vos_mem_malloc(
6978 sizeof(WDI_AddBASessionReqParamsType)) ;
6979 tWDA_ReqParams *pWdaParams ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]6980 WLANTL_STAStateType tlSTAState = 0;
6981
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6982 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6983 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6984 if(NULL == wdiAddBASessionReqParam)
6985 {
6986 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6987 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6988 VOS_ASSERT(0);
6989 return VOS_STATUS_E_NOMEM;
6990 }
6991 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
6992 if(NULL == pWdaParams)
6993 {
6994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]6995 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]6996 VOS_ASSERT(0);
6997 vos_mem_free(wdiAddBASessionReqParam);
6998 return VOS_STATUS_E_NOMEM;
6999 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7000 /*
7001 * Populate ADD BA parameters and pass these paarmeters to WDI.
7002 * ADD BA SESSION REQ will update HAL with BA params, WDA, will changes
7003 * the state to track if these is BA recipient case or BA initiator
7004 * case.
7005 */
7006 do
7007 {
7008 WDI_AddBASessionReqinfoType *wdiBAInfoType =
7009 &wdiAddBASessionReqParam->wdiBASessionInfoType ;
7010 /* vos_mem_copy(wdiBAInfoType->macBSSID,
7011 pAddBAReqParams->bssId, sizeof(tSirMacAddr));*/
7012 wdiBAInfoType->ucSTAIdx = pAddBAReqParams->staIdx;
7013 vos_mem_copy(wdiBAInfoType->macPeerAddr,
7014 pAddBAReqParams->peerMacAddr, sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7015 wdiBAInfoType->ucBaTID = pAddBAReqParams->baTID;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7016 wdiBAInfoType->ucBaPolicy = pAddBAReqParams->baPolicy;
7017 wdiBAInfoType->usBaBufferSize = pAddBAReqParams->baBufferSize;
7018 wdiBAInfoType->usBaTimeout = pAddBAReqParams->baTimeout;
7019 wdiBAInfoType->usBaSSN = pAddBAReqParams->baSSN;
7020 wdiBAInfoType->ucBaDirection = pAddBAReqParams->baDirection;
Deepthi Gowriba794fc2015-03-27 17:14:01 +0530[diff] [blame]7021
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7022 }while(0) ;
7023 wdiAddBASessionReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7024 pWdaParams->pWdaContext = pWDA;
7025 /* Store ADD BA pointer, as this will be used for response */
7026 pWdaParams->wdaMsgParam = (void *)pAddBAReqParams ;
7027 /* store Params pass it to WDI */
7028 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddBASessionReqParam ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]7029
7030 /* In TDLS case, there is a possibility that TL hasn't registered peer yet, but
7031 the peer thinks that we already setup TDLS link, and send us ADDBA request packet
7032 */
7033 if((VOS_STATUS_SUCCESS != WDA_TL_GET_STA_STATE(pWDA->pVosContext, pAddBAReqParams->staIdx, &tlSTAState)) ||
7034 ((WLANTL_STA_CONNECTED != tlSTAState) && (WLANTL_STA_AUTHENTICATED != tlSTAState)))
7035 {
7036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]7037 "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]7038 status = WDI_STATUS_E_NOT_ALLOWED;
7039 pAddBAReqParams->status =
7040 CONVERT_WDI2SIR_STATUS(status) ;
7041 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
7042 /*Reset the WDA state to READY */
7043 pWDA->wdaState = WDA_READY_STATE;
7044 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7045 vos_mem_free(pWdaParams);
7046
7047 return CONVERT_WDI2VOS_STATUS(status) ;
7048 }
7049
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7050 status = WDI_AddBASessionReq(wdiAddBASessionReqParam,
7051 (WDI_AddBASessionRspCb)WDA_AddBASessionReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7052 if(IS_WDI_STATUS_FAILURE(status))
7053 {
7054 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]7055 "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]7056 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]7057 "Send ADD BA failure response to PE");
Shailender Karmuchi2a74d4c2013-03-24 23:25:27 -0700[diff] [blame]7058 pAddBAReqParams->status =
7059 CONVERT_WDI2SIR_STATUS(status) ;
7060 WDA_SendMsg(pWDA, WDA_ADDBA_RSP, (void *)pAddBAReqParams , 0) ;
Hoonki Leea0631ce2013-04-15 16:59:08 -0700[diff] [blame]7061 /*Reset the WDA state to READY */
7062 pWDA->wdaState = WDA_READY_STATE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7063 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7064 vos_mem_free(pWdaParams);
7065 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7066 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7067}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7068/*
7069 * FUNCTION: WDA_DelBANotifyTL
7070 * send DEL BA IND to TL
7071 */
7072void WDA_DelBANotifyTL(tWDA_CbContext *pWDA,
7073 tDelBAParams *pDelBAReqParams)
7074{
7075 tpDelBAInd pDelBAInd = (tpDelBAInd)vos_mem_malloc(sizeof( tDelBAInd ));
7076 //tSirMsgQ msg;
7077 vos_msg_t vosMsg;
7078 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7079 if(NULL == pDelBAInd)
7080 {
7081 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7082 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7083 VOS_ASSERT(0) ;
7084 return;
7085 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7086 pDelBAInd->mesgType = WDA_DELETEBA_IND;
7087 pDelBAInd->staIdx = (tANI_U8) pDelBAReqParams->staIdx;
7088 pDelBAInd->baTID = (tANI_U8) pDelBAReqParams->baTID;
7089 pDelBAInd->mesgLen = sizeof( tDelBAInd );
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7090
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7091
7092 vosMsg.type = WDA_DELETEBA_IND;
7093 vosMsg.bodyptr = pDelBAInd;
7094 vosStatus = vos_mq_post_message(VOS_MQ_ID_TL, &vosMsg);
7095 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
7096 {
7097 vosStatus = VOS_STATUS_E_BADMSG;
7098 }
7099}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7100/*
7101 * FUNCTION: WDA_DelBAReqCallback
7102 * send DEL BA RSP back to PE
7103 */
7104void WDA_DelBAReqCallback(WDI_Status status, void* pUserData)
7105{
7106 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7107 tWDA_CbContext *pWDA;
7108 tDelBAParams *pDelBAReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7109 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7110 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7111 if(NULL == pWdaParams)
7112 {
7113 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7114 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7115 VOS_ASSERT(0) ;
7116 return ;
7117 }
7118 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7119
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7120 pDelBAReqParams = (tDelBAParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7121 /* Notify TL about DEL BA in case of recipinet */
7122 if((VOS_STATUS_SUCCESS == CONVERT_WDI2VOS_STATUS(status)) &&
7123 (eBA_RECIPIENT == pDelBAReqParams->baDirection))
7124 {
7125 WDA_DelBANotifyTL(pWDA, pDelBAReqParams);
7126 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7127 /*
7128 * No respone required for WDA_DELBA_IND so just free the request
7129 * param here
7130 */
7131 vos_mem_free(pDelBAReqParams);
7132 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7133 vos_mem_free(pWdaParams);
7134 return ;
7135}
7136
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7137/*
7138 * FUNCTION: WDA_ProcessDelBAReq
7139 * Request to WDI to Update the DELBA REQ params.
7140 */
7141VOS_STATUS WDA_ProcessDelBAReq(tWDA_CbContext *pWDA,
7142 tDelBAParams *pDelBAReqParams)
7143{
7144 WDI_Status status = WDI_STATUS_SUCCESS ;
7145 WDI_DelBAReqParamsType *wdiDelBAReqParam =
7146 (WDI_DelBAReqParamsType *)vos_mem_malloc(
7147 sizeof(WDI_DelBAReqParamsType)) ;
7148 tWDA_ReqParams *pWdaParams ;
7149 tANI_U16 staIdx = 0;
7150 tANI_U8 tid = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7151 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7152 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7153 if(NULL == wdiDelBAReqParam)
7154 {
7155 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7156 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7157 VOS_ASSERT(0);
7158 return VOS_STATUS_E_NOMEM;
7159 }
7160 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7161 if(NULL == pWdaParams)
7162 {
7163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7164 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7165 VOS_ASSERT(0);
7166 vos_mem_free(wdiDelBAReqParam);
7167 return VOS_STATUS_E_NOMEM;
7168 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7169 wdiDelBAReqParam->wdiBAInfo.ucSTAIdx = pDelBAReqParams->staIdx;
7170 wdiDelBAReqParam->wdiBAInfo.ucBaTID = pDelBAReqParams->baTID;
7171 wdiDelBAReqParam->wdiBAInfo.ucBaDirection = pDelBAReqParams->baDirection;
7172 wdiDelBAReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7173 pWdaParams->pWdaContext = pWDA;
7174 /* Store DEL BA pointer, as this will be used for response */
7175 pWdaParams->wdaMsgParam = (void *)pDelBAReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7176 /* store Params pass it to WDI */
7177 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelBAReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7178 /* if BA exchange over the air is failed, clear this tid in BaBitmap
7179 * maintained in WDA, so that WDA can retry for another BA session
7180 */
7181 staIdx = pDelBAReqParams->staIdx;
7182 tid = pDelBAReqParams->baTID;
7183 WDA_CLEAR_BA_TXFLAG(pWDA, staIdx, tid);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7184 status = WDI_DelBAReq(wdiDelBAReqParam,
7185 (WDI_DelBARspCb)WDA_DelBAReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7186 if(IS_WDI_STATUS_FAILURE(status))
7187 {
7188 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7189 "Failure in DEL BA REQ Params WDI API, free all the memory " );
7190 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7191 vos_mem_free(pWdaParams->wdaMsgParam);
7192 vos_mem_free(pWdaParams);
7193 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7194 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7195}
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7196
7197/*
7198 * FUNCTION: WDA_UpdateChReqCallback
7199 *
7200 */
7201void WDA_UpdateChReqCallback(WDI_Status status, void* pUserData)
7202{
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]7203 tWDA_ReqParams *pWdaParams;
7204 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
7205 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
7206 WDI_UpdateChannelReqinfoType *pChanInfoType;
7207 tSirUpdateChanList *pChanList;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7208
7209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7210 "<------ %s " ,__func__);
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]7211 if(NULL == pUserData)
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7212 {
7213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]7214 "%s: pUserData received NULL", __func__);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7215 VOS_ASSERT(0);
7216 return;
7217 }
7218
Siddharth Bhala006c122014-05-03 12:13:27 +0530[diff] [blame]7219 pWdaParams = (tWDA_ReqParams *)pUserData;
7220 pwdiUpdateChReqParam =
7221 (WDI_UpdateChReqParamsType *)pWdaParams->wdaWdiApiMsgParam;
7222 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
7223 pChanInfoType = pwdiUpdateChanReqType->pchanParam;
7224 pChanList = (tSirUpdateChanList *)pWdaParams->wdaMsgParam;
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7225 /*
7226 * currently there is no response message is expected between PE and
7227 * WDA, Failure return from WDI is a ASSERT condition
7228 */
7229 vos_mem_free(pChanInfoType);
7230 vos_mem_free(pChanList);
7231 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7232 vos_mem_free(pWdaParams);
7233
7234 return;
7235}
7236
7237/*
7238 * FUNCTION: WDA_ProcessUpdateChannelList
7239 * Request to WDI to Update the ChannelList params.
7240 */
7241VOS_STATUS WDA_ProcessUpdateChannelList(tWDA_CbContext *pWDA,
7242 tSirUpdateChanList *pChanList)
7243{
7244 WDI_Status status = WDI_STATUS_SUCCESS;
7245 WDI_UpdateChReqParamsType *pwdiUpdateChReqParam;
7246 WDI_UpdateChannelReqType *pwdiUpdateChanReqType;
7247 WDI_UpdateChannelReqinfoType *pChanInfoType;
7248 tWDA_ReqParams *pWdaParams;
7249 wpt_uint8 i;
7250
7251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7252 "------> %s " ,__func__);
7253 if(NULL == pChanList)
7254 {
7255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7256 "%s: NULL pChanList", __func__);
7257 VOS_ASSERT(0);
7258 return VOS_STATUS_E_INVAL;
7259 }
7260
7261 if(!WDA_getFwWlanFeatCaps(UPDATE_CHANNEL_LIST))
7262 {
Ratheesh S P36dbc932015-08-07 14:28:57 +0530[diff] [blame]7263 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7264 "Update channel list capability Not Supported");
7265 vos_mem_free(pChanList);
7266 return VOS_STATUS_E_INVAL;
7267 }
7268
7269 pwdiUpdateChReqParam = (WDI_UpdateChReqParamsType *)vos_mem_malloc(
7270 sizeof(WDI_UpdateChReqParamsType));
7271 if(NULL == pwdiUpdateChReqParam)
7272 {
7273 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7274 "%s: VOS MEM Alloc Failed for WDI_UpdateChReqParamsType",
7275 __func__);
7276 VOS_ASSERT(0);
7277 vos_mem_free(pChanList);
7278 return VOS_STATUS_E_NOMEM;
7279 }
7280 pwdiUpdateChanReqType = &pwdiUpdateChReqParam->wdiUpdateChanParams;
7281 pChanInfoType = (WDI_UpdateChannelReqinfoType *)
7282 vos_mem_malloc(sizeof(WDI_UpdateChannelReqinfoType) *
7283 pChanList->numChan);
7284 if(NULL == pChanInfoType)
7285 {
7286 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7287 "%s: VOS MEM Alloc Failure", __func__);
7288 VOS_ASSERT(0);
7289 vos_mem_free(pChanList);
7290 vos_mem_free(pwdiUpdateChReqParam);
7291 return VOS_STATUS_E_NOMEM;
7292 }
7293 vos_mem_zero(pChanInfoType, sizeof(WDI_UpdateChannelReqinfoType)
7294 * pChanList->numChan);
7295 pwdiUpdateChanReqType->pchanParam = pChanInfoType;
7296
7297 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
7298 if(NULL == pWdaParams)
7299 {
7300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7301 "%s: VOS MEM Alloc Failure", __func__);
7302 VOS_ASSERT(0);
7303 vos_mem_free(pChanList);
7304 vos_mem_free(pChanInfoType);
7305 vos_mem_free(pwdiUpdateChReqParam);
7306 return VOS_STATUS_E_NOMEM;
7307 }
7308 pwdiUpdateChanReqType->numchan = pChanList->numChan;
7309
7310 for(i = 0; i < pwdiUpdateChanReqType->numchan; i++)
7311 {
7312 pChanInfoType->mhz =
7313 vos_chan_to_freq(pChanList->chanParam[i].chanId);
7314
7315 pChanInfoType->band_center_freq1 = pChanInfoType->mhz;
7316 pChanInfoType->band_center_freq2 = 0;
7317
7318 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7319 "chan[%d] = %u", i, pChanInfoType->mhz);
7320 if (pChanList->chanParam[i].dfsSet)
7321 {
7322 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_PASSIVE);
7323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
7324 "chan[%d] DFS[%d]", pChanList->chanParam[i].chanId,
7325 pChanList->chanParam[i].dfsSet);
7326 }
7327
7328 if (pChanInfoType->mhz < WDA_2_4_GHZ_MAX_FREQ)
7329 {
7330 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11G);
7331 }
7332 else
7333 {
7334 WDA_SET_CHANNEL_MODE(pChanInfoType, MODE_11A);
7335 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_HT);
7336 WDA_SET_CHANNEL_FLAG(pChanInfoType, WLAN_HAL_CHAN_FLAG_ALLOW_VHT);
7337 }
7338
7339 WDA_SET_CHANNEL_MAX_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
7340 WDA_SET_CHANNEL_REG_POWER(pChanInfoType, pChanList->chanParam[i].pwr);
Sachin Ahujacb64fc82015-01-12 17:01:05 +0530[diff] [blame]7341 WDA_SET_CUURENT_REG_DOMAIN(pChanInfoType, pChanList->regId);
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7342 pChanInfoType++;
7343 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]7344 pwdiUpdateChReqParam->wdiReqStatusCB = NULL;
7345 pWdaParams->pWdaContext = pWDA;
7346 pWdaParams->wdaMsgParam = (void *)pChanList;
7347 /* store Params pass it to WDI */
7348 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiUpdateChReqParam;
7349 status = WDI_UpdateChannelReq(pwdiUpdateChReqParam,
7350 (WDI_UpdateChannelRspCb)WDA_UpdateChReqCallback, pWdaParams);
7351 if(IS_WDI_STATUS_FAILURE(status))
7352 {
7353 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7354 "Failure in Update Channel REQ Params WDI API, free all the memory");
7355 vos_mem_free(pwdiUpdateChanReqType->pchanParam);
7356 vos_mem_free(pwdiUpdateChReqParam);
7357 vos_mem_free(pWdaParams->wdaMsgParam);
7358 vos_mem_free(pWdaParams);
7359 }
7360 return CONVERT_WDI2VOS_STATUS(status);
7361}
7362
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7363/*
7364 * FUNCTION: WDA_AddTSReqCallback
7365 * send ADD TS RSP back to PE
7366 */
7367void WDA_AddTSReqCallback(WDI_Status status, void* pUserData)
7368{
7369 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7370 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7371 tAddTsParams *pAddTsReqParams;
7372
7373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7374 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7375 if(NULL == pWdaParams)
7376 {
7377 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7378 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7379 VOS_ASSERT(0) ;
7380 return ;
7381 }
7382 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7383 if (NULL == pWDA)
7384 {
7385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7386 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]7387 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7388 vos_mem_free(pWdaParams->wdaMsgParam);
7389 vos_mem_free(pWdaParams);
7390
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7391 VOS_ASSERT(0);
7392 return ;
7393 }
7394
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7395 pAddTsReqParams = (tAddTsParams *)pWdaParams->wdaMsgParam ;
7396 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7397 vos_mem_free(pWdaParams);
7398
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]7399 pAddTsReqParams->status = status ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7400 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7401 return ;
7402}
7403
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7404/*
7405 * FUNCTION: WDA_ProcessAddTSReq
7406 * Request to WDI to Update the ADD TS REQ params.
7407 */
7408VOS_STATUS WDA_ProcessAddTSReq(tWDA_CbContext *pWDA,
7409 tAddTsParams *pAddTsReqParams)
7410{
7411 WDI_Status status = WDI_STATUS_SUCCESS ;
7412 WDI_AddTSReqParamsType *wdiAddTSReqParam =
7413 (WDI_AddTSReqParamsType *)vos_mem_malloc(
7414 sizeof(WDI_AddTSReqParamsType)) ;
7415 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7416 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7417 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7418 if(NULL == wdiAddTSReqParam)
7419 {
7420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7421 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7422 VOS_ASSERT(0);
7423 return VOS_STATUS_E_NOMEM;
7424 }
7425 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7426 if(NULL == pWdaParams)
7427 {
7428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7429 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7430 VOS_ASSERT(0);
7431 vos_mem_free(wdiAddTSReqParam);
7432 return VOS_STATUS_E_NOMEM;
7433 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7434 wdiAddTSReqParam->wdiTsInfo.ucSTAIdx = pAddTsReqParams->staIdx;
7435 wdiAddTSReqParam->wdiTsInfo.ucTspecIdx = pAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7436 //TS IE
7437 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucType = pAddTsReqParams->tspec.type;
7438 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.ucLength =
7439 pAddTsReqParams->tspec.length;
7440
7441 //TS IE : TS INFO : TRAFFIC
7442 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.ackPolicy =
7443 pAddTsReqParams->tspec.tsinfo.traffic.ackPolicy;
7444 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.userPrio =
7445 pAddTsReqParams->tspec.tsinfo.traffic.userPrio;
7446 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.psb =
7447 pAddTsReqParams->tspec.tsinfo.traffic.psb;
7448 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.aggregation =
7449 pAddTsReqParams->tspec.tsinfo.traffic.aggregation;
7450 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.accessPolicy =
7451 pAddTsReqParams->tspec.tsinfo.traffic.accessPolicy;
7452 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.direction =
7453 pAddTsReqParams->tspec.tsinfo.traffic.direction;
7454 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.tsid =
7455 pAddTsReqParams->tspec.tsinfo.traffic.tsid;
7456 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiTraffic.trafficType =
7457 pAddTsReqParams->tspec.tsinfo.traffic.trafficType;
7458
7459 //TS IE : TS INFO : SCHEDULE
7460 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.schedule =
7461 pAddTsReqParams->tspec.tsinfo.schedule.schedule;
7462 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.wdiTSinfo.wdiSchedule.rsvd =
7463 pAddTsReqParams->tspec.tsinfo.schedule.rsvd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7464 //TS IE
7465 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usNomMsduSz =
7466 pAddTsReqParams->tspec.nomMsduSz;
7467 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMaxMsduSz =
7468 pAddTsReqParams->tspec.maxMsduSz;
7469 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinSvcInterval =
7470 pAddTsReqParams->tspec.minSvcInterval;
7471 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxSvcInterval =
7472 pAddTsReqParams->tspec.maxSvcInterval;
7473 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uInactInterval =
7474 pAddTsReqParams->tspec.inactInterval;
7475 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSuspendInterval =
7476 pAddTsReqParams->tspec.suspendInterval;
7477 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uSvcStartTime =
7478 pAddTsReqParams->tspec.svcStartTime;
7479 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinDataRate =
7480 pAddTsReqParams->tspec.minDataRate;
7481 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMeanDataRate =
7482 pAddTsReqParams->tspec.meanDataRate;
7483 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uPeakDataRate =
7484 pAddTsReqParams->tspec.peakDataRate;
7485 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMaxBurstSz =
7486 pAddTsReqParams->tspec.maxBurstSz;
7487 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uDelayBound =
7488 pAddTsReqParams->tspec.delayBound;
7489 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.uMinPhyRate =
7490 pAddTsReqParams->tspec.minPhyRate;
7491 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usSurplusBw =
7492 pAddTsReqParams->tspec.surplusBw;
7493 wdiAddTSReqParam->wdiTsInfo.wdiTspecIE.usMediumTime =
7494 pAddTsReqParams->tspec.mediumTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7495 /* TODO: tAddTsParams doesn't have the following fields */
7496#if 0
7497 wdiAddTSReqParam->wdiTsInfo.ucUapsdFlags =
7498 wdiAddTSReqParam->wdiTsInfo.ucServiceInterval =
7499 wdiAddTSReqParam->wdiTsInfo.ucSuspendInterval =
7500 wdiAddTSReqParam->wdiTsInfo.ucDelayedInterval =
7501#endif
7502 wdiAddTSReqParam->wdiReqStatusCB = NULL ;
7503
7504 pWdaParams->pWdaContext = pWDA;
7505 /* Store ADD TS pointer, as this will be used for response */
7506 pWdaParams->wdaMsgParam = (void *)pAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7507 /* store Params pass it to WDI */
7508 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAddTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7509 status = WDI_AddTSReq(wdiAddTSReqParam,
7510 (WDI_AddTsRspCb)WDA_AddTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7511 if(IS_WDI_STATUS_FAILURE(status))
7512 {
7513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7514 "Failure in ADD TS REQ Params WDI API, free all the memory " );
7515 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7516 vos_mem_free(pWdaParams);
7517 pAddTsReqParams->status = eSIR_FAILURE ;
7518 WDA_SendMsg(pWDA, WDA_ADD_TS_RSP, (void *)pAddTsReqParams , 0) ;
7519 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7520 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7521}
7522
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7523/*
7524 * FUNCTION: WDA_DelTSReqCallback
7525 * send DEL TS RSP back to PE
7526 */
7527void WDA_DelTSReqCallback(WDI_Status status, void* pUserData)
7528{
7529 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7530 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7531 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7532 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7533 vos_mem_free(pWdaParams->wdaMsgParam) ;
7534 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7535 /*
7536 * No respone required for WDA_DEL_TS_REQ so just free the request
7537 * param here
7538 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7539 return ;
7540}
7541
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7542/*
7543 * FUNCTION: WDA_ProcessDelTSReq
7544 * Request to WDI to Update the DELTS REQ params.
7545 */
7546VOS_STATUS WDA_ProcessDelTSReq(tWDA_CbContext *pWDA,
7547 tDelTsParams *pDelTSReqParams)
7548{
7549 WDI_Status status = WDI_STATUS_SUCCESS ;
7550 WDI_DelTSReqParamsType *wdiDelTSReqParam =
7551 (WDI_DelTSReqParamsType *)vos_mem_malloc(
7552 sizeof(WDI_DelTSReqParamsType)) ;
7553 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7554 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7555 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7556 if(NULL == wdiDelTSReqParam)
7557 {
7558 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7559 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7560 VOS_ASSERT(0);
7561 return VOS_STATUS_E_NOMEM;
7562 }
7563 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7564 if(NULL == pWdaParams)
7565 {
7566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7567 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7568 VOS_ASSERT(0);
7569 vos_mem_free(wdiDelTSReqParam);
7570 return VOS_STATUS_E_NOMEM;
7571 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7572 vos_mem_copy(wdiDelTSReqParam->wdiDelTSInfo.macBSSID,
7573 pDelTSReqParams->bssId, sizeof(tSirMacAddr));
7574 wdiDelTSReqParam->wdiDelTSInfo.ucSTAIdx = pDelTSReqParams->staIdx;
7575 wdiDelTSReqParam->wdiDelTSInfo.ucTspecIdx = pDelTSReqParams->tspecIdx;
7576 wdiDelTSReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7577 pWdaParams->pWdaContext = pWDA;
7578 /* Store DEL TS pointer, as this will be used for response */
7579 pWdaParams->wdaMsgParam = (void *)pDelTSReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7580 /* store Params pass it to WDI */
7581 pWdaParams->wdaWdiApiMsgParam = (void *)wdiDelTSReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7582 status = WDI_DelTSReq(wdiDelTSReqParam,
7583 (WDI_DelTsRspCb)WDA_DelTSReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7584 if(IS_WDI_STATUS_FAILURE(status))
7585 {
7586 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7587 "Failure in DEL TS REQ Params WDI API, free all the memory " );
7588 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7589 vos_mem_free(pWdaParams->wdaMsgParam);
7590 vos_mem_free(pWdaParams);
7591 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7592 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7593}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7594/*
7595 * FUNCTION: WDA_UpdateBeaconParamsCallback
7596 * Free the memory. No need to send any response to PE in this case
7597 */
7598void WDA_UpdateBeaconParamsCallback(WDI_Status status, void* pUserData)
7599{
7600 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7602 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7603 if(NULL == pWdaParams)
7604 {
7605 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7606 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7607 VOS_ASSERT(0) ;
7608 return ;
7609 }
7610 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7611 vos_mem_free(pWdaParams->wdaMsgParam) ;
7612 vos_mem_free(pWdaParams);
7613 /*
7614 * No respone required for WDA_UPDATE_BEACON_IND so just free the request
7615 * param here
7616 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7617 return ;
7618}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7619/*
7620 * FUNCTION: WDA_ProcessUpdateBeaconParams
7621 * Request to WDI to send the beacon parameters to HAL to update the Hardware
7622 */
7623VOS_STATUS WDA_ProcessUpdateBeaconParams(tWDA_CbContext *pWDA,
7624 tUpdateBeaconParams *pUpdateBeaconParams)
7625{
7626 WDI_Status status = WDI_STATUS_SUCCESS ;
7627 WDI_UpdateBeaconParamsType *wdiUpdateBeaconParams =
7628 (WDI_UpdateBeaconParamsType *)vos_mem_malloc(
7629 sizeof(WDI_UpdateBeaconParamsType)) ;
7630 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7632 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7633 if(NULL == wdiUpdateBeaconParams)
7634 {
7635 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7636 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7637 VOS_ASSERT(0);
7638 return VOS_STATUS_E_NOMEM;
7639 }
7640 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7641 if(NULL == pWdaParams)
7642 {
7643 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7644 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7645 VOS_ASSERT(0);
7646 vos_mem_free(wdiUpdateBeaconParams);
7647 return VOS_STATUS_E_NOMEM;
7648 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7649 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucBssIdx =
7650 pUpdateBeaconParams->bssIdx;
7651 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortPreamble =
7652 pUpdateBeaconParams->fShortPreamble;
7653 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfShortSlotTime =
7654 pUpdateBeaconParams->fShortSlotTime;
7655 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usBeaconInterval =
7656 pUpdateBeaconParams->beaconInterval;
7657 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllaCoexist =
7658 pUpdateBeaconParams->llaCoexist;
7659 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllbCoexist =
7660 pUpdateBeaconParams->llbCoexist;
7661 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllgCoexist =
7662 pUpdateBeaconParams->llgCoexist;
7663 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucHt20MhzCoexist=
7664 pUpdateBeaconParams->ht20MhzCoexist;
7665 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucllnNonGFCoexist =
7666 pUpdateBeaconParams->llnNonGFCoexist;
7667 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfLsigTXOPProtectionFullSupport =
7668 pUpdateBeaconParams->fLsigTXOPProtectionFullSupport;
7669 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.ucfRIFSMode =
7670 pUpdateBeaconParams->fRIFSMode;
7671 wdiUpdateBeaconParams->wdiUpdateBeaconParamsInfo.usChangeBitmap =
7672 pUpdateBeaconParams->paramChangeBitmap;
7673 wdiUpdateBeaconParams->wdiReqStatusCB = NULL ;
7674
7675 pWdaParams->pWdaContext = pWDA;
7676 /* Store UpdateBeacon Req pointer, as this will be used for response */
7677 pWdaParams->wdaMsgParam = (void *)pUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7678 /* store Params pass it to WDI */
7679 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateBeaconParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7680 status = WDI_UpdateBeaconParamsReq(wdiUpdateBeaconParams,
7681 (WDI_UpdateBeaconParamsRspCb)WDA_UpdateBeaconParamsCallback,
7682 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7683 if(IS_WDI_STATUS_FAILURE(status))
7684 {
7685 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7686 "Failure in UPDATE BEACON REQ Params WDI API, free all the memory " );
7687 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
7688 vos_mem_free(pWdaParams->wdaMsgParam);
7689 vos_mem_free(pWdaParams);
7690 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7691 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7692}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7693#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7694/*
7695 * FUNCTION: WDA_TSMStatsReqCallback
7696 * send TSM Stats RSP back to PE
7697 */
7698void WDA_TSMStatsReqCallback(WDI_TSMStatsRspParamsType *pwdiTSMStatsRspParams, void* pUserData)
7699{
7700 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7701 tWDA_CbContext *pWDA = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7702 tpAniGetTsmStatsRsp pTsmRspParams = NULL;
7703 tpAniGetTsmStatsReq pGetTsmStatsReqParams = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7704
7705 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7706 "<------ Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7707 if(NULL == pWdaParams)
7708 {
7709 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7710 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7711 VOS_ASSERT(0) ;
7712 return ;
7713 }
7714 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7715 if (NULL == pWDA)
7716 {
7717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7718 "%s:pWDA is NULL", __func__);
7719 VOS_ASSERT(0);
7720 return ;
7721 }
7722
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7723 pGetTsmStatsReqParams = (tAniGetTsmStatsReq *)pWdaParams->wdaMsgParam;
7724
7725 if(NULL == pGetTsmStatsReqParams)
7726 {
7727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7728 "%s: pGetTsmStatsReqParams received NULL", __func__);
7729 VOS_ASSERT(0);
7730 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7731 vos_mem_free(pWdaParams);
7732 return;
7733 }
7734
7735 pTsmRspParams =
7736 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7737 if( NULL == pTsmRspParams )
7738 {
7739 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7740 "%s: pTsmRspParams received NULL " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7741 VOS_ASSERT( 0 );
7742 return ;
7743 }
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7744 vos_mem_set(pTsmRspParams, sizeof(tAniGetTsmStatsRsp), 0);
7745 pTsmRspParams->rc = pwdiTSMStatsRspParams->wdiStatus;
7746 pTsmRspParams->staId = pGetTsmStatsReqParams->staId;
7747
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7748 pTsmRspParams->tsmMetrics.UplinkPktQueueDly = pwdiTSMStatsRspParams->UplinkPktQueueDly;
7749 vos_mem_copy(pTsmRspParams->tsmMetrics.UplinkPktQueueDlyHist,
7750 pwdiTSMStatsRspParams->UplinkPktQueueDlyHist,
7751 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist)/
7752 sizeof(pwdiTSMStatsRspParams->UplinkPktQueueDlyHist[0]));
7753 pTsmRspParams->tsmMetrics.UplinkPktTxDly = pwdiTSMStatsRspParams->UplinkPktTxDly;
7754 pTsmRspParams->tsmMetrics.UplinkPktLoss = pwdiTSMStatsRspParams->UplinkPktLoss;
7755 pTsmRspParams->tsmMetrics.UplinkPktCount = pwdiTSMStatsRspParams->UplinkPktCount;
7756 pTsmRspParams->tsmMetrics.RoamingCount = pwdiTSMStatsRspParams->RoamingCount;
7757 pTsmRspParams->tsmMetrics.RoamingDly = pwdiTSMStatsRspParams->RoamingDly;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7758
7759 /* Assign get tsm stats req req (backup) in to the response */
7760 pTsmRspParams->tsmStatsReq = pGetTsmStatsReqParams;
7761
7762 /* free WDI command buffer */
7763 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7764 vos_mem_free(pWdaParams);
7765
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7766 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pTsmRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7767 return ;
7768}
7769
7770
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7771/*
7772 * FUNCTION: WDA_ProcessTsmStatsReq
7773 * Request to WDI to get the TSM Stats params.
7774 */
7775VOS_STATUS WDA_ProcessTsmStatsReq(tWDA_CbContext *pWDA,
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7776 tpAniGetTsmStatsReq pTsmStats)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7777{
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7778 WDI_Status status = WDI_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7779 WDI_TSMStatsReqParamsType *wdiTSMReqParam = NULL;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7780 tWDA_ReqParams *pWdaParams = NULL;
7781 tAniGetTsmStatsRsp *pGetTsmStatsRspParams = NULL;
7782
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7784 "------> Entering: %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7785 wdiTSMReqParam = (WDI_TSMStatsReqParamsType *)vos_mem_malloc(
7786 sizeof(WDI_TSMStatsReqParamsType));
7787 if(NULL == wdiTSMReqParam)
7788 {
7789 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7790 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7791 VOS_ASSERT(0);
7792 return VOS_STATUS_E_NOMEM;
7793 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7794 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
7795 if(NULL == pWdaParams)
7796 {
7797 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7798 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7799 VOS_ASSERT(0);
7800 vos_mem_free(wdiTSMReqParam);
7801 return VOS_STATUS_E_NOMEM;
7802 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7803 wdiTSMReqParam->wdiTsmStatsParamsInfo.ucTid = pTsmStats->tid;
7804 vos_mem_copy(wdiTSMReqParam->wdiTsmStatsParamsInfo.bssid,
7805 pTsmStats->bssId,
7806 sizeof(wpt_macAddr));
7807 wdiTSMReqParam->wdiReqStatusCB = NULL ;
7808
7809 pWdaParams->pWdaContext = pWDA;
7810 /* Store TSM Stats pointer, as this will be used for response */
7811 pWdaParams->wdaMsgParam = (void *)pTsmStats ;
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7812 pWdaParams->wdaWdiApiMsgParam = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7813 status = WDI_TSMStatsReq(wdiTSMReqParam,
7814 (WDI_TsmRspCb)WDA_TSMStatsReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7815 if(IS_WDI_STATUS_FAILURE(status))
7816 {
7817 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7818 "Failure in TSM STATS REQ Params WDI API, free all the memory " );
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]7819 vos_mem_free(pWdaParams);
7820
7821 pGetTsmStatsRspParams =
7822 (tAniGetTsmStatsRsp *)vos_mem_malloc(sizeof(tAniGetTsmStatsRsp));
7823 if(NULL == pGetTsmStatsRspParams)
7824 {
7825 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7826 "%s: VOS MEM Alloc Failure", __func__);
7827 VOS_ASSERT(0);
7828 vos_mem_free(pTsmStats);
7829 return VOS_STATUS_E_NOMEM;
7830 }
7831 pGetTsmStatsRspParams->staId = pTsmStats->staId;
7832 pGetTsmStatsRspParams->rc = eSIR_FAILURE;
7833 pGetTsmStatsRspParams->tsmStatsReq = pTsmStats;
7834
7835 WDA_SendMsg(pWDA, WDA_TSM_STATS_RSP, (void *)pGetTsmStatsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7836 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7837 return CONVERT_WDI2VOS_STATUS(status) ;
7838}
7839#endif
7840/*
7841 * FUNCTION: WDA_SendBeaconParamsCallback
7842 * No need to send any response to PE in this case
7843 */
7844void WDA_SendBeaconParamsCallback(WDI_Status status, void* pUserData)
7845{
7846
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7848 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7849 return ;
7850}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7851/*
7852 * FUNCTION: WDA_ProcessSendBeacon
7853 * Request to WDI to send the beacon template to HAL to update the TPE memory and
7854 * start beacon trasmission
7855 */
7856VOS_STATUS WDA_ProcessSendBeacon(tWDA_CbContext *pWDA,
7857 tSendbeaconParams *pSendbeaconParams)
7858{
7859 WDI_Status status = WDI_STATUS_SUCCESS ;
7860 WDI_SendBeaconParamsType wdiSendBeaconReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7862 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7863 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.macBSSID,
7864 pSendbeaconParams->bssId, sizeof(tSirMacAddr));
7865 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beaconLength =
7866 pSendbeaconParams->beaconLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7867 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.timIeOffset =
7868 pSendbeaconParams->timIeOffset;
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]7869 /* p2pIeOffset should be atleast greater than timIeOffset */
7870 if ((pSendbeaconParams->p2pIeOffset != 0) &&
7871 (pSendbeaconParams->p2pIeOffset <
7872 pSendbeaconParams->timIeOffset))
7873 {
7874 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7875 "Invalid p2pIeOffset = %hu ", pSendbeaconParams->p2pIeOffset);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]7876 vos_mem_free(pSendbeaconParams);
Gopichand Nakkala81aef732013-03-22 11:15:19 +0530[diff] [blame]7877 VOS_ASSERT( 0 );
7878 return WDI_STATUS_E_FAILURE;
7879 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7880 wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.usP2PIeOffset =
7881 pSendbeaconParams->p2pIeOffset;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7882 /* Copy the beacon template to local buffer */
7883 vos_mem_copy(wdiSendBeaconReqParam.wdiSendBeaconParamsInfo.beacon,
7884 pSendbeaconParams->beacon, pSendbeaconParams->beaconLength);
7885 wdiSendBeaconReqParam.wdiReqStatusCB = NULL ;
7886
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7887 status = WDI_SendBeaconParamsReq(&wdiSendBeaconReqParam,
7888 (WDI_SendBeaconParamsRspCb)WDA_SendBeaconParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7889 if(IS_WDI_STATUS_FAILURE(status))
7890 {
7891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7892 "Failure in SEND BEACON REQ Params WDI API" );
7893 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7894 vos_mem_free(pSendbeaconParams);
7895 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7896}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7897/*
7898 * FUNCTION: WDA_UpdateProbeRspParamsCallback
7899 * No need to send any response to PE in this case
7900 */
7901void WDA_UpdateProbeRspParamsCallback(WDI_Status status, void* pUserData)
7902{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7904 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7905 return ;
7906}
7907
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7908/*
7909 * FUNCTION: WDA_ProcessUpdateProbeRspTemplate
7910 * Request to WDI to send the probe response template to HAL to update the TPE memory and
7911 * send probe response
7912 */
7913VOS_STATUS WDA_ProcessUpdateProbeRspTemplate(tWDA_CbContext *pWDA,
7914 tSendProbeRespParams *pSendProbeRspParams)
7915{
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7916 WDI_Status status = WDI_STATUS_SUCCESS;
7917 WDI_UpdateProbeRspTemplateParamsType *wdiSendProbeRspParam =
7918 vos_mem_malloc(sizeof(WDI_UpdateProbeRspTemplateParamsType));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7919 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7920 "------> %s " ,__func__);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7921
7922 if (!wdiSendProbeRspParam)
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]7923 {
7924 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7925 return CONVERT_WDI2VOS_STATUS(WDI_STATUS_MEM_FAILURE);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]7926 }
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7927
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7928 /*Copy update probe response parameters*/
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7929 vos_mem_copy(wdiSendProbeRspParam->wdiProbeRspTemplateInfo.macBSSID,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7930 pSendProbeRspParams->bssId, sizeof(tSirMacAddr));
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7931 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uProbeRespTemplateLen =
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7932 pSendProbeRspParams->probeRespTemplateLen;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7933 /* Copy the Probe Response template to local buffer */
7934 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7935 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.pProbeRespTemplate,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7936 pSendProbeRspParams->pProbeRespTemplate,
7937 pSendProbeRspParams->probeRespTemplateLen);
7938 vos_mem_copy(
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7939 wdiSendProbeRspParam->wdiProbeRspTemplateInfo.uaProxyProbeReqValidIEBmap,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7940 pSendProbeRspParams->ucProxyProbeReqValidIEBmap,
7941 WDI_PROBE_REQ_BITMAP_IE_LEN);
7942
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7943 wdiSendProbeRspParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7944
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7945 status = WDI_UpdateProbeRspTemplateReq(wdiSendProbeRspParam,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7946 (WDI_UpdateProbeRspTemplateRspCb)WDA_UpdateProbeRspParamsCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7947 if(IS_WDI_STATUS_FAILURE(status))
7948 {
7949 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7950 "Failure in SEND Probe RSP Params WDI API" );
7951 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7952 vos_mem_free(pSendProbeRspParams);
Madan Mohan Koyyalamudi8f207c12012-10-30 18:18:38 -0700[diff] [blame]7953 vos_mem_free(wdiSendProbeRspParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7954 return CONVERT_WDI2VOS_STATUS(status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7955}
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]7956#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7957/*
7958 * FUNCTION: WDA_SetMaxTxPowerCallBack
7959 * send the response to PE with power value received from WDI
7960 */
7961void WDA_SetMaxTxPowerCallBack(WDI_SetMaxTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
7962 void* pUserData)
7963{
7964 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
7965 tWDA_CbContext *pWDA = NULL;
7966 tMaxTxPowerParams *pMaxTxPowerParams = NULL;
7967
7968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7969 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7970 if(NULL == pWdaParams)
7971 {
7972 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7973 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7974 VOS_ASSERT(0) ;
7975 return ;
7976 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7977 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7978 if (NULL == pWDA)
7979 {
7980 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
7981 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]7982 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7983 vos_mem_free(pWdaParams->wdaMsgParam);
7984 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]7985 VOS_ASSERT(0);
7986 return ;
7987 }
7988
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7989 pMaxTxPowerParams = (tMaxTxPowerParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7990 if( NULL == pMaxTxPowerParams )
7991 {
7992 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]7993 "%s: pMaxTxPowerParams received NULL " ,__func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7994 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]7995 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
7996 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]7997 return ;
7998 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]7999
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8000
8001 /*need to free memory for the pointers used in the
8002 WDA Process.Set Max Tx Power Req function*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8003 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8004 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8005 pMaxTxPowerParams->power = pwdiSetMaxTxPowerRsp->ucPower;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]8006
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8007
8008 /* send response to UMAC*/
8009 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, pMaxTxPowerParams , 0) ;
8010
8011 return;
8012}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8013/*
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8014 * FUNCTION: WDA_ProcessSetMaxTxPowerReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8015 * Request to WDI to send set Max Tx Power Request
8016 */
8017 VOS_STATUS WDA_ProcessSetMaxTxPowerReq(tWDA_CbContext *pWDA,
8018 tMaxTxPowerParams *MaxTxPowerParams)
8019{
8020 WDI_Status status = WDI_STATUS_SUCCESS;
8021 WDI_SetMaxTxPowerParamsType *wdiSetMaxTxPowerParams = NULL;
8022 tWDA_ReqParams *pWdaParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8023
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8024 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8025 "------> %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8026
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8027 wdiSetMaxTxPowerParams = (WDI_SetMaxTxPowerParamsType *)vos_mem_malloc(
8028 sizeof(WDI_SetMaxTxPowerParamsType));
8029 if(NULL == wdiSetMaxTxPowerParams)
8030 {
8031 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8032 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8033 VOS_ASSERT(0);
8034 return VOS_STATUS_E_NOMEM;
8035 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8036 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8037 if(NULL == pWdaParams)
8038 {
8039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8040 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8041 vos_mem_free(wdiSetMaxTxPowerParams);
8042 VOS_ASSERT(0);
8043 return VOS_STATUS_E_NOMEM;
8044 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8045 /* Copy.Max.Tx.Power Params to WDI structure */
8046 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macBSSId,
8047 MaxTxPowerParams->bssId,
8048 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8049 vos_mem_copy(wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.macSelfStaMacAddr,
8050 MaxTxPowerParams->selfStaMacAddr,
8051 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8052 wdiSetMaxTxPowerParams->wdiMaxTxPowerInfo.ucPower =
8053 MaxTxPowerParams->power;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8054 wdiSetMaxTxPowerParams->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8055 pWdaParams->pWdaContext = pWDA;
8056 pWdaParams->wdaMsgParam = (void *)MaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8057 /* store Params pass it to WDI */
8058 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMaxTxPowerParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8059 status = WDI_SetMaxTxPowerReq(wdiSetMaxTxPowerParams,
8060 (WDA_SetMaxTxPowerRspCb)WDA_SetMaxTxPowerCallBack, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8061 if(IS_WDI_STATUS_FAILURE(status))
8062 {
8063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8064 "Failure in SET MAX TX Power REQ Params WDI API, free all the memory " );
8065 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8066 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8067 /* send response to UMAC*/
8068 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_RSP, MaxTxPowerParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8069 }
8070 return CONVERT_WDI2VOS_STATUS(status);
8071
8072}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8073#endif
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]8074
8075/*
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]8076 * FUNCTION: WDA_SetMaxTxPowerPerBandCallBack
8077 * send the response to PE with power value received from WDI
8078 */
8079void WDA_SetMaxTxPowerPerBandCallBack(WDI_SetMaxTxPowerPerBandRspMsg
8080 *pwdiSetMaxTxPowerPerBandRsp,
8081 void* pUserData)
8082{
8083 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8084 tWDA_CbContext *pWDA = NULL;
8085 tMaxTxPowerPerBandParams *pMxTxPwrPerBandParams = NULL;
8086
8087 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8088 "<------ %s ", __func__);
8089 if (NULL == pWdaParams)
8090 {
8091 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8092 "%s: pWdaParams received NULL", __func__);
8093 VOS_ASSERT(0);
8094 return ;
8095 }
8096 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8097 if (NULL == pWDA)
8098 {
8099 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8100 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8101 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8102 vos_mem_free(pWdaParams->wdaMsgParam);
8103 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8104 VOS_ASSERT(0);
8105 return ;
8106 }
8107
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]8108 pMxTxPwrPerBandParams = (tMaxTxPowerPerBandParams*)pWdaParams->wdaMsgParam;
8109 if ( NULL == pMxTxPwrPerBandParams )
8110 {
8111 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8112 "%s: pMxTxPwrPerBandParams received NULL ", __func__);
8113 VOS_ASSERT(0);
8114 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8115 vos_mem_free(pWdaParams);
8116 return;
8117 }
8118
8119 /*need to free memory for the pointers used in the
8120 WDA Process.Set Max Tx Power Req function*/
8121 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8122 vos_mem_free(pWdaParams);
8123 pMxTxPwrPerBandParams->power = pwdiSetMaxTxPowerPerBandRsp->ucPower;
8124
8125 /* send response to UMAC*/
8126 WDA_SendMsg(pWDA, WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
8127 pMxTxPwrPerBandParams, 0);
8128
8129 return;
8130}
8131
8132/*
8133 * FUNCTION: WDA_ProcessSetMaxTxPowerPerBandReq
8134 * Request to WDI to send set Max Tx Power Per band Request
8135 */
8136 VOS_STATUS WDA_ProcessSetMaxTxPowerPerBandReq(tWDA_CbContext *pWDA,
8137 tMaxTxPowerPerBandParams
8138 *MaxTxPowerPerBandParams)
8139{
8140 WDI_Status status = WDI_STATUS_SUCCESS;
8141 WDI_SetMaxTxPowerPerBandParamsType *wdiSetMxTxPwrPerBandParams = NULL;
8142 tWDA_ReqParams *pWdaParams = NULL;
8143
8144 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8145 "------> %s ", __func__);
8146
8147 wdiSetMxTxPwrPerBandParams = vos_mem_malloc(
8148 sizeof(WDI_SetMaxTxPowerPerBandParamsType));
8149
8150 if (NULL == wdiSetMxTxPwrPerBandParams)
8151 {
8152 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8153 "%s: VOS MEM Alloc Failure", __func__);
8154 VOS_ASSERT(0);
8155 return VOS_STATUS_E_NOMEM;
8156 }
8157 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8158 if (NULL == pWdaParams)
8159 {
8160 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8161 "%s: VOS MEM Alloc Failure", __func__);
8162 vos_mem_free(wdiSetMxTxPwrPerBandParams);
8163 VOS_ASSERT(0);
8164 return VOS_STATUS_E_NOMEM;
8165 }
8166 /* Copy.Max.Tx.Power.Per.Band Params to WDI structure */
8167 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.bandInfo = \
8168 MaxTxPowerPerBandParams->bandInfo;
8169 wdiSetMxTxPwrPerBandParams->wdiMaxTxPowerPerBandInfo.ucPower = \
8170 MaxTxPowerPerBandParams->power;
8171 wdiSetMxTxPwrPerBandParams->wdiReqStatusCB = NULL;
8172 pWdaParams->pWdaContext = pWDA;
8173 pWdaParams->wdaMsgParam = (void *)MaxTxPowerPerBandParams;
8174 /* store Params pass it to WDI */
8175 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetMxTxPwrPerBandParams;
8176 status = WDI_SetMaxTxPowerPerBandReq(wdiSetMxTxPwrPerBandParams,
8177 WDA_SetMaxTxPowerPerBandCallBack,
8178 pWdaParams);
8179 if (IS_WDI_STATUS_FAILURE(status))
8180 {
8181 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8182 "Failure in SET MAX TX Power REQ Params WDI API,"
8183 " free all the memory");
8184 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8185 vos_mem_free(pWdaParams);
8186 /* send response to UMAC*/
8187 WDA_SendMsg(pWDA,
8188 WDA_SET_MAX_TX_POWER_PER_BAND_RSP,
8189 MaxTxPowerPerBandParams, 0);
8190 }
8191 return CONVERT_WDI2VOS_STATUS(status);
8192}
8193
8194/*
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]8195 * FUNCTION: WDA_SetTxPowerCallBack
8196 * send the response to PE with power value received from WDI
8197 */
8198void WDA_SetTxPowerCallBack(WDI_SetTxPowerRspMsg * pwdiSetMaxTxPowerRsp,
8199 void* pUserData)
8200{
8201 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8202 tWDA_CbContext *pWDA = NULL;
8203 tSirSetTxPowerReq *pTxPowerParams = NULL;
8204
8205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8206 "<------ %s ", __func__);
8207 if(NULL == pWdaParams)
8208 {
8209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8210 "%s: pWdaParams received NULL", __func__);
8211 VOS_ASSERT(0) ;
8212 return ;
8213 }
8214 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8215 if (NULL == pWDA)
8216 {
8217 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8218 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8219 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8220 vos_mem_free(pWdaParams->wdaMsgParam);
8221 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8222 VOS_ASSERT(0);
8223 return ;
8224 }
8225
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]8226 pTxPowerParams = (tSirSetTxPowerReq *)pWdaParams->wdaMsgParam;
8227 if(NULL == pTxPowerParams)
8228 {
8229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8230 "%s: pTxPowerParams received NULL " ,__func__);
8231 VOS_ASSERT(0);
8232 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8233 vos_mem_free(pWdaParams);
8234 return ;
8235 }
8236
8237 /*need to free memory for the pointers used in the
8238 WDA Process.Set Max Tx Power Req function*/
8239 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8240 vos_mem_free(pWdaParams);
8241
8242 /* send response to UMAC*/
8243 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, pTxPowerParams , 0) ;
8244 return;
8245}
8246
8247/*
8248 * FUNCTION: WDA_ProcessSetTxPowerReq
8249 * Request to WDI to send set Tx Power Request
8250 */
8251 VOS_STATUS WDA_ProcessSetTxPowerReq(tWDA_CbContext *pWDA,
8252 tSirSetTxPowerReq *txPowerParams)
8253{
8254 WDI_Status status = WDI_STATUS_SUCCESS;
8255 WDI_SetTxPowerParamsType *wdiSetTxPowerParams = NULL;
8256 tWDA_ReqParams *pWdaParams = NULL;
8257
8258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8259 "------> %s ", __func__);
8260
8261 wdiSetTxPowerParams = (WDI_SetTxPowerParamsType *)vos_mem_malloc(
8262 sizeof(WDI_SetTxPowerParamsType));
8263 if(NULL == wdiSetTxPowerParams)
8264 {
8265 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8266 "%s: VOS MEM Alloc Failure", __func__);
8267 VOS_ASSERT(0);
8268 return VOS_STATUS_E_NOMEM;
8269 }
8270 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8271 if(NULL == pWdaParams)
8272 {
8273 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8274 "%s: VOS MEM Alloc Failure", __func__);
8275 vos_mem_free(wdiSetTxPowerParams);
8276 VOS_ASSERT(0);
8277 return VOS_STATUS_E_NOMEM;
8278 }
8279 wdiSetTxPowerParams->wdiTxPowerInfo.bssIdx =
8280 txPowerParams->bssIdx;
8281 wdiSetTxPowerParams->wdiTxPowerInfo.ucPower =
8282 txPowerParams->mwPower;
8283 wdiSetTxPowerParams->wdiReqStatusCB = NULL ;
8284 pWdaParams->pWdaContext = pWDA;
8285 pWdaParams->wdaMsgParam = (void *)txPowerParams ;
8286 /* store Params pass it to WDI */
8287 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTxPowerParams ;
8288 status = WDI_SetTxPowerReq(wdiSetTxPowerParams,
8289 (WDA_SetTxPowerRspCb)WDA_SetTxPowerCallBack, pWdaParams);
8290 if(IS_WDI_STATUS_FAILURE(status))
8291 {
8292 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8293 "Failure in SET TX Power REQ Params WDI API, free all the memory ");
8294 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8295 vos_mem_free(pWdaParams);
8296 /* send response to UMAC*/
8297 WDA_SendMsg(pWDA, WDA_SET_TX_POWER_RSP, txPowerParams , 0) ;
8298 }
8299 return CONVERT_WDI2VOS_STATUS(status);
8300}
8301
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8302/*
8303 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
8304 * Free the memory. No need to send any response to PE in this case
8305 */
8306void WDA_SetP2PGONOAReqParamsCallback(WDI_Status status, void* pUserData)
8307{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8308 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
8309
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8311 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8312
8313 if(NULL == pWdaParams)
8314 {
8315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8316 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8317 VOS_ASSERT(0) ;
8318 return ;
8319 }
8320
8321 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8322 vos_mem_free(pWdaParams->wdaMsgParam) ;
8323 vos_mem_free(pWdaParams);
8324
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8325 /*
8326 * No respone required for SIR_HAL_SET_P2P_GO_NOA_REQ
8327 * so just free the request param here
8328 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8329 return ;
8330}
8331
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8332/*
8333 * FUNCTION: WDA_ProcessSetP2PGONOAReq
8334 * Request to WDI to set the P2P Group Owner Notice of Absence Req
8335 */
8336VOS_STATUS WDA_ProcessSetP2PGONOAReq(tWDA_CbContext *pWDA,
8337 tP2pPsParams *pP2pPsConfigParams)
8338{
8339 WDI_Status status = WDI_STATUS_SUCCESS ;
8340 WDI_SetP2PGONOAReqParamsType *wdiSetP2PGONOAReqParam =
8341 (WDI_SetP2PGONOAReqParamsType *)vos_mem_malloc(
8342 sizeof(WDI_SetP2PGONOAReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8343 tWDA_ReqParams *pWdaParams = NULL;
8344
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8345 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8346 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8347 if(NULL == wdiSetP2PGONOAReqParam)
8348 {
8349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8350 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]8351 vos_mem_free(pP2pPsConfigParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8352 VOS_ASSERT(0);
8353 return VOS_STATUS_E_NOMEM;
8354 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8355
8356 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8357 if(NULL == pWdaParams)
8358 {
8359 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8360 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8361 vos_mem_free(pP2pPsConfigParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8362 vos_mem_free(wdiSetP2PGONOAReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8363 VOS_ASSERT(0);
8364 return VOS_STATUS_E_NOMEM;
8365 }
8366
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8367 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucOpp_ps =
8368 pP2pPsConfigParams->opp_ps;
8369 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uCtWindow =
8370 pP2pPsConfigParams->ctWindow;
8371 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucCount =
8372 pP2pPsConfigParams->count;
8373 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uDuration =
8374 pP2pPsConfigParams->duration;
8375 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uInterval =
8376 pP2pPsConfigParams->interval;
8377 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.uSingle_noa_duration =
8378 pP2pPsConfigParams->single_noa_duration;
8379 wdiSetP2PGONOAReqParam->wdiP2PGONOAInfo.ucPsSelection =
8380 pP2pPsConfigParams->psSelection;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8381
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8382 wdiSetP2PGONOAReqParam->wdiReqStatusCB = NULL ;
8383 /* Store msg pointer from PE, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8384 pWdaParams->wdaMsgParam = (void *)pP2pPsConfigParams ;
8385
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8386 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8387 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetP2PGONOAReqParam ;
8388 pWdaParams->pWdaContext = pWDA;
8389
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8390 status = WDI_SetP2PGONOAReq(wdiSetP2PGONOAReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8391 (WDI_SetP2PGONOAReqParamsRspCb)WDA_SetP2PGONOAReqParamsCallback, pWdaParams);
8392
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8393 if(IS_WDI_STATUS_FAILURE(status))
8394 {
8395 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8396 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8397 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8398 vos_mem_free(pWdaParams->wdaMsgParam);
8399 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8400 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8401 return CONVERT_WDI2VOS_STATUS(status);
8402
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8403}
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8404
8405#ifdef FEATURE_WLAN_TDLS
8406/*
8407 * FUNCTION: WDA_SetP2PGONOAReqParamsCallback
8408 * Free the memory. No need to send any response to PE in this case
8409 */
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8410void WDA_SetTDLSLinkEstablishReqParamsCallback(WDI_SetTdlsLinkEstablishReqResp *wdiSetTdlsLinkEstablishReqRsp,
8411 void* pUserData)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8412{
8413 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8414 tWDA_CbContext *pWDA = NULL;
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8415 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8416
8417
8418 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8419 "<------ %s " ,__func__);
8420 if(NULL == pWdaParams)
8421 {
8422 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8423 "%s: pWdaParams received NULL", __func__);
8424 VOS_ASSERT(0) ;
8425 return ;
8426 }
8427 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
8428
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8429 if (NULL == pWDA)
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8430 {
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8431 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8432 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8433 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8434 vos_mem_free(pWdaParams->wdaMsgParam);
8435 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8436 VOS_ASSERT(0);
8437 return ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8438 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8439
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8440 pTdlsLinkEstablishParams = (tTdlsLinkEstablishParams *)pWdaParams->wdaMsgParam ;
8441 if( NULL == pTdlsLinkEstablishParams )
8442 {
8443 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8444 "%s: pTdlsLinkEstablishParams "
8445 "received NULL " ,__func__);
8446 VOS_ASSERT(0);
8447 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8448 vos_mem_free(pWdaParams);
8449 return ;
8450 }
8451 pTdlsLinkEstablishParams->status = CONVERT_WDI2SIR_STATUS(
8452 wdiSetTdlsLinkEstablishReqRsp->wdiStatus);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8453 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8454 vos_mem_free(pWdaParams);
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8455 /* send response to UMAC*/
8456 WDA_SendMsg(pWDA, WDA_SET_TDLS_LINK_ESTABLISH_REQ_RSP, pTdlsLinkEstablishParams, 0) ;
8457
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8458 return ;
8459}
8460
8461VOS_STATUS WDA_ProcessSetTdlsLinkEstablishReq(tWDA_CbContext *pWDA,
8462 tTdlsLinkEstablishParams *pTdlsLinkEstablishParams)
8463{
8464 WDI_Status status = WDI_STATUS_SUCCESS ;
8465 WDI_SetTDLSLinkEstablishReqParamsType *wdiSetTDLSLinkEstablishReqParam =
8466 (WDI_SetTDLSLinkEstablishReqParamsType *)vos_mem_malloc(
8467 sizeof(WDI_SetTDLSLinkEstablishReqParamsType)) ;
8468 tWDA_ReqParams *pWdaParams = NULL;
8469 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8470 "------> %s " ,__func__);
8471 if(NULL == wdiSetTDLSLinkEstablishReqParam)
8472 {
8473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8474 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]8475 vos_mem_free(pTdlsLinkEstablishParams);
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8476 VOS_ASSERT(0);
8477 return VOS_STATUS_E_NOMEM;
8478 }
8479 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8480 if(NULL == pWdaParams)
8481 {
8482 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8483 "%s: VOS MEM Alloc Failure", __func__);
8484 vos_mem_free(pTdlsLinkEstablishParams);
8485 vos_mem_free(wdiSetTDLSLinkEstablishReqParam);
8486 VOS_ASSERT(0);
8487 return VOS_STATUS_E_NOMEM;
8488 }
8489 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uStaIdx =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8490 pTdlsLinkEstablishParams->staIdx;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8491 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsResponder =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8492 pTdlsLinkEstablishParams->isResponder;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8493 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uUapsdQueues =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8494 pTdlsLinkEstablishParams->uapsdQueues;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8495 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uMaxSp =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8496 pTdlsLinkEstablishParams->maxSp;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8497 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsBufSta =
Gopichand Nakkala574f6d12013-06-27 19:38:43 +0530[diff] [blame]8498 pTdlsLinkEstablishParams->isBufsta;
Naresh Jayaramc7cbd782014-02-04 17:38:23 +0530[diff] [blame]8499 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.uIsOffChannelSupported =
8500 pTdlsLinkEstablishParams->isOffChannelSupported;
8501
8502 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannels,
8503 pTdlsLinkEstablishParams->validChannels,
8504 pTdlsLinkEstablishParams->validChannelsLen);
8505
8506 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validChannelsLen =
8507 pTdlsLinkEstablishParams->validChannelsLen;
8508
8509 vos_mem_copy(wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClasses,
8510 pTdlsLinkEstablishParams->validOperClasses,
8511 pTdlsLinkEstablishParams->validOperClassesLen);
8512 wdiSetTDLSLinkEstablishReqParam->wdiTDLSLinkEstablishInfo.validOperClassesLen =
8513 pTdlsLinkEstablishParams->validOperClassesLen;
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8514
8515 wdiSetTDLSLinkEstablishReqParam->wdiReqStatusCB = NULL ;
8516 /* Store msg pointer from PE, as this will be used for response */
8517 pWdaParams->wdaMsgParam = (void *)pTdlsLinkEstablishParams ;
8518 /* store Params pass it to WDI */
8519 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSLinkEstablishReqParam ;
8520 pWdaParams->pWdaContext = pWDA;
8521
8522 status = WDI_SetTDLSLinkEstablishReq(wdiSetTDLSLinkEstablishReqParam,
8523 (WDI_SetTDLSLinkEstablishReqParamsRspCb)
8524 WDA_SetTDLSLinkEstablishReqParamsCallback,
8525 pWdaParams);
8526 if(IS_WDI_STATUS_FAILURE(status))
8527 {
8528 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8529 "Failure in Set P2P GO NOA Req WDI API, free all the memory " );
8530 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8531 vos_mem_free(pWdaParams->wdaMsgParam);
8532 vos_mem_free(pWdaParams);
8533 }
8534 return CONVERT_WDI2VOS_STATUS(status);
8535}
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8536
8537// tdlsoffchan
8538void WDA_SetTDLSChanSwitchReqParamsCallback(WDI_SetTdlsChanSwitchReqResp *wdiSetTdlsChanSwitchReqRsp,
8539 void* pUserData)
8540{
8541 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
8542 tWDA_CbContext *pWDA = NULL;
8543 tTdlsChanSwitchParams *pTdlsChanSwitchParams;
8544
8545
8546 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8547 "<------ %s " ,__func__);
8548 if(NULL == pWdaParams)
8549 {
8550 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8551 "%s: pWdaParams received NULL", __func__);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8552 VOS_ASSERT(0) ;
8553 return ;
8554 }
8555 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
8556
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8557 if (NULL == pWDA)
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]8558 {
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8559 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8560 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8561 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8562 vos_mem_free(pWdaParams->wdaMsgParam);
8563 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8564 VOS_ASSERT(0);
8565 return ;
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]8566 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8567
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8568 pTdlsChanSwitchParams = (tTdlsChanSwitchParams *)pWdaParams->wdaMsgParam ;
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]8569 if( NULL == pTdlsChanSwitchParams )
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8570 {
8571 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8572 "%s: pTdlsChanSwitchParams "
8573 "received NULL " ,__func__);
8574 VOS_ASSERT(0);
8575 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8576 vos_mem_free(pWdaParams);
8577 return ;
8578 }
8579 pTdlsChanSwitchParams->status = CONVERT_WDI2SIR_STATUS(
8580 wdiSetTdlsChanSwitchReqRsp->wdiStatus);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8581 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8582 vos_mem_free(pWdaParams);
Atul Mittal60bd4292014-08-14 12:19:27 +0530[diff] [blame]8583 /* send response to UMAC*/
8584 WDA_SendMsg(pWDA, WDA_SET_TDLS_CHAN_SWITCH_REQ_RSP, pTdlsChanSwitchParams, 0) ;
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8585
8586 return ;
8587}
8588VOS_STATUS WDA_ProcessSetTdlsChanSwitchReq(tWDA_CbContext *pWDA,
8589 tTdlsChanSwitchParams *pTdlsChanSwitchParams)
8590{
8591 WDI_Status status = WDI_STATUS_SUCCESS ;
8592 WDI_SetTDLSChanSwitchReqParamsType *wdiSetTDLSChanSwitchReqParam =
8593 (WDI_SetTDLSChanSwitchReqParamsType *)vos_mem_malloc(
8594 sizeof(WDI_SetTDLSChanSwitchReqParamsType));
8595 tWDA_ReqParams *pWdaParams = NULL;
8596
8597 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8598 "Enter: %s ",__func__);
8599 if(NULL == wdiSetTDLSChanSwitchReqParam)
8600 {
8601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8602 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]8603 vos_mem_free(pTdlsChanSwitchParams);
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]8604 VOS_ASSERT(0);
8605 return VOS_STATUS_E_NOMEM;
8606 }
8607
8608 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
8609 if(NULL == pWdaParams)
8610 {
8611 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8612 "%s: VOS MEM Alloc Failure", __func__);
8613 vos_mem_free(pTdlsChanSwitchParams);
8614 vos_mem_free(wdiSetTDLSChanSwitchReqParam);
8615 VOS_ASSERT(0);
8616 return VOS_STATUS_E_NOMEM;
8617 }
8618 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.staIdx =
8619 pTdlsChanSwitchParams->staIdx;
8620 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.isOffchannelInitiator =
8621 pTdlsChanSwitchParams->tdlsSwMode;
8622 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetOperClass =
8623 pTdlsChanSwitchParams->operClass;
8624 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.targetChannel =
8625 pTdlsChanSwitchParams->tdlsOffCh;
8626 wdiSetTDLSChanSwitchReqParam->wdiTDLSChanSwitchReqInfo.secondaryChannelOffset =
8627 pTdlsChanSwitchParams->tdlsOffChBwOffset;
8628
8629
8630 /* Store msg pointer from PE, as this will be used for response */
8631 pWdaParams->wdaMsgParam = (void *)pTdlsChanSwitchParams ;
8632 /* store Params pass it to WDI */
8633 pWdaParams->wdaWdiApiMsgParam = (void *)wdiSetTDLSChanSwitchReqParam ;
8634 pWdaParams->pWdaContext = pWDA;
8635 status = WDI_SetTDLSChanSwitchReq(wdiSetTDLSChanSwitchReqParam,
8636 (WDI_SetTDLSChanSwitchReqParamsRspCb)
8637 WDA_SetTDLSChanSwitchReqParamsCallback,
8638 pWdaParams);
8639 if(IS_WDI_STATUS_FAILURE(status))
8640 {
8641 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8642 "Failure in TDLS Channel Switch Req WDI API, free all the memory" );
8643 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8644 vos_mem_free(pWdaParams->wdaMsgParam);
8645 vos_mem_free(pWdaParams);
8646 }
8647 return CONVERT_WDI2VOS_STATUS(status);
8648}
8649#endif /*FEATURE_WLAN_TDLS*/
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]8650
8651
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8652#ifdef WLAN_FEATURE_VOWIFI_11R
8653/*
8654 * FUNCTION: WDA_AggrAddTSReqCallback
8655 * send ADD AGGREGATED TS RSP back to PE
8656 */
8657void WDA_AggrAddTSReqCallback(WDI_Status status, void* pUserData)
8658{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8659 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8660 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8661 tAggrAddTsParams *pAggrAddTsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8662 int i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8664 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8665 if(NULL == pWdaParams)
8666 {
8667 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8668 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8669 VOS_ASSERT(0) ;
8670 return ;
8671 }
8672
8673 pWDA = pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8674 if (NULL == pWDA)
8675 {
8676 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8677 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8678 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8679 vos_mem_free(pWdaParams->wdaMsgParam);
8680 vos_mem_free(pWdaParams);
8681
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8682 VOS_ASSERT(0);
8683 return ;
8684 }
8685
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8686 pAggrAddTsReqParams = (tAggrAddTsParams *)pWdaParams->wdaMsgParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8687
8688 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
8689 {
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8690 pAggrAddTsReqParams->status[i] = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8691 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8692 WDA_SendMsg(pWDA, WDA_AGGR_QOS_RSP, (void *)pAggrAddTsReqParams , 0) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8693
8694 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8695 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8696 return ;
8697}/* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8698/*
8699 * FUNCTION: WDA_ProcessAddTSReq
8700 * Request to WDI to send an update with AGGREGATED ADD TS REQ params.
8701 */
8702VOS_STATUS WDA_ProcessAggrAddTSReq(tWDA_CbContext *pWDA,
8703 tAggrAddTsParams *pAggrAddTsReqParams)
8704{
8705 WDI_Status status = WDI_STATUS_SUCCESS ;
8706 int i;
8707 WDI_AggrAddTSReqParamsType *wdiAggrAddTSReqParam;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8708 tWDA_ReqParams *pWdaParams = NULL;
8709
8710
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8712 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8713 wdiAggrAddTSReqParam = (WDI_AggrAddTSReqParamsType *)vos_mem_malloc(
8714 sizeof(WDI_AggrAddTSReqParamsType)) ;
8715 if(NULL == wdiAggrAddTSReqParam)
8716 {
8717 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8718 "%s: VOS MEM Alloc Failure", __func__);
Ratheesh S P62439fe2015-06-11 15:53:31 +0530[diff] [blame]8719 vos_mem_free(pAggrAddTsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8720 VOS_ASSERT(0);
8721 return VOS_STATUS_E_NOMEM;
8722 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8723
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__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8730 vos_mem_free(pAggrAddTsReqParams);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]8731 vos_mem_free(wdiAggrAddTSReqParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8732 VOS_ASSERT(0);
8733 return VOS_STATUS_E_NOMEM;
8734 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8735 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucSTAIdx = pAggrAddTsReqParams->staIdx;
8736 wdiAggrAddTSReqParam->wdiAggrTsInfo.ucTspecIdx =
8737 pAggrAddTsReqParams->tspecIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8738 for( i = 0; i < WDI_MAX_NO_AC; i++ )
8739 {
8740 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucType = pAggrAddTsReqParams->tspec[i].type;
8741 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].ucLength =
8742 pAggrAddTsReqParams->tspec[i].length;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8743 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.ackPolicy =
8744 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.ackPolicy;
8745 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.userPrio =
8746 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.userPrio;
8747 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.psb =
8748 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.psb;
8749 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.aggregation =
8750 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.aggregation;
8751 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.accessPolicy =
8752 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.accessPolicy;
8753 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.direction =
8754 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.direction;
8755 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.tsid =
8756 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.tsid;
8757 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiTraffic.trafficType =
8758 pAggrAddTsReqParams->tspec[i].tsinfo.traffic.trafficType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8759 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].wdiTSinfo.wdiSchedule.schedule =
8760 pAggrAddTsReqParams->tspec[i].tsinfo.schedule.schedule;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8761 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usNomMsduSz =
8762 pAggrAddTsReqParams->tspec[i].nomMsduSz;
8763 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMaxMsduSz =
8764 pAggrAddTsReqParams->tspec[i].maxMsduSz;
8765 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinSvcInterval =
8766 pAggrAddTsReqParams->tspec[i].minSvcInterval;
8767 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxSvcInterval =
8768 pAggrAddTsReqParams->tspec[i].maxSvcInterval;
8769 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uInactInterval =
8770 pAggrAddTsReqParams->tspec[i].inactInterval;
8771 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSuspendInterval =
8772 pAggrAddTsReqParams->tspec[i].suspendInterval;
8773 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uSvcStartTime =
8774 pAggrAddTsReqParams->tspec[i].svcStartTime;
8775 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinDataRate =
8776 pAggrAddTsReqParams->tspec[i].minDataRate;
8777 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMeanDataRate =
8778 pAggrAddTsReqParams->tspec[i].meanDataRate;
8779 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uPeakDataRate =
8780 pAggrAddTsReqParams->tspec[i].peakDataRate;
8781 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMaxBurstSz =
8782 pAggrAddTsReqParams->tspec[i].maxBurstSz;
8783 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uDelayBound =
8784 pAggrAddTsReqParams->tspec[i].delayBound;
8785 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].uMinPhyRate =
8786 pAggrAddTsReqParams->tspec[i].minPhyRate;
8787 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usSurplusBw =
8788 pAggrAddTsReqParams->tspec[i].surplusBw;
8789 wdiAggrAddTSReqParam->wdiAggrTsInfo.wdiTspecIE[i].usMediumTime =
8790 pAggrAddTsReqParams->tspec[i].mediumTime;
8791 }
8792
8793 /* TODO: tAggrAddTsParams doesn't have the following fields */
8794#if 0
8795 wdiAggrAddTSReqParam->wdiTsInfo.ucUapsdFlags =
8796 wdiAggrAddTSReqParam->wdiTsInfo.ucServiceInterval =
8797 wdiAggrAddTSReqParam->wdiTsInfo.ucSuspendInterval =
8798 wdiAggrAddTSReqParam->wdiTsInfo.ucDelayedInterval =
8799#endif
8800 wdiAggrAddTSReqParam->wdiReqStatusCB = NULL ;
8801
8802 /* Store ADD TS pointer, as this will be used for response */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8803 pWdaParams->wdaMsgParam = (void *)pAggrAddTsReqParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8804 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8805 pWdaParams->wdaWdiApiMsgParam = (void *)wdiAggrAddTSReqParam ;
8806
8807 pWdaParams->pWdaContext = pWDA;
8808
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8809 status = WDI_AggrAddTSReq(wdiAggrAddTSReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8810 (WDI_AggrAddTsRspCb)WDA_AggrAddTSReqCallback, pWdaParams);
8811
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8812 if(IS_WDI_STATUS_FAILURE(status))
8813 {
8814 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8815 "Failure in ADD TS REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]8816 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
8817 vos_mem_free(pWdaParams);
8818
8819 /* send the failure response back to PE*/
8820 for( i = 0; i < HAL_QOS_NUM_AC_MAX; i++ )
8821 {
8822 pAggrAddTsReqParams->status[i] = eHAL_STATUS_FAILURE ;
8823 }
8824
8825 WDA_SendMsg(pWdaParams->pWdaContext, WDA_AGGR_QOS_RSP,
8826 (void *)pAggrAddTsReqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8827 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8828 return CONVERT_WDI2VOS_STATUS(status) ;
8829}
8830#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8831/*
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8832 * FUNCTION: WDA_EnterImpsRspCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8833 * send Enter IMPS RSP back to PE
8834 */
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8835void WDA_EnterImpsRspCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8836{
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8837 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8838 tWDA_CbContext *pWDA = NULL;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8839
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8840 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8841 "<------ %s status=%d" ,__func__,status);
8842 if(NULL == pWdaParams)
8843 {
8844 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8845 "%s: pWdaParams received NULL", __func__);
8846 VOS_ASSERT(0);
8847 return;
8848 }
8849
8850 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8851 if (NULL == pWDA)
8852 {
8853 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8854 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8855 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8856 vos_mem_free(pWdaParams->wdaMsgParam);
8857 vos_mem_free(pWdaParams);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8858 VOS_ASSERT(0);
8859 return ;
8860 }
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8861
8862 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8863 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]8864 if (WDI_STATUS_SUCCESS != status)
8865 {
8866 pWDA->failureCounts.enterImpsFailureCount++;
8867 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
8868 pWDA->failureCounts.enterImpsFailureCount)
8869 {
8870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8871 "%s: Status %d fail count %d", __func__, status,
8872 pWDA->failureCounts.enterImpsFailureCount);
8873 pWDA->failureCounts.enterImpsFailureCount = 0;
8874 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
8875 WLAN_LOG_INDICATOR_HOST_DRIVER,
8876 WLAN_LOG_REASON_ENTER_IMPS_BMPS_FAIL,
8877 FALSE, TRUE);
8878 }
8879 }
8880 else
8881 {
8882 pWDA->failureCounts.enterImpsFailureCount = 0;
8883 }
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]8884 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8885 return ;
8886}
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8887
8888
8889/*
8890 * FUNCTION: WDA_EnterImpsReqCallback
8891 * Free memory and send Enter IMPS RSP back to PE.
8892 * Invoked when Enter IMPS REQ failed in WDI and no RSP callback is generated.
8893 */
8894void WDA_EnterImpsReqCallback(WDI_Status wdiStatus, void* pUserData)
8895{
8896 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8897 tWDA_CbContext *pWDA = NULL;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8898
8899 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
8900 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
8901
8902 if(NULL == pWdaParams)
8903 {
8904 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8905 "%s: pWdaParams received NULL", __func__);
8906 VOS_ASSERT(0);
8907 return;
8908 }
8909
8910 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8911 if (NULL == pWDA)
8912 {
8913 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8914 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]8915 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8916 vos_mem_free(pWdaParams->wdaMsgParam);
8917 vos_mem_free(pWdaParams);
8918
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]8919 VOS_ASSERT(0);
8920 return ;
8921 }
8922
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8923
8924 if(IS_WDI_STATUS_FAILURE(wdiStatus))
8925 {
8926 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
8927 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]8928 pWDA->failureCounts.enterImpsFailureCount++;
8929 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
8930 pWDA->failureCounts.enterImpsFailureCount)
8931 {
8932 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8933 "%s: wdiStatus %d fail count %d", __func__, wdiStatus,
8934 pWDA->failureCounts.enterImpsFailureCount);
8935 pWDA->failureCounts.enterImpsFailureCount = 0;
8936 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
8937 WLAN_LOG_INDICATOR_HOST_DRIVER,
8938 WLAN_LOG_REASON_ENTER_IMPS_BMPS_FAIL,
8939 FALSE, TRUE);
8940 }
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8941 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
8942 CONVERT_WDI2SIR_STATUS(wdiStatus));
8943 }
8944
8945 return;
8946}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8947/*
8948 * FUNCTION: WDA_ProcessEnterImpsReq
8949 * Request to WDI to Enter IMPS power state.
8950 */
8951VOS_STATUS WDA_ProcessEnterImpsReq(tWDA_CbContext *pWDA)
8952{
8953 WDI_Status status = WDI_STATUS_SUCCESS ;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8954 WDI_EnterImpsReqParamsType *wdiEnterImpsReqParams;
8955 tWDA_ReqParams *pWdaParams;
Sushant Kaushik7438e252015-05-01 14:55:09 +0530[diff] [blame]8956 static int failcnt = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8957 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]8958 "------> %s " ,__func__);
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]8959
8960
8961 wdiEnterImpsReqParams = vos_mem_malloc(sizeof(WDI_EnterImpsReqParamsType));
8962 if (NULL == wdiEnterImpsReqParams)
8963 {
8964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8965 "%s: VOS MEM Alloc Failure", __func__);
8966 VOS_ASSERT(0);
8967 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL,
8968 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
8969 return VOS_STATUS_E_NOMEM;
8970 }
8971
8972 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
8973 if (NULL == pWdaParams)
8974 {
8975 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8976 "%s: VOS MEM Alloc Failure", __func__);
8977 VOS_ASSERT(0);
8978 vos_mem_free(wdiEnterImpsReqParams);
8979 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL ,
8980 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
8981 return VOS_STATUS_E_NOMEM;
8982 }
8983
8984 wdiEnterImpsReqParams->wdiReqStatusCB = WDA_EnterImpsReqCallback;
8985 wdiEnterImpsReqParams->pUserData = pWdaParams;
8986
8987 pWdaParams->wdaWdiApiMsgParam = wdiEnterImpsReqParams;
8988 pWdaParams->wdaMsgParam = NULL;
8989 pWdaParams->pWdaContext = pWDA;
8990
8991 status = WDI_EnterImpsReq(wdiEnterImpsReqParams,
8992 (WDI_EnterImpsRspCb)WDA_EnterImpsRspCallback,
8993 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]8994 if(IS_WDI_STATUS_FAILURE(status))
8995 {
Sushant Kaushik7438e252015-05-01 14:55:09 +0530[diff] [blame]8996 if (! (failcnt & 0xF))
8997 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
8998 "Failure in Enter IMPS REQ WDI API, free all the memory " );
8999 failcnt++;
Mihir Shetea4306052014-03-25 00:02:54 +0530[diff] [blame]9000 vos_mem_free(wdiEnterImpsReqParams);
9001 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9002 WDA_SendMsg(pWDA, WDA_ENTER_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9003 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9004 return CONVERT_WDI2VOS_STATUS(status) ;
9005}
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9006
9007/*
9008 * FUNCTION: WDA_ExitImpsRespCallback
9009 * send Exit IMPS RSP back to PE
9010 */
9011void WDA_ExitImpsRespCallback(WDI_Status status, void* pUserData)
9012{
9013 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9014 tWDA_CbContext *pWDA;
9015
9016 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9017 "<------ %s " ,__func__);
9018
9019 if (NULL == pWdaParams)
9020 {
9021 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9022 "%s: pWdaParams received NULL", __func__);
9023 VOS_ASSERT(0);
9024 return;
9025 }
9026 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
9027
9028 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9029 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]9030 if (WDI_STATUS_SUCCESS != status)
9031 {
9032 pWDA->failureCounts.exitImpsFailureCount++;
9033 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9034 pWDA->failureCounts.exitImpsFailureCount)
9035 {
9036 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9037 "%s: Status %d fail count %d", __func__,
9038 status,
9039 pWDA->failureCounts.exitImpsFailureCount);
9040 pWDA->failureCounts.exitImpsFailureCount = 0;
9041 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9042 WLAN_LOG_INDICATOR_HOST_DRIVER,
9043 WLAN_LOG_REASON_EXIT_IMPS_BMPS_FAIL,
9044 FALSE, TRUE);
9045 }
9046 }
9047 else
9048 {
9049 pWDA->failureCounts.exitImpsFailureCount = 0;
9050 }
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9051
9052 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , (status));
9053 return;
9054}
9055
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9056/*
9057 * FUNCTION: WDA_ExitImpsReqCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9058 */
9059void WDA_ExitImpsReqCallback(WDI_Status status, void* pUserData)
9060{
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9061 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]9062 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9063 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9064 "<------ %s " ,__func__);
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9065 if(NULL == pWdaParams)
9066 {
9067 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9068 "%s: pWdaParams received NULL", __func__);
9069 VOS_ASSERT(0);
9070 return;
9071 }
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]9072 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9073 if (IS_WDI_STATUS_FAILURE(status))
9074 {
9075 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9076 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]9077
9078 pWDA->failureCounts.exitImpsFailureCount++;
9079 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9080 pWDA->failureCounts.exitImpsFailureCount)
9081 {
9082 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9083 "%s: wdiStatus %d fail count %d", __func__,
9084 status,
9085 pWDA->failureCounts.exitImpsFailureCount);
9086 pWDA->failureCounts.exitImpsFailureCount = 0;
9087 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9088 WLAN_LOG_INDICATOR_HOST_DRIVER,
9089 WLAN_LOG_REASON_EXIT_IMPS_BMPS_FAIL,
9090 FALSE, TRUE);
9091 }
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9092 if (WDI_STATUS_DEV_INTERNAL_FAILURE == status)
9093 {
9094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9095 FL("reload wlan driver"));
9096 wpalWlanReload();
9097 }
9098 }
9099 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9100}
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9101
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9102/*
9103 * FUNCTION: WDA_ProcessExitImpsReq
9104 * Request to WDI to Exit IMPS power state.
9105 */
9106VOS_STATUS WDA_ProcessExitImpsReq(tWDA_CbContext *pWDA)
9107{
9108 WDI_Status status = WDI_STATUS_SUCCESS ;
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9109 tWDA_ReqParams *pWdaParams;
9110 WDI_ExitImpsReqParamsType *wdiExitImpsReqParams;
9111
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9113 "------> %s " ,__func__);
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9114 wdiExitImpsReqParams = (WDI_ExitImpsReqParamsType *)vos_mem_malloc(
9115 sizeof(WDI_ExitImpsReqParamsType));
9116 if (NULL == wdiExitImpsReqParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9117 {
Mahesh A Saptasagar329813b2014-12-15 12:16:51 +0530[diff] [blame]9118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9119 "%s: VOS MEM Alloc Failure", __func__);
9120 VOS_ASSERT(0);
9121 return VOS_STATUS_E_NOMEM;
9122 }
9123 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
9124 if(NULL == pWdaParams)
9125 {
9126 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9127 "%s: VOS MEM Alloc Failure", __func__);
9128 VOS_ASSERT(0);
9129 vos_mem_free(wdiExitImpsReqParams);
9130 return VOS_STATUS_E_NOMEM;
9131 }
9132 wdiExitImpsReqParams->wdiReqStatusCB = WDA_ExitImpsReqCallback;
9133 wdiExitImpsReqParams->pUserData = pWdaParams;
9134
9135 /* Store param pointer as passed in by caller */
9136 /* store Params pass it to WDI */
9137 pWdaParams->wdaWdiApiMsgParam = wdiExitImpsReqParams;
9138 pWdaParams->pWdaContext = pWDA;
9139 pWdaParams->wdaMsgParam = wdiExitImpsReqParams;
9140 status = WDI_ExitImpsReq(wdiExitImpsReqParams,
9141 (WDI_ExitImpsRspCb)WDA_ExitImpsRespCallback,
9142 pWdaParams);
9143 if (IS_WDI_STATUS_FAILURE(status))
9144 {
9145 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9146 "Failure in Exit IMPS REQ WDI API, free all the memory " );
9147 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9148 vos_mem_free(pWdaParams);
9149 WDA_SendMsg(pWDA, WDA_EXIT_IMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9150 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9151 return CONVERT_WDI2VOS_STATUS(status) ;
9152}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9153/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9154 * FUNCTION: WDA_EnterBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9155 * send Enter BMPS RSP back to PE
9156 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9157void WDA_EnterBmpsRespCallback(WDI_EnterBmpsRspParamsType *pwdiEnterBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9158{
9159 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9160 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9161 tEnterBmpsParams *pEnterBmpsRspParams;
9162
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9163 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9164 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9165 if(NULL == pWdaParams)
9166 {
9167 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9168 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9169 VOS_ASSERT(0) ;
9170 return ;
9171 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9172
9173 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9174 if (NULL == pWDA)
9175 {
9176 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9177 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]9178
9179 if(pWdaParams->wdaWdiApiMsgParam)
9180 {
9181 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9182 }
9183 vos_mem_free(pWdaParams);
9184
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9185 VOS_ASSERT(0);
9186 return ;
9187 }
9188
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9189 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
9190
9191 pEnterBmpsRspParams->bssIdx = pwdiEnterBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9192 pEnterBmpsRspParams->status = (pwdiEnterBmpsRsp->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9193
9194 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9195 vos_mem_free(pWdaParams) ;
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]9196 if (eHAL_STATUS_SUCCESS != pEnterBmpsRspParams->status)
9197 {
9198 pWDA->failureCounts.enterBmpsFailureCount++;
9199 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9200 pWDA->failureCounts.enterBmpsFailureCount)
9201 {
9202 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9203 "%s: wdiStatus %d fail count %d", __func__,
9204 pwdiEnterBmpsRsp->wdiStatus,
9205 pWDA->failureCounts.enterBmpsFailureCount);
9206 pWDA->failureCounts.enterBmpsFailureCount = 0;
9207 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9208 WLAN_LOG_INDICATOR_HOST_DRIVER,
9209 WLAN_LOG_REASON_ENTER_IMPS_BMPS_FAIL,
9210 FALSE, TRUE);
9211 }
9212 }
9213 else
9214 {
9215 pWDA->failureCounts.enterBmpsFailureCount = 0;
9216 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9217 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams , 0);
9218
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9219 return ;
9220}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9221/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9222 * FUNCTION: WDA_EnterBmpsReqCallback
9223 * Free memory and send Enter BMPS RSP back to PE.
9224 * Invoked when Enter BMPS REQ failed in WDI and no RSP callback is generated.
9225 */
9226void WDA_EnterBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
9227{
9228 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9229 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9230 tEnterBmpsParams *pEnterBmpsRspParams;
9231
9232 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9233 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9234
9235 if(NULL == pWdaParams)
9236 {
9237 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9238 "%s: pWdaParams received NULL", __func__);
9239 VOS_ASSERT(0);
9240 return;
9241 }
9242
9243 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9244 if (NULL == pWDA)
9245 {
9246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9247 "%s:pWDA is NULL", __func__);
9248 VOS_ASSERT(0);
9249 return ;
9250 }
9251
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9252 pEnterBmpsRspParams = (tEnterBmpsParams *)pWdaParams->wdaMsgParam;
9253 pEnterBmpsRspParams->status = wdiStatus;
9254
9255 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9256 {
9257 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9258 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]9259 pWDA->failureCounts.enterBmpsFailureCount++;
9260 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9261 pWDA->failureCounts.enterBmpsFailureCount)
9262 {
9263 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9264 "%s: wdiStatus %d fail count %d", __func__,
9265 wdiStatus,
9266 pWDA->failureCounts.enterBmpsFailureCount);
9267 pWDA->failureCounts.enterBmpsFailureCount = 0;
9268 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9269 WLAN_LOG_INDICATOR_HOST_DRIVER,
9270 WLAN_LOG_REASON_ENTER_IMPS_BMPS_FAIL,
9271 FALSE, TRUE);
9272 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9273 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, (void *)pEnterBmpsRspParams, 0);
9274 }
9275
9276 return;
9277}
9278/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9279 * FUNCTION: WDA_ProcessEnterBmpsReq
9280 * Request to WDI to Enter BMPS power state.
9281 */
9282VOS_STATUS WDA_ProcessEnterBmpsReq(tWDA_CbContext *pWDA,
9283 tEnterBmpsParams *pEnterBmpsReqParams)
9284{
9285 WDI_Status status = WDI_STATUS_SUCCESS;
9286 WDI_EnterBmpsReqParamsType *wdiEnterBmpsReqParams;
9287 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9288 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9289 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9290 if ((NULL == pWDA) || (NULL == pEnterBmpsReqParams))
9291 {
9292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9293 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9294 VOS_ASSERT(0);
9295 return VOS_STATUS_E_FAILURE;
9296 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9297 wdiEnterBmpsReqParams = vos_mem_malloc(sizeof(WDI_EnterBmpsReqParamsType));
9298 if (NULL == wdiEnterBmpsReqParams)
9299 {
9300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9301 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9302 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9303 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
9304 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9305 return VOS_STATUS_E_NOMEM;
9306 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9307 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
9308 if (NULL == pWdaParams)
9309 {
9310 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9311 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9312 VOS_ASSERT(0);
9313 vos_mem_free(wdiEnterBmpsReqParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9314 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL ,
9315 CONVERT_WDI2SIR_STATUS(WDI_STATUS_MEM_FAILURE)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9316 return VOS_STATUS_E_NOMEM;
9317 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9318 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucBssIdx = pEnterBmpsReqParams->bssIdx;
9319 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimCount = pEnterBmpsReqParams->dtimCount;
9320 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.ucDtimPeriod = pEnterBmpsReqParams->dtimPeriod;
9321 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.uTbtt = pEnterBmpsReqParams->tbtt;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]9322 // For ESE and 11R Roaming
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9323 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.rssiFilterPeriod = (wpt_uint32)pEnterBmpsReqParams->rssiFilterPeriod;
9324 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.numBeaconPerRssiAverage = (wpt_uint32)pEnterBmpsReqParams->numBeaconPerRssiAverage;
9325 wdiEnterBmpsReqParams->wdiEnterBmpsInfo.bRssiFilterEnable = (wpt_uint8)pEnterBmpsReqParams->bRssiFilterEnable;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9326 wdiEnterBmpsReqParams->wdiReqStatusCB = WDA_EnterBmpsReqCallback;
9327 wdiEnterBmpsReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9328
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9329 /* Store param pointer as passed in by caller */
9330 /* store Params pass it to WDI */
9331 pWdaParams->wdaWdiApiMsgParam = wdiEnterBmpsReqParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9332 pWdaParams->wdaMsgParam = pEnterBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9333 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9334 status = WDI_EnterBmpsReq(wdiEnterBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9335 (WDI_EnterBmpsRspCb)WDA_EnterBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9336 if (IS_WDI_STATUS_FAILURE(status))
9337 {
9338 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9339 "Failure in Enter BMPS REQ WDI API, free all the memory" );
9340 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]9341 vos_mem_free(pWdaParams->wdaMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9342 vos_mem_free(pWdaParams);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9343 WDA_SendMsg(pWDA, WDA_ENTER_BMPS_RSP, NULL , CONVERT_WDI2SIR_STATUS(status)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9344 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9345 return CONVERT_WDI2VOS_STATUS(status);
9346}
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9347
9348
9349static void WDA_SendExitBmpsRsp(tWDA_CbContext *pWDA,
9350 WDI_Status wdiStatus,
9351 tExitBmpsParams *pExitBmpsReqParams)
9352{
9353 pExitBmpsReqParams->status = CONVERT_WDI2SIR_STATUS(wdiStatus) ;
9354
9355 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsReqParams , 0) ;
9356}
9357
9358
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9359/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9360 * FUNCTION: WDA_ExitBmpsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9361 * send Exit BMPS RSP back to PE
9362 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9363void WDA_ExitBmpsRespCallback(WDI_ExitBmpsRspParamsType *pwdiExitBmpsRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9364{
9365 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9366 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9367 tExitBmpsParams *pExitBmpsRspParams;
9368
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9369 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9370 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9371 if(NULL == pWdaParams)
9372 {
9373 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9374 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9375 VOS_ASSERT(0) ;
9376 return ;
9377 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9378
9379 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9380 if (NULL == pWDA)
9381 {
9382 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9383 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]9384
9385 if(pWdaParams->wdaWdiApiMsgParam)
9386 {
9387 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9388 }
9389 vos_mem_free(pWdaParams);
9390
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9391 VOS_ASSERT(0);
9392 return ;
9393 }
9394
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9395 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
9396
9397 pExitBmpsRspParams->bssIdx = pwdiExitBmpsRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9398 pExitBmpsRspParams->status = (pwdiExitBmpsRsp->wdiStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9399
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9400 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]9401 vos_mem_free(pWdaParams);
9402
9403 if (WDI_STATUS_SUCCESS != pwdiExitBmpsRsp->wdiStatus)
9404 {
9405 pWDA->failureCounts.exitBmpsFailureCount++;
9406 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9407 pWDA->failureCounts.exitBmpsFailureCount)
9408 {
9409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9410 "%s: Status %d fail count %d", __func__,
9411 pExitBmpsRspParams->status,
9412 pWDA->failureCounts.exitBmpsFailureCount);
9413 pWDA->failureCounts.exitBmpsFailureCount = 0;
9414 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9415 WLAN_LOG_INDICATOR_HOST_DRIVER,
9416 WLAN_LOG_REASON_EXIT_IMPS_BMPS_FAIL,
9417 FALSE, TRUE);
9418 }
9419 }
9420 else
9421 {
9422 pWDA->failureCounts.exitBmpsFailureCount = 0;
9423 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9424
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9425 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9426 return ;
9427}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9428/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9429 * FUNCTION: WDA_ExitBmpsReqCallback
9430 * Free memory and send Exit BMPS RSP back to PE.
9431 * Invoked when Exit BMPS REQ failed in WDI and no RSP callback is generated.
9432 */
9433void WDA_ExitBmpsReqCallback(WDI_Status wdiStatus, void* pUserData)
9434{
9435 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9436 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9437 tExitBmpsParams *pExitBmpsRspParams;
9438
9439 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9440 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9441
9442 if(NULL == pWdaParams)
9443 {
9444 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9445 "%s: pWdaParams received NULL", __func__);
9446 VOS_ASSERT(0);
9447 return;
9448 }
9449
9450 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9451 if (NULL == pWDA)
9452 {
9453 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9454 "%s:pWDA is NULL", __func__);
9455 VOS_ASSERT(0);
9456 return ;
9457 }
9458
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9459 pExitBmpsRspParams = (tExitBmpsParams *)pWdaParams->wdaMsgParam;
9460 pExitBmpsRspParams->status = wdiStatus;
9461
9462 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9463 {
9464 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9465 vos_mem_free(pWdaParams);
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]9466 pWDA->failureCounts.exitBmpsFailureCount++;
9467 if (BMPS_IMPS_FAILURE_REPORT_THRESHOLD ==
9468 pWDA->failureCounts.exitBmpsFailureCount)
9469 {
9470 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9471 "%s: wdiStatus %d fail count %d", __func__,
9472 wdiStatus,
9473 pWDA->failureCounts.exitBmpsFailureCount);
9474 pWDA->failureCounts.exitBmpsFailureCount = 0;
9475 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
9476 WLAN_LOG_INDICATOR_HOST_DRIVER,
9477 WLAN_LOG_REASON_EXIT_IMPS_BMPS_FAIL,
9478 FALSE, TRUE);
9479 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9480 WDA_SendMsg(pWDA, WDA_EXIT_BMPS_RSP, (void *)pExitBmpsRspParams, 0);
9481 }
9482
9483 return;
9484}
9485/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9486 * FUNCTION: WDA_ProcessExitBmpsReq
9487 * Request to WDI to Exit BMPS power state.
9488 */
9489VOS_STATUS WDA_ProcessExitBmpsReq(tWDA_CbContext *pWDA,
9490 tExitBmpsParams *pExitBmpsReqParams)
9491{
9492 WDI_Status status = WDI_STATUS_SUCCESS ;
9493 WDI_ExitBmpsReqParamsType *wdiExitBmpsReqParams =
9494 (WDI_ExitBmpsReqParamsType *)vos_mem_malloc(
9495 sizeof(WDI_ExitBmpsReqParamsType)) ;
9496 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9498 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9499 if(NULL == wdiExitBmpsReqParams)
9500 {
9501 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9502 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9503 VOS_ASSERT(0);
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9504 WDA_SendExitBmpsRsp(pWDA, WDI_STATUS_MEM_FAILURE, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9505 return VOS_STATUS_E_NOMEM;
9506 }
9507 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9508 if(NULL == pWdaParams)
9509 {
9510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9511 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9512 VOS_ASSERT(0);
9513 vos_mem_free(wdiExitBmpsReqParams);
9514 return VOS_STATUS_E_NOMEM;
9515 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9516 wdiExitBmpsReqParams->wdiExitBmpsInfo.ucSendDataNull = pExitBmpsReqParams->sendDataNull;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]9517
9518 wdiExitBmpsReqParams->wdiExitBmpsInfo.bssIdx = pExitBmpsReqParams->bssIdx;
9519
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9520 wdiExitBmpsReqParams->wdiReqStatusCB = WDA_ExitBmpsReqCallback;
9521 wdiExitBmpsReqParams->pUserData = pWdaParams;
9522
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9523 /* Store param pointer as passed in by caller */
9524 /* store Params pass it to WDI */
9525 pWdaParams->wdaWdiApiMsgParam = wdiExitBmpsReqParams;
9526 pWdaParams->pWdaContext = pWDA;
9527 pWdaParams->wdaMsgParam = pExitBmpsReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9528 status = WDI_ExitBmpsReq(wdiExitBmpsReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9529 (WDI_ExitBmpsRspCb)WDA_ExitBmpsRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9530 if(IS_WDI_STATUS_FAILURE(status))
9531 {
9532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9533 "Failure in Exit BMPS REQ WDI API, free all the memory " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9534 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9535 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]9536 WDA_SendExitBmpsRsp(pWDA, status, pExitBmpsReqParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9537 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9538 return CONVERT_WDI2VOS_STATUS(status) ;
9539}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9540/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9541 * FUNCTION: WDA_EnterUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9542 * send Enter UAPSD RSP back to PE
9543 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9544void WDA_EnterUapsdRespCallback( WDI_EnterUapsdRspParamsType *pwdiEnterUapsdRspParams, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9545{
9546 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9547 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9548 tUapsdParams *pEnterUapsdRsqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9549 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9550 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9551 if(NULL == pWdaParams)
9552 {
9553 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9554 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9555 VOS_ASSERT(0) ;
9556 return ;
9557 }
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9558
9559 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9560 if (NULL == pWDA)
9561 {
9562 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9563 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]9564
9565 if(pWdaParams->wdaWdiApiMsgParam)
9566 {
9567 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9568 }
9569 vos_mem_free(pWdaParams);
9570
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9571 VOS_ASSERT(0);
9572 return ;
9573 }
9574
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9575 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
9576
9577 pEnterUapsdRsqParams->bssIdx = pwdiEnterUapsdRspParams->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9578 pEnterUapsdRsqParams->status = (pwdiEnterUapsdRspParams->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9579
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9580 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9581 vos_mem_free(pWdaParams) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9582 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9583 return ;
9584}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9585/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9586 * FUNCTION: WDA_EnterUapsdReqCallback
9587 * Free memory and send Enter UAPSD RSP back to PE.
9588 * Invoked when Enter UAPSD REQ failed in WDI and no RSP callback is generated.
9589 */
9590void WDA_EnterUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
9591{
9592 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9593 tWDA_CbContext *pWDA;
9594 tUapsdParams *pEnterUapsdRsqParams;
9595
9596 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9597 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9598
9599 if(NULL == pWdaParams)
9600 {
9601 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9602 "%s: pWdaParams received NULL", __func__);
9603 VOS_ASSERT(0);
9604 return;
9605 }
9606
9607 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9608 if (NULL == pWDA)
9609 {
9610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9611 "%s:pWDA is NULL", __func__);
9612 VOS_ASSERT(0);
9613 return ;
9614 }
9615
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9616 pEnterUapsdRsqParams = (tUapsdParams *)pWdaParams->wdaMsgParam;
9617 pEnterUapsdRsqParams->status = wdiStatus;
9618
9619 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9620 {
9621 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9622 vos_mem_free(pWdaParams);
9623 WDA_SendMsg(pWDA, WDA_ENTER_UAPSD_RSP, (void *)pEnterUapsdRsqParams, 0);
9624 }
9625
9626 return;
9627}
9628/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9629 * FUNCTION: WDA_ProcessEnterUapsdReq
9630 * Request to WDI to Enter UAPSD power state.
9631 */
9632VOS_STATUS WDA_ProcessEnterUapsdReq(tWDA_CbContext *pWDA,
9633 tUapsdParams *pEnterUapsdReqParams)
9634{
9635 WDI_Status status = WDI_STATUS_SUCCESS ;
9636 WDI_EnterUapsdReqParamsType *wdiEnterUapsdReqParams =
9637 (WDI_EnterUapsdReqParamsType *)vos_mem_malloc(
9638 sizeof(WDI_EnterUapsdReqParamsType)) ;
9639 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9640 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9641 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9642 if(NULL == wdiEnterUapsdReqParams)
9643 {
9644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9645 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9646 VOS_ASSERT(0);
9647 return VOS_STATUS_E_NOMEM;
9648 }
9649 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9650 if(NULL == pWdaParams)
9651 {
9652 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9653 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9654 VOS_ASSERT(0);
9655 vos_mem_free(wdiEnterUapsdReqParams);
9656 return VOS_STATUS_E_NOMEM;
9657 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9658 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeDeliveryEnabled =
9659 pEnterUapsdReqParams->beDeliveryEnabled;
9660 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBeTriggerEnabled =
9661 pEnterUapsdReqParams->beTriggerEnabled;
9662 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkDeliveryEnabled =
9663 pEnterUapsdReqParams->bkDeliveryEnabled;
9664 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucBkTriggerEnabled =
9665 pEnterUapsdReqParams->bkTriggerEnabled;
9666 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViDeliveryEnabled =
9667 pEnterUapsdReqParams->viDeliveryEnabled;
9668 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucViTriggerEnabled =
9669 pEnterUapsdReqParams->viTriggerEnabled;
9670 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoDeliveryEnabled =
9671 pEnterUapsdReqParams->voDeliveryEnabled;
9672 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.ucVoTriggerEnabled =
9673 pEnterUapsdReqParams->voTriggerEnabled;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]9674 wdiEnterUapsdReqParams->wdiEnterUapsdInfo.bssIdx = pEnterUapsdReqParams->bssIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9675
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9676 wdiEnterUapsdReqParams->wdiReqStatusCB = WDA_EnterUapsdReqCallback;
9677 wdiEnterUapsdReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9678
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9679 /* Store param pointer as passed in by caller */
9680 /* store Params pass it to WDI */
9681 pWdaParams->wdaWdiApiMsgParam = wdiEnterUapsdReqParams;
9682 pWdaParams->pWdaContext = pWDA;
9683 pWdaParams->wdaMsgParam = pEnterUapsdReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9684 status = WDI_EnterUapsdReq(wdiEnterUapsdReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9685 (WDI_EnterUapsdRspCb)WDA_EnterUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9686 if(IS_WDI_STATUS_FAILURE(status))
9687 {
9688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9689 "Failure in Enter UAPSD REQ WDI API, free all the memory " );
9690 vos_mem_free(pWdaParams->wdaMsgParam) ;
9691 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9692 vos_mem_free(pWdaParams) ;
9693 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9694 return CONVERT_WDI2VOS_STATUS(status) ;
9695}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9696/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9697 * FUNCTION: WDA_ExitUapsdRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9698 * send Exit UAPSD RSP back to PE
9699 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9700void WDA_ExitUapsdRespCallback(WDI_ExitUapsdRspParamsType *pwdiExitRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9701{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9702
9703 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
9704 tWDA_CbContext *pWDA;
9705 tExitUapsdParams *pExitUapsdRspParams;
9706
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9707 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9708 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9709 if(NULL == pWdaParams)
9710 {
9711 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9712 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9713 VOS_ASSERT(0);
9714 return;
9715 }
9716
9717 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
9718 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
9719
9720 pExitUapsdRspParams->bssIdx = pwdiExitRspParam->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]9721 pExitUapsdRspParams->status = (pwdiExitRspParam->wdiStatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9722
9723 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9724 vos_mem_free(pWdaParams) ;
9725
9726 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9727 return ;
9728}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9729/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9730 * FUNCTION: WDA_ExitUapsdReqCallback
9731 * Free memory and send Exit UAPSD RSP back to PE.
9732 * Invoked when Exit UAPSD REQ failed in WDI and no RSP callback is generated.
9733 */
9734void WDA_ExitUapsdReqCallback(WDI_Status wdiStatus, void* pUserData)
9735{
9736 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9737 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9738 tExitUapsdParams *pExitUapsdRspParams;
9739
9740 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
9741 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
9742
9743 if(NULL == pWdaParams)
9744 {
9745 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9746 "%s: pWdaParams received NULL", __func__);
9747 VOS_ASSERT(0);
9748 return;
9749 }
9750
9751 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]9752 if (NULL == pWDA)
9753 {
9754 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9755 "%s:pWDA is NULL", __func__);
9756 VOS_ASSERT(0);
9757 return ;
9758 }
9759
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9760 pExitUapsdRspParams = (tExitUapsdParams *)pWdaParams->wdaMsgParam;
9761 pExitUapsdRspParams->status = wdiStatus;
9762
9763 if(IS_WDI_STATUS_FAILURE(wdiStatus))
9764 {
9765 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9766 vos_mem_free(pWdaParams);
9767 WDA_SendMsg(pWDA, WDA_EXIT_UAPSD_RSP, (void *)pExitUapsdRspParams, 0);
9768 }
9769
9770 return;
9771}
9772/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9773 * FUNCTION: WDA_ProcessExitUapsdReq
9774 * Request to WDI to Exit UAPSD power state.
9775 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9776VOS_STATUS WDA_ProcessExitUapsdReq(tWDA_CbContext *pWDA,
9777 tExitUapsdParams *pExitUapsdParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9778{
9779 WDI_Status status = WDI_STATUS_SUCCESS ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9780 tWDA_ReqParams *pWdaParams ;
9781 WDI_ExitUapsdReqParamsType *wdiExitUapsdReqParams =
9782 (WDI_ExitUapsdReqParamsType *)vos_mem_malloc(
9783 sizeof(WDI_ExitUapsdReqParamsType)) ;
9784
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9786 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9787
9788 if(NULL == wdiExitUapsdReqParams)
9789 {
9790 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9791 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9792 VOS_ASSERT(0);
9793 return VOS_STATUS_E_NOMEM;
9794 }
9795 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9796 if(NULL == pWdaParams)
9797 {
9798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9799 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9800 VOS_ASSERT(0);
9801 vos_mem_free(wdiExitUapsdReqParams);
9802 return VOS_STATUS_E_NOMEM;
9803 }
9804
9805 wdiExitUapsdReqParams->wdiExitUapsdInfo.bssIdx = pExitUapsdParams->bssIdx;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9806 wdiExitUapsdReqParams->wdiReqStatusCB = WDA_ExitUapsdReqCallback;
9807 wdiExitUapsdReqParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9808
9809 /* Store param pointer as passed in by caller */
9810 /* store Params pass it to WDI */
9811 pWdaParams->wdaWdiApiMsgParam = wdiExitUapsdReqParams;
9812 pWdaParams->pWdaContext = pWDA;
9813 pWdaParams->wdaMsgParam = pExitUapsdParams;
9814
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]9815 status = WDI_ExitUapsdReq(wdiExitUapsdReqParams, (WDI_ExitUapsdRspCb)WDA_ExitUapsdRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9816 if(IS_WDI_STATUS_FAILURE(status))
9817 {
9818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
9819 "Failure in Exit UAPSD REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]9820 vos_mem_free(pWdaParams->wdaMsgParam) ;
9821 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9822 vos_mem_free(pWdaParams) ;
9823
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9824 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9825 return CONVERT_WDI2VOS_STATUS(status) ;
9826}
9827
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9828/*
9829 * FUNCTION: WDA_SetPwrSaveCfgReqCallback
9830 *
9831 */
9832void WDA_SetPwrSaveCfgReqCallback(WDI_Status status, void* pUserData)
9833{
9834 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9836 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9837 if(NULL == pWdaParams)
9838 {
9839 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9840 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9841 VOS_ASSERT(0) ;
9842 return ;
9843 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9844 if( pWdaParams != NULL )
9845 {
9846 if( pWdaParams->wdaWdiApiMsgParam != NULL )
9847 {
9848 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
9849 }
9850 if( pWdaParams->wdaMsgParam != NULL )
9851 {
9852 vos_mem_free(pWdaParams->wdaMsgParam) ;
9853 }
9854 vos_mem_free(pWdaParams) ;
9855 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9856 return ;
9857}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9858/*
9859 * FUNCTION: WDA_ProcessSetPwrSaveCfgReq
9860 * Request to WDI to set the power save params at start.
9861 */
9862VOS_STATUS WDA_ProcessSetPwrSaveCfgReq(tWDA_CbContext *pWDA,
9863 tSirPowerSaveCfg *pPowerSaveCfg)
9864{
9865 WDI_Status status = WDI_STATUS_SUCCESS ;
9866 tHalCfg *tlvStruct = NULL ;
9867 tANI_U8 *tlvStructStart = NULL ;
9868 v_PVOID_t *configParam;
9869 tANI_U32 configParamSize;
9870 tANI_U32 *configDataValue;
9871 WDI_UpdateCfgReqParamsType *wdiPowerSaveCfg;
9872 tWDA_ReqParams *pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9873 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9874 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9875 if ((NULL == pWDA) || (NULL == pPowerSaveCfg))
9876 {
9877 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9878 "%s: invalid param", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9879 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9880 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9881 return VOS_STATUS_E_FAILURE;
9882 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9883 wdiPowerSaveCfg = vos_mem_malloc(sizeof(WDI_UpdateCfgReqParamsType));
9884 if (NULL == wdiPowerSaveCfg)
9885 {
9886 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9887 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9888 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9889 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9890 return VOS_STATUS_E_NOMEM;
9891 }
9892 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
9893 if(NULL == pWdaParams)
9894 {
9895 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]9896 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9897 VOS_ASSERT(0);
9898 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9899 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9900 return VOS_STATUS_E_NOMEM;
9901 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9902 configParamSize = (sizeof(tHalCfg) + (sizeof(tANI_U32))) * WDA_NUM_PWR_SAVE_CFG;
9903 configParam = vos_mem_malloc(configParamSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9904 if(NULL == configParam)
9905 {
9906 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]9907 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9908 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9909 vos_mem_free(pWdaParams);
9910 vos_mem_free(wdiPowerSaveCfg);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]9911 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9912 return VOS_STATUS_E_NOMEM;
9913 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9914 vos_mem_set(configParam, configParamSize, 0);
9915 wdiPowerSaveCfg->pConfigBuffer = configParam;
9916 tlvStruct = (tHalCfg *)configParam;
9917 tlvStructStart = (tANI_U8 *)configParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9918 /* QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE */
9919 tlvStruct->type = QWLAN_HAL_CFG_PS_BROADCAST_FRAME_FILTER_ENABLE;
9920 tlvStruct->length = sizeof(tANI_U32);
9921 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9922 *configDataValue = (tANI_U32)pPowerSaveCfg->broadcastFrameFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9923 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9924 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9925 /* QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD */
9926 tlvStruct->type = QWLAN_HAL_CFG_PS_HEART_BEAT_THRESHOLD;
9927 tlvStruct->length = sizeof(tANI_U32);
9928 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9929 *configDataValue = (tANI_U32)pPowerSaveCfg->HeartBeatCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9930 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9931 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9932 /* QWLAN_HAL_CFG_PS_IGNORE_DTIM */
9933 tlvStruct->type = QWLAN_HAL_CFG_PS_IGNORE_DTIM;
9934 tlvStruct->length = sizeof(tANI_U32);
9935 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9936 *configDataValue = (tANI_U32)pPowerSaveCfg->ignoreDtim;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9937 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9938 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9939 /* QWLAN_HAL_CFG_PS_LISTEN_INTERVAL */
9940 tlvStruct->type = QWLAN_HAL_CFG_PS_LISTEN_INTERVAL;
9941 tlvStruct->length = sizeof(tANI_U32);
9942 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9943 *configDataValue = (tANI_U32)pPowerSaveCfg->listenInterval;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9944 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9945 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9946 /* QWLAN_HAL_CFG_PS_MAX_PS_POLL */
9947 tlvStruct->type = QWLAN_HAL_CFG_PS_MAX_PS_POLL;
9948 tlvStruct->length = sizeof(tANI_U32);
9949 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9950 *configDataValue = (tANI_U32)pPowerSaveCfg->maxPsPoll;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9951 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9952 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9953 /* QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD */
9954 tlvStruct->type = QWLAN_HAL_CFG_PS_MIN_RSSI_THRESHOLD;
9955 tlvStruct->length = sizeof(tANI_U32);
9956 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9957 *configDataValue = (tANI_U32)pPowerSaveCfg->minRssiThreshold;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9958 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9959 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9960 /* QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER */
9961 tlvStruct->type = QWLAN_HAL_CFG_PS_NTH_BEACON_FILTER;
9962 tlvStruct->length = sizeof(tANI_U32);
9963 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9964 *configDataValue = (tANI_U32)pPowerSaveCfg->nthBeaconFilter;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9965 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9966 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9967 /* QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM */
9968 tlvStruct->type = QWLAN_HAL_CFG_PS_ENABLE_BCN_EARLY_TERM;
9969 tlvStruct->length = sizeof(tANI_U32);
9970 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9971 *configDataValue = (tANI_U32)pPowerSaveCfg->fEnableBeaconEarlyTermination;
9972 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9973 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9974 /* QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL */
9975 tlvStruct->type = QWLAN_HAL_CFG_BCN_EARLY_TERM_WAKEUP_INTERVAL;
9976 tlvStruct->length = sizeof(tANI_U32);
9977 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9978 *configDataValue = (tANI_U32)pPowerSaveCfg->bcnEarlyTermWakeInterval;
9979 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9980 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9981 /* QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE */
9982 tlvStruct->type = QWLAN_HAL_CFG_NUM_BEACON_PER_RSSI_AVERAGE;
9983 tlvStruct->length = sizeof(tANI_U32);
9984 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9985 *configDataValue = (tANI_U32)pPowerSaveCfg->numBeaconPerRssiAverage;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9986 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9987 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9988 /* QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD */
9989 tlvStruct->type = QWLAN_HAL_CFG_PS_RSSI_FILTER_PERIOD;
9990 tlvStruct->length = sizeof(tANI_U32);
9991 configDataValue = (tANI_U32 *)(tlvStruct + 1);
9992 *configDataValue = (tANI_U32)pPowerSaveCfg->rssiFilterPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9993 tlvStruct = (tHalCfg *)(( (tANI_U8 *) tlvStruct
9994 + sizeof(tHalCfg) + tlvStruct->length)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9995 wdiPowerSaveCfg->uConfigBufferLen = (tANI_U8 *)tlvStruct - tlvStructStart ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9996 wdiPowerSaveCfg->wdiReqStatusCB = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]9997 /* store Params pass it to WDI */
9998 pWdaParams->wdaMsgParam = configParam;
9999 pWdaParams->wdaWdiApiMsgParam = wdiPowerSaveCfg;
10000 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10001 status = WDI_SetPwrSaveCfgReq(wdiPowerSaveCfg,
10002 (WDI_SetPwrSaveCfgCb)WDA_SetPwrSaveCfgReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10003 if(IS_WDI_STATUS_FAILURE(status))
10004 {
10005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10006 "Failure in Set Pwr Save CFG REQ WDI API, free all the memory " );
10007 vos_mem_free(pWdaParams->wdaMsgParam);
10008 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10009 vos_mem_free(pWdaParams);
10010 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10011 vos_mem_free(pPowerSaveCfg);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10012 return CONVERT_WDI2VOS_STATUS(status);
10013}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10014/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10015 * FUNCTION: WDA_SetUapsdAcParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10016 *
10017 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10018void WDA_SetUapsdAcParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10019{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10020 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
10021
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10023 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10024
10025 if(NULL == pWdaParams)
10026 {
10027 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10028 "%s: pWdaParams received NULL", __func__);
10029 VOS_ASSERT(0);
10030 return ;
10031 }
10032
10033 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10034 vos_mem_free(pWdaParams);
10035
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10036 return ;
10037}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10038/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10039 * FUNCTION: WDA_SetUapsdAcParamsReqCallback
10040 * Free memory.
10041 * Invoked when SetUAPSDACParams REQ failed in WDI and no RSP callback is generated.
10042 */
10043void WDA_SetUapsdAcParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
10044{
10045 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10046
10047 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10048 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10049
10050 if(NULL == pWdaParams)
10051 {
10052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10053 "%s: pWdaParams received NULL", __func__);
10054 VOS_ASSERT(0);
10055 return;
10056 }
10057
10058 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10059 {
10060 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10061 vos_mem_free(pWdaParams);
10062 }
10063
10064 return;
10065}
10066/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10067 * FUNCTION: WDA_SetUapsdAcParamsReq
10068 * Request to WDI to set the UAPSD params for an ac (sta mode).
10069 */
10070VOS_STATUS WDA_SetUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx,
10071 tUapsdInfo *pUapsdInfo)
10072{
10073 WDI_Status status = WDI_STATUS_SUCCESS;
10074 tWDA_CbContext *pWDA = NULL ;
10075 WDI_SetUapsdAcParamsReqParamsType *wdiUapsdParams =
10076 (WDI_SetUapsdAcParamsReqParamsType *)vos_mem_malloc(
10077 sizeof(WDI_SetUapsdAcParamsReqParamsType)) ;
10078 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10079 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10080 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10081 if(NULL == wdiUapsdParams)
10082 {
10083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10084 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10085 VOS_ASSERT(0);
10086 return VOS_STATUS_E_NOMEM;
10087 }
10088 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10089 if(NULL == pWdaParams)
10090 {
10091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10092 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10093 VOS_ASSERT(0);
10094 vos_mem_free(wdiUapsdParams);
10095 return VOS_STATUS_E_NOMEM;
10096 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10097 wdiUapsdParams->wdiUapsdInfo.ucAc = pUapsdInfo->ac;
10098 wdiUapsdParams->wdiUapsdInfo.uDelayInterval = pUapsdInfo->delayInterval;
10099 wdiUapsdParams->wdiUapsdInfo.uSrvInterval = pUapsdInfo->srvInterval;
10100 wdiUapsdParams->wdiUapsdInfo.ucSTAIdx = pUapsdInfo->staidx;
10101 wdiUapsdParams->wdiUapsdInfo.uSusInterval = pUapsdInfo->susInterval;
10102 wdiUapsdParams->wdiUapsdInfo.ucUp = pUapsdInfo->up;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10103 wdiUapsdParams->wdiReqStatusCB = WDA_SetUapsdAcParamsReqCallback;
10104 wdiUapsdParams->pUserData = pWdaParams;
10105
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10106 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10107 pWdaParams->pWdaContext = pWDA;
10108 /* Store param pointer as passed in by caller */
10109 pWdaParams->wdaMsgParam = pUapsdInfo;
10110 /* store Params pass it to WDI */
10111 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUapsdParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10112 status = WDI_SetUapsdAcParamsReq(wdiUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10113 (WDI_SetUapsdAcParamsCb)WDA_SetUapsdAcParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10114 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10115 if(IS_WDI_STATUS_FAILURE(status))
10116 {
10117 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10118 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
10119 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10120 vos_mem_free(pWdaParams);
10121 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10122 if((WDI_STATUS_SUCCESS == status) || (WDI_STATUS_PENDING == status))
10123 return VOS_STATUS_SUCCESS;
10124 else
10125 return VOS_STATUS_E_FAILURE;
10126
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10127}
10128/*
10129 * FUNCTION: WDA_ClearUapsdAcParamsReq
10130 * Currently the WDA API is a NOP. It has been added for symmetry & Also it was
10131 * decided that the if the UPASD parameters change, FW would get a exit UAPSD
10132 * and again enter the UPASD with the modified params. Hence the disable
10133 * function was kept empty.
10134 *
10135 */
10136VOS_STATUS WDA_ClearUapsdAcParamsReq(v_PVOID_t pVosContext, v_U8_t staIdx, wpt_uint8 ac)
10137{
10138 /* do nothing */
10139 return VOS_STATUS_SUCCESS;
10140}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10141/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10142 * FUNCTION: WDA_UpdateUapsdParamsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10143 *
10144 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10145void WDA_UpdateUapsdParamsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10146{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10147 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
10148
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10150 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10151
10152 if(NULL == pWdaParams)
10153 {
10154 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10155 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10156 VOS_ASSERT(0) ;
10157 return ;
10158 }
10159
10160 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10161 vos_mem_free(pWdaParams->wdaMsgParam);
10162 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10163
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10164 //print a msg, nothing else to do
10165 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10166 "WDA_UpdateUapsdParamsRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10167 return ;
10168}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10169/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10170 * FUNCTION: WDA_UpdateUapsdParamsReqCallback
10171 * Free memory.
10172 * Invoked when UpdateUAPSDParams REQ failed in WDI and no RSP callback is generated.
10173 */
10174void WDA_UpdateUapsdParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
10175{
10176 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10177
10178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10179 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10180
10181 if(NULL == pWdaParams)
10182 {
10183 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10184 "%s: pWdaParams received NULL", __func__);
10185 VOS_ASSERT(0);
10186 return;
10187 }
10188
10189 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10190 {
10191 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10192 vos_mem_free(pWdaParams->wdaMsgParam);
10193 vos_mem_free(pWdaParams);
10194 }
10195
10196 return;
10197}
10198/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10199 * FUNCTION: WDA_UpdateUapsdParamsReq
10200 * Request to WDI to update UAPSD params (in softAP mode) for a station.
10201 */
10202VOS_STATUS WDA_UpdateUapsdParamsReq(tWDA_CbContext *pWDA,
10203 tUpdateUapsdParams* pUpdateUapsdInfo)
10204{
10205 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10206 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10207 WDI_UpdateUapsdReqParamsType *wdiUpdateUapsdParams =
10208 (WDI_UpdateUapsdReqParamsType *)vos_mem_malloc(
10209 sizeof(WDI_UpdateUapsdReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10210 tWDA_ReqParams *pWdaParams = NULL;
10211
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10212 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10213 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10214 if(NULL == wdiUpdateUapsdParams)
10215 {
10216 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10217 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10218 VOS_ASSERT(0);
10219 return VOS_STATUS_E_NOMEM;
10220 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10221 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.uMaxSpLen = pUpdateUapsdInfo->maxSpLen;
10222 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucSTAIdx = pUpdateUapsdInfo->staIdx;
10223 wdiUpdateUapsdParams->wdiUpdateUapsdInfo.ucUapsdACMask = pUpdateUapsdInfo->uapsdACMask;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10224 wdiUpdateUapsdParams->wdiReqStatusCB = WDA_UpdateUapsdParamsReqCallback;
10225 wdiUpdateUapsdParams->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10226
10227 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10228 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10229 {
10230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10231 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10232 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10233 vos_mem_free(pUpdateUapsdInfo);
10234 vos_mem_free(wdiUpdateUapsdParams);
10235 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10236 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10237 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10238 pWdaParams->wdaMsgParam = pUpdateUapsdInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10239 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10240 pWdaParams->wdaWdiApiMsgParam = (void *)wdiUpdateUapsdParams;
10241 pWdaParams->pWdaContext = pWDA;
10242
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10243 wstatus = WDI_UpdateUapsdParamsReq(wdiUpdateUapsdParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10244 (WDI_UpdateUapsdParamsCb)WDA_UpdateUapsdParamsRespCallback,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10245 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10246
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10247 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10248 {
10249 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10250 "Failure in Set UAPSD params REQ WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]10251 status = CONVERT_WDI2VOS_STATUS(wstatus) ;
10252 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10253 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]10254 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10255 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10256 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10257}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10258/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10259 * FUNCTION: WDA_ConfigureRxpFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10260 *
10261 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10262void WDA_ConfigureRxpFilterRespCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10263{
10264 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10265 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10266 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10267 if(WDI_STATUS_SUCCESS != wdiStatus)
10268 {
10269 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]10270 "%s: RXP config filter failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10271 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10272 if(NULL == pWdaParams)
10273 {
10274 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10275 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10276 VOS_ASSERT(0) ;
10277 return ;
10278 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10279 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10280 vos_mem_free(pWdaParams->wdaMsgParam);
10281 vos_mem_free(pWdaParams);
10282 return ;
10283}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10284/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10285 * FUNCTION: WDA_ConfigureRxpFilterReqCallback
10286 * Free memory.
10287 * Invoked when ConfigureRXPFilter REQ failed in WDI and no RSP callback is generated.
10288 */
10289void WDA_ConfigureRxpFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
10290{
10291 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10292
10293 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10294 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10295
10296 if(NULL == pWdaParams)
10297 {
10298 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10299 "%s: pWdaParams received NULL", __func__);
10300 VOS_ASSERT(0);
10301 return;
10302 }
10303
10304 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10305 {
10306 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10307 vos_mem_free(pWdaParams->wdaMsgParam);
10308 vos_mem_free(pWdaParams);
10309 }
10310
10311 return;
10312}
10313/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10314 * FUNCTION: WDA_ProcessConfigureRxpFilterReq
10315 *
10316 */
10317VOS_STATUS WDA_ProcessConfigureRxpFilterReq(tWDA_CbContext *pWDA,
10318 tSirWlanSetRxpFilters *pWlanSuspendParam)
10319{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10320 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10321 WDI_Status wstatus;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]10322 WDI_ConfigureRxpFilterReqParamsType *wdiRxpFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10323 tWDA_ReqParams *pWdaParams ;
Siddharth Bhal1739c9c2014-04-17 20:40:55 +0530[diff] [blame]10324 /* Sanity Check
10325 * This is very unlikely and add assert to collect more info next time */
10326 if(NULL == pWlanSuspendParam)
10327 {
10328 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10329 "%s: pWlanSuspendParam received NULL", __func__);
10330 VOS_ASSERT(0) ;
10331 return VOS_STATUS_E_FAULT;
10332 }
10333 wdiRxpFilterParams = (WDI_ConfigureRxpFilterReqParamsType *)vos_mem_malloc(
10334 sizeof(WDI_ConfigureRxpFilterReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10336 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10337 if(NULL == wdiRxpFilterParams)
10338 {
10339 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10340 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10341 VOS_ASSERT(0);
10342 vos_mem_free(pWlanSuspendParam);
10343 return VOS_STATUS_E_NOMEM;
10344 }
10345 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10346 if(NULL == pWdaParams)
10347 {
10348 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10349 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10350 VOS_ASSERT(0);
10351 vos_mem_free(wdiRxpFilterParams);
10352 vos_mem_free(pWlanSuspendParam);
10353 return VOS_STATUS_E_NOMEM;
10354 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10355 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilter =
10356 pWlanSuspendParam->setMcstBcstFilter;
10357 wdiRxpFilterParams->wdiRxpFilterParam.ucSetMcstBcstFilterSetting =
10358 pWlanSuspendParam->configuredMcstBcstFilterSetting;
10359
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10360 wdiRxpFilterParams->wdiReqStatusCB = WDA_ConfigureRxpFilterReqCallback;
10361 wdiRxpFilterParams->pUserData = pWdaParams;
10362
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10363 pWdaParams->pWdaContext = pWDA;
10364 pWdaParams->wdaMsgParam = pWlanSuspendParam;
10365 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRxpFilterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10366 wstatus = WDI_ConfigureRxpFilterReq(wdiRxpFilterParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10367 (WDI_ConfigureRxpFilterCb)WDA_ConfigureRxpFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10368 pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10369 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10370 {
10371 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10372 "Failure in configure RXP filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10373 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10374 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10375 vos_mem_free(pWdaParams->wdaMsgParam);
10376 vos_mem_free(pWdaParams);
10377 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]10378 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10379}
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10380
10381/*
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]10382 * FUNCTION: WDA_ProcessGetFrameLogReq
10383 * Request to WDI to get the Frame Log.
10384 */
10385VOS_STATUS WDA_ProcessGetFrameLogReq(tWDA_CbContext *pWDA,
10386 tAniGetFrameLogReq *pGetFrameLog)
10387{
10388 VOS_STATUS status = VOS_STATUS_SUCCESS;
10389 WDI_Status wstatus;
10390 WDI_GetFrameLogReqInfoType *wdiGetFrameLogInfo;
10391 tWDA_ReqParams *pWdaParams ;
10392
10393 /* Sanity Check*/
10394 if(NULL == pGetFrameLog)
10395 {
10396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10397 "%s: pFWLoggingInitParam received NULL", __func__);
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]10398 VOS_ASSERT(0) ;
10399 return VOS_STATUS_E_FAULT;
10400 }
10401
10402 wdiGetFrameLogInfo = (WDI_GetFrameLogReqInfoType *)vos_mem_malloc(
10403 sizeof(WDI_GetFrameLogReqInfoType));
10404 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10405 "------> %s " ,__func__);
10406
10407 if(NULL == wdiGetFrameLogInfo)
10408 {
10409 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10410 "%s: VOS MEM Alloc Failure", __func__);
10411 VOS_ASSERT(0);
10412 vos_mem_free(pGetFrameLog);
10413 return VOS_STATUS_E_NOMEM;
10414 }
10415
10416 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
10417 if(NULL == pWdaParams)
10418 {
10419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10420 "%s: VOS MEM Alloc Failure", __func__);
10421 VOS_ASSERT(0);
10422 vos_mem_free(wdiGetFrameLogInfo);
10423 vos_mem_free(pGetFrameLog);
10424 return VOS_STATUS_E_NOMEM;
10425 }
10426
10427 wdiGetFrameLogInfo->flags = pGetFrameLog->getFrameLogCmdFlag;
10428
10429 pWdaParams->pWdaContext = pWDA;
10430 pWdaParams->wdaMsgParam = pGetFrameLog;
10431 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGetFrameLogInfo;
10432
10433 wstatus = WDI_GetFrameLogReq(wdiGetFrameLogInfo,
10434 (WDI_GetFrameLogRspCb)WDA_GetFrameLogRspCallback,
10435 pWdaParams);
10436 if(IS_WDI_STATUS_FAILURE(wstatus))
10437 {
10438 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10439 "Failure in get frame log REQ WDI API, free all the memory" );
10440 status = CONVERT_WDI2VOS_STATUS(wstatus);
10441 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10442 vos_mem_free(pWdaParams->wdaMsgParam);
10443 vos_mem_free(pWdaParams);
10444 }
10445 return status;
10446}
10447
Sachin Ahuja715aafc2015-07-21 23:35:10 +0530[diff] [blame]10448
10449/*
10450 * FUNCTION: WDA_FatalEventLogsRspCallback
10451 * recieves Flush Logs response from FW
10452 */
10453
10454void WDA_FatalEventLogsRspCallback(WDI_FatalEventLogsRspParamType* wdiRsp,
10455 void* pUserData)
10456{
10457 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10458
10459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10460 "<------ %s,wdiStatus:%d " ,
10461 __func__, wdiRsp->wdiStatus);
10462 if(NULL == pWdaParams)
10463 {
10464 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10465 "%s: pWdaParams received NULL", __func__);
10466 VOS_ASSERT(0);
10467 return ;
10468 }
10469
10470 if(NULL == pWdaParams->wdaMsgParam)
10471 {
10472 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10473 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
10474 VOS_ASSERT(0);
10475 vos_mem_free(pWdaParams);
10476 return ;
10477 }
10478
10479 if(IS_WDI_STATUS_FAILURE(wdiRsp->wdiStatus))
10480 {
10481 /*
10482 * If it is failure, it means JOb is already posted by FW
10483 * for logging, so for failure scenario also we will get the
10484 * done indication
10485 */
10486 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10487 "%s: Fatal Event Rsp Failure,wdiStatus : %d ",
10488 __func__, wdiRsp->wdiStatus);
10489 }
10490
10491 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10492 vos_mem_free(pWdaParams->wdaMsgParam);
10493 vos_mem_free(pWdaParams);
10494
10495 return;
10496
10497}
10498
10499/*
10500 * FUNCTION: WDA_ProcessFatalEventLogsReq
10501 * Request to WDI to send the fatal Event Logs Req.
10502 */
10503
10504VOS_STATUS WDA_ProcessFatalEventLogsReq(tWDA_CbContext *pWDA,
10505 tSirFatalEventLogsReqParam *pFatalEventLogsReqParam)
10506{
10507 VOS_STATUS status = VOS_STATUS_SUCCESS;
10508 WDI_FatalEventLogsReqInfoType *wdiFatalEventLogsReqInfo;
10509 tWDA_ReqParams *pWdaParams ;
10510 WDI_Status wstatus;
10511
10512
10513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10514 "------> %s " ,__func__);
10515 if (NULL == pFatalEventLogsReqParam)
10516 {
10517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10518 "%s: pMgmtLoggingInitParam received NULL", __func__);
10519 VOS_ASSERT(0) ;
10520 return VOS_STATUS_E_FAULT;
10521 }
10522 wdiFatalEventLogsReqInfo = (WDI_FatalEventLogsReqInfoType *)vos_mem_malloc(
10523 sizeof(WDI_FatalEventLogsReqInfoType));
10524 if(NULL == wdiFatalEventLogsReqInfo)
10525 {
10526 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10527 "%s: VOS MEM Alloc Failure", __func__);
10528 VOS_ASSERT(0);
10529 vos_mem_free(pFatalEventLogsReqParam);
10530 return VOS_STATUS_E_NOMEM;
10531 }
10532 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10533 if(NULL == pWdaParams)
10534 {
10535 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10536 "%s: VOS MEM Alloc Failure", __func__);
10537 VOS_ASSERT(0);
10538 vos_mem_free(wdiFatalEventLogsReqInfo);
10539 vos_mem_free(pFatalEventLogsReqParam);
10540 return VOS_STATUS_E_NOMEM;
10541 }
10542 wdiFatalEventLogsReqInfo->reason_code = pFatalEventLogsReqParam->reason_code;
10543 pWdaParams->pWdaContext = pWDA;
10544 pWdaParams->wdaMsgParam = pFatalEventLogsReqParam;
10545 pWdaParams->wdaWdiApiMsgParam = (void *)wdiFatalEventLogsReqInfo;
10546
10547 wstatus = WDI_FatalEventLogsReq(wdiFatalEventLogsReqInfo,
10548 (WDI_FatalEventLogsRspCb)WDA_FatalEventLogsRspCallback,
10549 pWdaParams);
10550 if(IS_WDI_STATUS_FAILURE(wstatus))
10551 {
10552 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10553 "Failure in Mgmt Logging init REQ WDI API, free all the memory" );
10554 status = CONVERT_WDI2VOS_STATUS(wstatus);
10555 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10556 vos_mem_free(pWdaParams->wdaMsgParam);
10557 vos_mem_free(pWdaParams);
10558 }
10559
10560 return status;
10561
10562}
10563
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]10564/*
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10565 * FUNCTION: WDA_ProcessFWLoggingInitReq
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10566 *
10567 */
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10568VOS_STATUS WDA_ProcessFWLoggingInitReq(tWDA_CbContext *pWDA,
10569 tSirFWLoggingInitParam *pFWLoggingInitParam)
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10570{
10571 VOS_STATUS status = VOS_STATUS_SUCCESS;
10572 WDI_Status wstatus;
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10573 WDI_FWLoggingInitReqInfoType *wdiFWLoggingInitInfo;
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10574 tWDA_ReqParams *pWdaParams ;
10575
10576 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10577 "------> %s " ,__func__);
10578
10579 /* Sanity Check*/
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10580 if(NULL == pFWLoggingInitParam)
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10581 {
10582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10583 "%s: pFWLoggingInitParam received NULL", __func__);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10584 VOS_ASSERT(0) ;
10585 return VOS_STATUS_E_FAULT;
10586 }
10587
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10588 wdiFWLoggingInitInfo = (WDI_FWLoggingInitReqInfoType *)vos_mem_malloc(
10589 sizeof(WDI_FWLoggingInitReqInfoType));
10590 if(NULL == wdiFWLoggingInitInfo)
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10591 {
10592 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10593 "%s: VOS MEM Alloc Failure", __func__);
10594 VOS_ASSERT(0);
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10595 vos_mem_free(pFWLoggingInitParam);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10596 return VOS_STATUS_E_NOMEM;
10597 }
10598
10599 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10600 if(NULL == pWdaParams)
10601 {
10602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10603 "%s: VOS MEM Alloc Failure", __func__);
10604 VOS_ASSERT(0);
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10605 vos_mem_free(wdiFWLoggingInitInfo);
10606 vos_mem_free(pFWLoggingInitParam);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10607 return VOS_STATUS_E_NOMEM;
10608 }
10609
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10610 wdiFWLoggingInitInfo->enableFlag = pFWLoggingInitParam->enableFlag;
10611 wdiFWLoggingInitInfo->frameType = pFWLoggingInitParam->frameType;
10612 wdiFWLoggingInitInfo->frameSize = pFWLoggingInitParam->frameSize;
10613 wdiFWLoggingInitInfo->bufferMode = pFWLoggingInitParam->bufferMode;
10614 wdiFWLoggingInitInfo->continuousFrameLogging =
10615 pFWLoggingInitParam->continuousFrameLogging;
10616 wdiFWLoggingInitInfo->minLogBufferSize=
10617 pFWLoggingInitParam->minLogBufferSize;
10618 wdiFWLoggingInitInfo->maxLogBufferSize=
10619 pFWLoggingInitParam->maxLogBufferSize;
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10620
10621 pWdaParams->pWdaContext = pWDA;
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10622 pWdaParams->wdaMsgParam = pFWLoggingInitParam;
10623 pWdaParams->wdaWdiApiMsgParam = (void *)wdiFWLoggingInitInfo;
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10624
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]10625 wstatus = WDI_FWLoggingInitReq(wdiFWLoggingInitInfo,
10626 (WDI_FWLoggingInitRspCb)WDA_FWLoggingInitRspCallback,
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]10627 pWdaParams);
10628 if(IS_WDI_STATUS_FAILURE(wstatus))
10629 {
10630 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10631 "Failure in Mgmt Logging init REQ WDI API, free all the memory" );
10632 status = CONVERT_WDI2VOS_STATUS(wstatus);
10633 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10634 vos_mem_free(pWdaParams->wdaMsgParam);
10635 vos_mem_free(pWdaParams);
10636 }
10637
10638 return status;
10639}
10640
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10641/*
Gupta, Kapil7c34b322015-09-30 13:12:35 +0530[diff] [blame]10642 * FUNCTION: WDA_ProcessStartRssiMonitorReq
10643 *
10644 */
10645VOS_STATUS WDA_ProcessStartRssiMonitorReq(tWDA_CbContext *pWDA,
10646 tSirRssiMonitorReq *pRssiMonitorReqParam)
10647{
10648 VOS_STATUS status = VOS_STATUS_SUCCESS;
10649 WDI_Status wstatus;
10650 WDI_RssiMonitorReqInfoType *wdiRssiMonitorInfo;
10651 tWDA_ReqParams *pWdaParams ;
10652
10653 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10654 "------> %s " ,__func__);
10655
10656 /* Sanity Check*/
10657 if(NULL == pRssiMonitorReqParam)
10658 {
10659 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10660 "%s: pRssiMonitorReqParam received NULL", __func__);
10661 VOS_ASSERT(0) ;
10662 return VOS_STATUS_E_FAULT;
10663 }
10664
10665 wdiRssiMonitorInfo = (WDI_RssiMonitorReqInfoType *)vos_mem_malloc(
10666 sizeof(WDI_RssiMonitorReqInfoType));
10667 if(NULL == wdiRssiMonitorInfo)
10668 {
10669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10670 "%s: VOS MEM Alloc Failure", __func__);
10671 VOS_ASSERT(0);
10672 vos_mem_free(pRssiMonitorReqParam);
10673 return VOS_STATUS_E_NOMEM;
10674 }
10675
10676 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10677 if(NULL == pWdaParams)
10678 {
10679 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10680 "%s: VOS MEM Alloc Failure", __func__);
10681 VOS_ASSERT(0);
10682 vos_mem_free(wdiRssiMonitorInfo);
10683 vos_mem_free(pRssiMonitorReqParam);
10684 return VOS_STATUS_E_NOMEM;
10685 }
10686
10687 wdiRssiMonitorInfo->requestId = pRssiMonitorReqParam->requestId;
10688 wdiRssiMonitorInfo->minRssi = pRssiMonitorReqParam->minRssi;
10689 wdiRssiMonitorInfo->maxRssi = pRssiMonitorReqParam->maxRssi;
10690 vos_mem_copy(wdiRssiMonitorInfo->currentBssId,
10691 &(pRssiMonitorReqParam->currentBssId), sizeof(tSirMacAddr));
10692
10693 pWdaParams->pWdaContext = pWDA;
10694 pWdaParams->wdaMsgParam = pRssiMonitorReqParam;
10695 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRssiMonitorInfo;
10696
10697 wstatus = WDI_StartRssiMonitorReq(wdiRssiMonitorInfo,
10698 (WDI_RssiMonitorStartRspCb)WDA_RssiMonitorStartRspCallback,
10699 pWdaParams);
10700 if(IS_WDI_STATUS_FAILURE(wstatus))
10701 {
10702 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10703 "Failure in Mgmt Logging init REQ WDI API, free all the memory" );
10704 status = CONVERT_WDI2VOS_STATUS(wstatus);
10705 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10706 vos_mem_free(pWdaParams->wdaMsgParam);
10707 vos_mem_free(pWdaParams);
10708 }
10709
10710 return status;
10711}
10712
10713/*
10714 * FUNCTION: WDA_ProcessStopRssiMonitorReq
10715 *
10716 */
10717VOS_STATUS WDA_ProcessStopRssiMonitorReq(tWDA_CbContext *pWDA,
10718 tSirRssiMonitorReq *pRssiMonitorReqParam)
10719{
10720 VOS_STATUS status = VOS_STATUS_SUCCESS;
10721 WDI_Status wstatus;
10722 WDI_RssiMonitorReqInfoType *wdiRssiMonitorInfo;
10723 tWDA_ReqParams *pWdaParams ;
10724
10725 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10726 "------> %s " ,__func__);
10727
10728 /* Sanity Check*/
10729 if(NULL == pRssiMonitorReqParam)
10730 {
10731 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10732 "%s: pRssiMonitorReqParam received NULL", __func__);
10733 VOS_ASSERT(0) ;
10734 return VOS_STATUS_E_FAULT;
10735 }
10736
10737 wdiRssiMonitorInfo = (WDI_RssiMonitorReqInfoType *)vos_mem_malloc(
10738 sizeof(WDI_RssiMonitorReqInfoType));
10739 if(NULL == wdiRssiMonitorInfo)
10740 {
10741 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10742 "%s: VOS MEM Alloc Failure", __func__);
10743 VOS_ASSERT(0);
10744 vos_mem_free(pRssiMonitorReqParam);
10745 return VOS_STATUS_E_NOMEM;
10746 }
10747
10748 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10749 if(NULL == pWdaParams)
10750 {
10751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10752 "%s: VOS MEM Alloc Failure", __func__);
10753 VOS_ASSERT(0);
10754 vos_mem_free(wdiRssiMonitorInfo);
10755 vos_mem_free(pRssiMonitorReqParam);
10756 return VOS_STATUS_E_NOMEM;
10757 }
10758
10759 wdiRssiMonitorInfo->requestId = pRssiMonitorReqParam->requestId;
10760 vos_mem_copy(wdiRssiMonitorInfo->currentBssId,
10761 &(pRssiMonitorReqParam->currentBssId), sizeof(tSirMacAddr));
10762
10763 pWdaParams->pWdaContext = pWDA;
10764 pWdaParams->wdaMsgParam = pRssiMonitorReqParam;
10765 pWdaParams->wdaWdiApiMsgParam = (void *)wdiRssiMonitorInfo;
10766
10767 wstatus = WDI_StopRssiMonitorReq(wdiRssiMonitorInfo,
10768 (WDI_RssiMonitorStopRspCb)WDA_RssiMonitorStopRspCallback,
10769 pWdaParams);
10770 if(IS_WDI_STATUS_FAILURE(wstatus))
10771 {
10772 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10773 "Failure in Mgmt Logging init REQ WDI API, free all the memory" );
10774 status = CONVERT_WDI2VOS_STATUS(wstatus);
10775 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10776 vos_mem_free(pWdaParams->wdaMsgParam);
10777 vos_mem_free(pWdaParams);
10778 }
10779
10780 return status;
10781}
10782
10783
10784/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10785 * FUNCTION: WDA_WdiIndicationCallback
10786 *
10787 */
10788void WDA_WdiIndicationCallback( WDI_Status wdiStatus,
10789 void* pUserData)
10790{
10791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10792 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10793}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10794/*
10795 * FUNCTION: WDA_ProcessWlanSuspendInd
10796 *
10797 */
10798VOS_STATUS WDA_ProcessWlanSuspendInd(tWDA_CbContext *pWDA,
10799 tSirWlanSuspendParam *pWlanSuspendParam)
10800{
10801 WDI_Status wdiStatus;
10802 WDI_SuspendParamsType wdiSuspendParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10803 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10804 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10805 wdiSuspendParams.wdiSuspendParams.ucConfiguredMcstBcstFilterSetting =
10806 pWlanSuspendParam->configuredMcstBcstFilterSetting;
10807 wdiSuspendParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
10808 wdiSuspendParams.pUserData = pWDA;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10809 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]10810 wdiStatus = WDI_HostSuspendInd(&wdiSuspendParams);
10811 if(WDI_STATUS_PENDING == wdiStatus)
10812 {
10813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10814 "Pending received for %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10815 }
10816 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
10817 {
10818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10819 "Failure in %s:%d ",__func__,__LINE__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10820 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10821 vos_mem_free(pWlanSuspendParam);
10822 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
10823}
10824
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]10825#ifdef WLAN_FEATURE_11W
10826/*
10827 * FUNCTION: WDA_ProcessExcludeUnecryptInd
10828 *
10829 */
10830VOS_STATUS WDA_ProcessExcludeUnecryptInd(tWDA_CbContext *pWDA,
10831 tSirWlanExcludeUnencryptParam *pExclUnencryptParam)
10832{
10833 WDI_Status wdiStatus;
10834 WDI_ExcludeUnencryptIndType wdiExclUnencryptParams;
10835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10836 "------> %s ", __func__);
10837
10838 wdiExclUnencryptParams.bExcludeUnencrypt = pExclUnencryptParam->excludeUnencrypt;
10839 vos_mem_copy(wdiExclUnencryptParams.bssid, pExclUnencryptParam->bssId,
10840 sizeof(tSirMacAddr));
10841
10842 wdiExclUnencryptParams.wdiReqStatusCB = NULL;
10843 wdiExclUnencryptParams.pUserData = pWDA;
10844
10845 wdiStatus = WDI_ExcludeUnencryptedInd(&wdiExclUnencryptParams);
10846 if(WDI_STATUS_PENDING == wdiStatus)
10847 {
10848 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10849 "Pending received for %s:%d ", __func__, __LINE__ );
10850 }
10851 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
10852 {
10853 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10854 "Failure in %s:%d ", __func__, __LINE__ );
10855 }
10856 vos_mem_free(pExclUnencryptParam);
10857 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
10858}
10859#endif
10860
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10861/*
10862 * FUNCTION: WDA_ProcessWlanResumeCallback
10863 *
10864 */
10865void WDA_ProcessWlanResumeCallback(
10866 WDI_SuspendResumeRspParamsType *resumeRspParams,
10867 void* pUserData)
10868{
10869 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10870 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10871 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10872 if(NULL == pWdaParams)
10873 {
10874 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10875 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10876 VOS_ASSERT(0) ;
10877 return ;
10878 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10879 if(WDI_STATUS_SUCCESS != resumeRspParams->wdiStatus)
10880 {
10881 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]10882 "%s: Process Wlan Resume failure", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10883 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10884 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10885 vos_mem_free(pWdaParams->wdaMsgParam);
10886 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10887 return ;
10888}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10889/*
10890 * FUNCTION: WDA_ProcessWlanResumeReq
10891 *
10892 */
10893VOS_STATUS WDA_ProcessWlanResumeReq(tWDA_CbContext *pWDA,
10894 tSirWlanResumeParam *pWlanResumeParam)
10895{
10896 WDI_Status wdiStatus;
10897 WDI_ResumeParamsType *wdiResumeParams =
10898 (WDI_ResumeParamsType *)vos_mem_malloc(
10899 sizeof(WDI_ResumeParamsType) ) ;
10900 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10901 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10902 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10903 if(NULL == wdiResumeParams)
10904 {
10905 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10906 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10907 VOS_ASSERT(0);
10908 return VOS_STATUS_E_NOMEM;
10909 }
10910 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
10911 if(NULL == pWdaParams)
10912 {
10913 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10914 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10915 VOS_ASSERT(0);
10916 vos_mem_free(wdiResumeParams);
10917 return VOS_STATUS_E_NOMEM;
10918 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10919 wdiResumeParams->wdiResumeParams.ucConfiguredMcstBcstFilterSetting =
10920 pWlanResumeParam->configuredMcstBcstFilterSetting;
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10921 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]10922 wdiResumeParams->wdiReqStatusCB = NULL;
10923 pWdaParams->wdaMsgParam = pWlanResumeParam;
10924 pWdaParams->wdaWdiApiMsgParam = wdiResumeParams;
10925 pWdaParams->pWdaContext = pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10926 wdiStatus = WDI_HostResumeReq(wdiResumeParams,
10927 (WDI_HostResumeEventRspCb)WDA_ProcessWlanResumeCallback,
10928 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10929 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10930 {
10931 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10932 "Failure in Host Resume REQ WDI API, free all the memory " );
10933 VOS_ASSERT(0);
10934 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
10935 vos_mem_free(pWdaParams->wdaMsgParam);
10936 vos_mem_free(pWdaParams);
10937 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10938 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
10939}
10940
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10941/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10942 * FUNCTION: WDA_SetBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10943 *
10944 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10945void WDA_SetBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10946{
10947 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10948 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10949 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10950 if(NULL == pWdaParams)
10951 {
10952 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]10953 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10954 VOS_ASSERT(0) ;
10955 return ;
10956 }
10957
10958 vos_mem_free(pWdaParams->wdaMsgParam) ;
10959 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10960 vos_mem_free(pWdaParams) ;
10961 /*
10962 * No respone required for SetBeaconFilter req so just free the request
10963 * param here
10964 */
10965
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10966 return ;
10967}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10968/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]10969 * FUNCTION: WDA_SetBeaconFilterReqCallback
10970 * Free memory.
10971 * Invoked when SetBeaconFilter REQ failed in WDI and no RSP callback is generated.
10972 */
10973void WDA_SetBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
10974{
10975 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
10976
10977 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
10978 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
10979
10980 if(NULL == pWdaParams)
10981 {
10982 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
10983 "%s: pWdaParams received NULL", __func__);
10984 VOS_ASSERT(0);
10985 return;
10986 }
10987
10988 if(IS_WDI_STATUS_FAILURE(wdiStatus))
10989 {
10990 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
10991 vos_mem_free(pWdaParams->wdaMsgParam);
10992 vos_mem_free(pWdaParams);
10993 }
10994
10995 return;
10996}
10997/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]10998 * FUNCTION: WDA_SetBeaconFilterReq
10999 * Request to WDI to send the beacon filtering related information.
11000 */
11001VOS_STATUS WDA_SetBeaconFilterReq(tWDA_CbContext *pWDA,
11002 tBeaconFilterMsg* pBeaconFilterInfo)
11003{
11004 WDI_Status status = WDI_STATUS_SUCCESS;
11005 tANI_U8 *dstPtr, *srcPtr;
11006 tANI_U8 filterLength;
11007 WDI_BeaconFilterReqParamsType *wdiBeaconFilterInfo =
11008 (WDI_BeaconFilterReqParamsType *)vos_mem_malloc(
11009 sizeof(WDI_BeaconFilterReqParamsType) ) ;
11010 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11011 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11012 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11013 if(NULL == wdiBeaconFilterInfo)
11014 {
11015 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11016 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11017 VOS_ASSERT(0);
11018 return VOS_STATUS_E_NOMEM;
11019 }
11020 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11021 if(NULL == pWdaParams)
11022 {
11023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11024 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11025 VOS_ASSERT(0);
11026 vos_mem_free(wdiBeaconFilterInfo);
11027 return VOS_STATUS_E_NOMEM;
11028 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11029 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usBeaconInterval =
11030 pBeaconFilterInfo->beaconInterval;
11031 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityInfo =
11032 pBeaconFilterInfo->capabilityInfo;
11033 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usCapabilityMask =
11034 pBeaconFilterInfo->capabilityMask;
11035 wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum = pBeaconFilterInfo->ieNum;
Madan Mohan Koyyalamudia84edda2012-10-15 14:58:25 -0700[diff] [blame]11036
11037 //Fill the BssIdx
11038 wdiBeaconFilterInfo->wdiBeaconFilterInfo.bssIdx = pBeaconFilterInfo->bssIdx;
11039
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11040 //Fill structure with info contained in the beaconFilterTable
11041 dstPtr = (tANI_U8 *)wdiBeaconFilterInfo + sizeof(WDI_BeaconFilterInfoType);
11042 srcPtr = (tANI_U8 *)pBeaconFilterInfo + sizeof(tBeaconFilterMsg);
11043 filterLength = wdiBeaconFilterInfo->wdiBeaconFilterInfo.usIeNum * sizeof(tBeaconFilterIe);
11044 if(WDI_BEACON_FILTER_LEN < filterLength)
11045 {
11046 filterLength = WDI_BEACON_FILTER_LEN;
11047 }
11048 vos_mem_copy(dstPtr, srcPtr, filterLength);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11049 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_SetBeaconFilterReqCallback;
11050 wdiBeaconFilterInfo->pUserData = pWdaParams;
11051
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11052 /* Store param pointer as passed in by caller */
11053 /* store Params pass it to WDI */
11054 pWdaParams->wdaWdiApiMsgParam = wdiBeaconFilterInfo;
11055 pWdaParams->pWdaContext = pWDA;
11056 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
11057
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11058 status = WDI_SetBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11059 (WDI_SetBeaconFilterCb)WDA_SetBeaconFilterRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11060 if(IS_WDI_STATUS_FAILURE(status))
11061 {
11062 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11063 "Failure in Set Beacon Filter REQ WDI API, free all the memory " );
11064 vos_mem_free(pWdaParams->wdaMsgParam) ;
11065 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11066 vos_mem_free(pWdaParams) ;
11067 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11068 return CONVERT_WDI2VOS_STATUS(status) ;
11069}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11070/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11071 * FUNCTION: WDA_RemBeaconFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11072 *
11073 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11074void WDA_RemBeaconFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11075{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11076 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
11077
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11078 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11079 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11080
11081 if(NULL == pWdaParams)
11082 {
11083 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11084 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11085 VOS_ASSERT(0) ;
11086 return ;
11087 }
11088
11089 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11090 vos_mem_free(pWdaParams->wdaMsgParam);
11091 vos_mem_free(pWdaParams);
11092
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11093 //print a msg, nothing else to do
11094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11095 "WDA_RemBeaconFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11096 return ;
11097}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11098/*
11099 * FUNCTION: WDA_RemBeaconFilterReqCallback
11100 * Free memory.
11101 * Invoked when RemBeaconFilter REQ failed in WDI and no RSP callback is generated.
11102 */
11103void WDA_RemBeaconFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
11104{
11105 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11106
11107 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11108 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11109
11110 if(NULL == pWdaParams)
11111 {
11112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11113 "%s: pWdaParams received NULL", __func__);
11114 VOS_ASSERT(0);
11115 return;
11116 }
11117
11118 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11119 {
11120 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11121 vos_mem_free(pWdaParams->wdaMsgParam);
11122 vos_mem_free(pWdaParams);
11123 }
11124
11125 return;
11126}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11127 // TODO: PE does not have this feature for now implemented,
11128 // but the support for removing beacon filter exists between
11129 // HAL and FW. This function can be called whenever PE defines
11130 // a new message for beacon filter removal
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11131/*
11132 * FUNCTION: WDA_RemBeaconFilterReq
11133 * Request to WDI to send the removal of beacon filtering related information.
11134 */
11135VOS_STATUS WDA_RemBeaconFilterReq(tWDA_CbContext *pWDA,
11136 tRemBeaconFilterMsg* pBeaconFilterInfo)
11137{
11138 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11139 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11140 WDI_RemBeaconFilterReqParamsType *wdiBeaconFilterInfo =
11141 (WDI_RemBeaconFilterReqParamsType *)vos_mem_malloc(
11142 sizeof(WDI_RemBeaconFilterReqParamsType) + pBeaconFilterInfo->ucIeCount) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11143 tWDA_ReqParams *pWdaParams ;
11144
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11145 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11146 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11147 if(NULL == wdiBeaconFilterInfo)
11148 {
11149 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11150 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11151 VOS_ASSERT(0);
11152 return VOS_STATUS_E_NOMEM;
11153 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11154 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11155 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11156 {
11157 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11158 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11159 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11160 vos_mem_free(wdiBeaconFilterInfo);
11161 vos_mem_free(pBeaconFilterInfo);
11162 return VOS_STATUS_E_NOMEM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11163 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11164
11165 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount =
11166 pBeaconFilterInfo->ucIeCount;
11167 //Fill structure with info contained in the ucRemIeId
11168 vos_mem_copy(wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucRemIeId,
11169 pBeaconFilterInfo->ucRemIeId,
11170 wdiBeaconFilterInfo->wdiBeaconFilterInfo.ucIeCount);
11171 wdiBeaconFilterInfo->wdiReqStatusCB = WDA_RemBeaconFilterReqCallback;
11172 wdiBeaconFilterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11173
11174 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11175 pWdaParams->wdaMsgParam = pBeaconFilterInfo;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11176 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11177 pWdaParams->wdaWdiApiMsgParam = (void *)wdiBeaconFilterInfo;
11178
11179 pWdaParams->pWdaContext = pWDA;
11180
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11181 wstatus = WDI_RemBeaconFilterReq(wdiBeaconFilterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11182 (WDI_RemBeaconFilterCb)WDA_RemBeaconFilterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11183 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11184 {
11185 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11186 "Failure in Remove Beacon Filter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11187 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11188 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11189 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]11190 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11191 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11192 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11193}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11194/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11195 * FUNCTION: WDA_SetRSSIThresholdsRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11196 *
11197 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11198void WDA_SetRSSIThresholdsRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11199{
11200 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11201 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11202 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11203 if(NULL == pWdaParams)
11204 {
11205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11206 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11207 VOS_ASSERT(0) ;
11208 return ;
11209 }
11210
11211 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11212 vos_mem_free(pWdaParams) ;
11213
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11214 return ;
11215}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11216/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11217 * FUNCTION: WDA_SetRSSIThresholdsReqCallback
11218 * Free memory.
11219 * Invoked when SetRSSIThresholds REQ failed in WDI and no RSP callback is generated.
11220 */
11221void WDA_SetRSSIThresholdsReqCallback(WDI_Status wdiStatus, void* pUserData)
11222{
11223 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11224
11225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11226 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11227
11228 if(NULL == pWdaParams)
11229 {
11230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11231 "%s: pWdaParams received NULL", __func__);
11232 VOS_ASSERT(0);
11233 return;
11234 }
11235
11236 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11237 {
11238 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11239 vos_mem_free(pWdaParams);
11240 }
11241
11242 return;
11243}
11244/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11245 * FUNCTION: WDA_SetRSSIThresholdsReq
11246 * Request to WDI to set the RSSI thresholds (sta mode).
11247 */
11248VOS_STATUS WDA_SetRSSIThresholdsReq(tpAniSirGlobal pMac, tSirRSSIThresholds *pBmpsThresholds)
11249{
11250 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11251 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11252 tWDA_CbContext *pWDA = NULL ;
11253 v_PVOID_t pVosContext = NULL;
11254 WDI_SetRSSIThresholdsReqParamsType *wdiRSSIThresholdsInfo =
11255 (WDI_SetRSSIThresholdsReqParamsType *)vos_mem_malloc(
11256 sizeof(WDI_SetRSSIThresholdsReqParamsType)) ;
11257 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11259 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11260 if(NULL == wdiRSSIThresholdsInfo)
11261 {
11262 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11263 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11264 VOS_ASSERT(0);
11265 return VOS_STATUS_E_NOMEM;
11266 }
11267 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11268 if(NULL == pWdaParams)
11269 {
11270 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11271 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11272 VOS_ASSERT(0);
11273 vos_mem_free(wdiRSSIThresholdsInfo);
11274 return VOS_STATUS_E_NOMEM;
11275 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11276 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bReserved10 = pBmpsThresholds->bReserved10;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11277 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold1 = pBmpsThresholds->ucRssiThreshold1;
11278 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold2 = pBmpsThresholds->ucRssiThreshold2;
11279 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.ucRssiThreshold3 = pBmpsThresholds->ucRssiThreshold3;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11280 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1NegNotify = pBmpsThresholds->bRssiThres1NegNotify;
11281 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2NegNotify = pBmpsThresholds->bRssiThres2NegNotify;
11282 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3NegNotify = pBmpsThresholds->bRssiThres3NegNotify;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11283 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres1PosNotify = pBmpsThresholds->bRssiThres1PosNotify;
11284 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres2PosNotify = pBmpsThresholds->bRssiThres2PosNotify;
11285 wdiRSSIThresholdsInfo->wdiRSSIThresholdsInfo.bRssiThres3PosNotify = pBmpsThresholds->bRssiThres3PosNotify;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11286 wdiRSSIThresholdsInfo->wdiReqStatusCB = WDA_SetRSSIThresholdsReqCallback;
11287 wdiRSSIThresholdsInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11288 pVosContext = vos_get_global_context(VOS_MODULE_ID_PE, (void *)pMac);
11289 pWDA = vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
11290
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11291 /* Store param pointer as passed in by caller */
11292 /* store Params pass it to WDI */
11293 pWdaParams->wdaWdiApiMsgParam = wdiRSSIThresholdsInfo;
11294 pWdaParams->pWdaContext = pWDA;
11295 pWdaParams->wdaMsgParam = pBmpsThresholds;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11296 wstatus = WDI_SetRSSIThresholdsReq(wdiRSSIThresholdsInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11297 (WDI_SetRSSIThresholdsCb)WDA_SetRSSIThresholdsRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11298 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11299 {
11300 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11301 "Failure in Set RSSI thresholds REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11302 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11303 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11304 vos_mem_free(pWdaParams) ;
11305 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11306 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11307
11308}/*WDA_SetRSSIThresholdsReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11309/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11310 * FUNCTION: WDA_HostOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11311 *
11312 */
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11313void WDA_HostOffloadRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11314{
11315 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
11316
11317 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11318 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11319 if(NULL == pWdaParams)
11320 {
11321 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11322 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11323 VOS_ASSERT(0) ;
11324 return ;
11325 }
11326
11327 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11328 vos_mem_free(pWdaParams->wdaMsgParam);
11329 vos_mem_free(pWdaParams) ;
11330
11331 //print a msg, nothing else to do
11332 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11333 "WDA_HostOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11334 return ;
11335}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11336/*
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11337 * FUNCTION: WDA_HostOffloadReqCallback
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11338 * Free memory.
11339 * Invoked when HostOffload REQ failed in WDI and no RSP callback is generated.
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11340 */
11341void WDA_HostOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
11342{
11343 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11344
11345 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11346 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11347
11348 if(NULL == pWdaParams)
11349 {
11350 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11351 "%s: Invalid pWdaParams pointer", __func__);
11352 VOS_ASSERT(0);
11353 return;
11354 }
11355
11356 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11357 {
11358 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11359 vos_mem_free(pWdaParams->wdaMsgParam);
11360 vos_mem_free(pWdaParams);
11361 }
11362
11363 return;
11364}
11365/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11366 * FUNCTION: WDA_ProcessHostOffloadReq
11367 * Request to WDI to set the filter to minimize unnecessary host wakeup due
11368 * to broadcast traffic (sta mode).
11369 */
11370VOS_STATUS WDA_ProcessHostOffloadReq(tWDA_CbContext *pWDA,
11371 tSirHostOffloadReq *pHostOffloadParams)
11372{
11373 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11374 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11375 WDI_HostOffloadReqParamsType *wdiHostOffloadInfo =
11376 (WDI_HostOffloadReqParamsType *)vos_mem_malloc(
11377 sizeof(WDI_HostOffloadReqParamsType)) ;
11378 tWDA_ReqParams *pWdaParams ;
11379
11380 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11381 "------> %s: offloadType=%x" ,__func__, pHostOffloadParams->offloadType);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11382
11383 if(NULL == wdiHostOffloadInfo)
11384 {
11385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11386 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11387 VOS_ASSERT(0);
11388 return VOS_STATUS_E_NOMEM;
11389 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11390 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11391 if(NULL == pWdaParams)
11392 {
11393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11394 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11395 VOS_ASSERT(0);
11396 vos_mem_free(wdiHostOffloadInfo);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11397 vos_mem_free(pHostOffloadParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11398 return VOS_STATUS_E_NOMEM;
11399 }
11400
11401 wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType =
11402 pHostOffloadParams->offloadType;
11403 wdiHostOffloadInfo->wdiHostOffloadInfo.ucEnableOrDisable =
11404 pHostOffloadParams->enableOrDisable;
11405
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11406 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.bssId,
11407 pHostOffloadParams->bssId, sizeof(wpt_macAddr));
11408
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11409 switch (wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType)
11410 {
11411 case SIR_IPV4_ARP_REPLY_OFFLOAD:
11412 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv4Addr,
11413 pHostOffloadParams->params.hostIpv4Addr,
11414 4);
11415 break;
11416 case SIR_IPV6_NEIGHBOR_DISCOVERY_OFFLOAD:
11417 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
11418 pHostOffloadParams->params.hostIpv6Addr,
11419 16);
11420 break;
11421 case SIR_IPV6_NS_OFFLOAD:
11422 vos_mem_copy(wdiHostOffloadInfo->wdiHostOffloadInfo.params.aHostIpv6Addr,
11423 pHostOffloadParams->params.hostIpv6Addr,
11424 16);
11425
11426#ifdef WLAN_NS_OFFLOAD
11427 if(pHostOffloadParams->nsOffloadInfo.srcIPv6AddrValid)
11428 {
11429 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6Addr,
11430 pHostOffloadParams->nsOffloadInfo.srcIPv6Addr,
11431 16);
11432 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 1;
11433 }
11434 else
11435 {
11436 wdiHostOffloadInfo->wdiNsOffloadParams.srcIPv6AddrValid = 0;
11437 }
11438
11439 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfIPv6Addr,
11440 pHostOffloadParams->nsOffloadInfo.selfIPv6Addr,
11441 16);
11442 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.selfMacAddr,
11443 pHostOffloadParams->nsOffloadInfo.selfMacAddr,
11444 6);
11445
11446 //Only two are supported so let's go through them without a loop
11447 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[0])
11448 {
11449 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1,
11450 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[0],
11451 16);
11452 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 1;
11453 }
11454 else
11455 {
11456 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr1Valid = 0;
11457 }
11458
11459 if(pHostOffloadParams->nsOffloadInfo.targetIPv6AddrValid[1])
11460 {
11461 vos_mem_copy(wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2,
11462 pHostOffloadParams->nsOffloadInfo.targetIPv6Addr[1],
11463 16);
11464 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 1;
11465 }
11466 else
11467 {
11468 wdiHostOffloadInfo->wdiNsOffloadParams.targetIPv6Addr2Valid = 0;
11469 }
Gopichand Nakkala746a9452013-06-11 12:45:54 +0530[diff] [blame]11470 wdiHostOffloadInfo->wdiNsOffloadParams.slotIdx =
11471 pHostOffloadParams->nsOffloadInfo.slotIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11472 break;
11473#endif //WLAN_NS_OFFLOAD
11474 default:
11475 {
11476 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11477 "No Handling for Offload Type %x in WDA "
11478 , wdiHostOffloadInfo->wdiHostOffloadInfo.ucOffloadType);
11479 //WDA_VOS_ASSERT(0) ;
11480 }
11481 }
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11482 wdiHostOffloadInfo->wdiReqStatusCB = WDA_HostOffloadReqCallback;
11483 wdiHostOffloadInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11484
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11485 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11486 pWdaParams->wdaMsgParam = pHostOffloadParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11487 /* store Params pass it to WDI */
11488 pWdaParams->wdaWdiApiMsgParam = wdiHostOffloadInfo;
11489 pWdaParams->pWdaContext = pWDA;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11490
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11491
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11492 wstatus = WDI_HostOffloadReq(wdiHostOffloadInfo,
Yue Madb90ac12013-04-04 13:39:13 -0700[diff] [blame]11493 (WDI_HostOffloadCb)WDA_HostOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11494
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11495 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11496 {
11497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
c_hpothu86feba52014-10-28 15:51:18 +0530[diff] [blame]11498 "Failure in host offload REQ WDI API, free all the memory %d",
11499 wstatus);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11500 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11501 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11502 vos_mem_free(pWdaParams->wdaMsgParam);
11503 vos_mem_free(pWdaParams) ;
11504 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11505 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11506
11507}/*WDA_HostOffloadReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11508/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11509 * FUNCTION: WDA_KeepAliveRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11510 *
11511 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11512void WDA_KeepAliveRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11513{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11514 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData ;
11515
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11516 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11517 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11518
11519 if(NULL == pWdaParams)
11520 {
11521 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11522 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11523 VOS_ASSERT(0) ;
11524 return ;
11525 }
11526
11527 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11528 vos_mem_free(pWdaParams->wdaMsgParam);
11529 vos_mem_free(pWdaParams);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11530
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11531 //print a msg, nothing else to do
11532 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11533 "WDA_KeepAliveRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11534 return ;
11535}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11536/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11537 * FUNCTION: WDA_KeepAliveReqCallback
11538 * Free memory.
11539 * Invoked when KeepAlive REQ failed in WDI and no RSP callback is generated.
11540 */
11541void WDA_KeepAliveReqCallback(WDI_Status wdiStatus, void* pUserData)
11542{
11543 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11544
11545 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11546 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11547
11548 if(NULL == pWdaParams)
11549 {
11550 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11551 "%s: pWdaParams received NULL", __func__);
11552 VOS_ASSERT(0);
11553 return;
11554 }
11555
11556 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11557 {
11558 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11559 vos_mem_free(pWdaParams->wdaMsgParam);
11560 vos_mem_free(pWdaParams);
11561 }
11562
11563 return;
11564}
11565/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11566 * FUNCTION: WDA_ProcessKeepAliveReq
11567 * Request to WDI to send Keep Alive packets to minimize unnecessary host
11568 * wakeup due to broadcast traffic (sta mode).
11569 */
11570VOS_STATUS WDA_ProcessKeepAliveReq(tWDA_CbContext *pWDA,
11571 tSirKeepAliveReq *pKeepAliveParams)
11572{
11573 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11574 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11575 WDI_KeepAliveReqParamsType *wdiKeepAliveInfo =
11576 (WDI_KeepAliveReqParamsType *)vos_mem_malloc(
11577 sizeof(WDI_KeepAliveReqParamsType)) ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11578 tWDA_ReqParams *pWdaParams;
11579
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11580 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11581 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11582 if(NULL == wdiKeepAliveInfo)
11583 {
11584 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11585 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11586 VOS_ASSERT(0);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11587 vos_mem_free(pKeepAliveParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11588 return VOS_STATUS_E_NOMEM;
11589 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11590
11591 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11592 if(NULL == pWdaParams)
11593 {
11594 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11595 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11596 VOS_ASSERT(0);
11597 vos_mem_free(wdiKeepAliveInfo);
11598 vos_mem_free(pKeepAliveParams);
11599 return VOS_STATUS_E_NOMEM;
11600 }
11601
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11602 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType =
11603 pKeepAliveParams->packetType;
11604 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod =
11605 pKeepAliveParams->timePeriod;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11606
11607 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.bssId,
11608 pKeepAliveParams->bssId,
11609 sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11610
11611 if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_UNSOLICIT_ARP_RSP)
11612 {
11613 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
11614 pKeepAliveParams->hostIpv4Addr,
11615 SIR_IPV4_ADDR_LEN);
11616 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
11617 pKeepAliveParams->destIpv4Addr,
11618 SIR_IPV4_ADDR_LEN);
11619 vos_mem_copy(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
11620 pKeepAliveParams->destMacAddr,
11621 SIR_MAC_ADDR_LEN);
11622 }
11623 else if(pKeepAliveParams->packetType == SIR_KEEP_ALIVE_NULL_PKT)
11624 {
11625 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr,
11626 SIR_IPV4_ADDR_LEN,
11627 0);
11628 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr,
11629 SIR_IPV4_ADDR_LEN,
11630 0);
11631 vos_mem_set(&wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr,
11632 SIR_MAC_ADDR_LEN,
11633 0);
11634 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11635 wdiKeepAliveInfo->wdiReqStatusCB = WDA_KeepAliveReqCallback;
11636 wdiKeepAliveInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11637
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11638 /* Store param pointer as passed in by caller */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11639 pWdaParams->wdaMsgParam = pKeepAliveParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11640 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11641 pWdaParams->wdaWdiApiMsgParam = (void *)wdiKeepAliveInfo;
11642 pWdaParams->pWdaContext = pWDA;
11643
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11644 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA HIP : %d.%d.%d.%d",
11645 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[0],
11646 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[1],
11647 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[2],
11648 wdiKeepAliveInfo->wdiKeepAliveInfo.aHostIpv4Addr[3]);
11649 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,"WDA DIP : %d.%d.%d.%d",
11650 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[0],
11651 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[1],
11652 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[2],
11653 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestIpv4Addr[3]);
11654 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11655 "WDA DMAC : %d:%d:%d:%d:%d:%d",
11656 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[0],
11657 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[1],
11658 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[2],
11659 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[3],
11660 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[4],
11661 wdiKeepAliveInfo->wdiKeepAliveInfo.aDestMacAddr[5]);
11662 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11663 "TimePeriod %d PacketType %d",
11664 wdiKeepAliveInfo->wdiKeepAliveInfo.ucTimePeriod,
11665 wdiKeepAliveInfo->wdiKeepAliveInfo.ucPacketType);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11666 wstatus = WDI_KeepAliveReq(wdiKeepAliveInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11667 (WDI_KeepAliveCb)WDA_KeepAliveRespCallback, pWdaParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11668
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11669 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11670 {
11671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11672 "Failure in Keep Alive REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11673 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]11674 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
11675 vos_mem_free(pWdaParams->wdaMsgParam);
Madan Mohan Koyyalamudi683acf12012-10-30 18:10:18 -0700[diff] [blame]11676 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11677 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11678 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11679
11680}/*WDA_KeepAliveReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11681/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11682 * FUNCTION: WDA_WowlAddBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11683 *
11684 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11685void WDA_WowlAddBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11686 WDI_WowlAddBcPtrnRspParamsType *pWdiWowlAddBcstPtrRsp,
11687 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11688{
11689 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11690 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11691 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11692 if(NULL == pWdaParams)
11693 {
11694 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11695 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11696 VOS_ASSERT(0) ;
11697 return ;
11698 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11699 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11700 vos_mem_free(pWdaParams->wdaMsgParam);
11701 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11702 return ;
11703}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11704/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11705 * FUNCTION: WDA_WowlAddBcPtrnReqCallback
11706 * Free memory.
11707 * Invoked when WOWLAddBCPTRN REQ failed in WDI and no RSP callback is generated.
11708 */
11709void WDA_WowlAddBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
11710{
11711 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11712
11713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11714 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11715
11716 if(NULL == pWdaParams)
11717 {
11718 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11719 "%s: pWdaParams received NULL", __func__);
11720 VOS_ASSERT(0);
11721 return;
11722 }
11723
11724 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11725 {
11726 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11727 vos_mem_free(pWdaParams->wdaMsgParam);
11728 vos_mem_free(pWdaParams);
11729 }
11730
11731 return;
11732}
11733
11734/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11735 * FUNCTION: WDA_ProcessWowlAddBcPtrnReq
11736 * Request to WDI to add WOWL Bcast pattern
11737 */
11738VOS_STATUS WDA_ProcessWowlAddBcPtrnReq(tWDA_CbContext *pWDA,
11739 tSirWowlAddBcastPtrn *pWowlAddBcPtrnParams)
11740{
11741 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11742 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11743 WDI_WowlAddBcPtrnReqParamsType *wdiWowlAddBcPtrnInfo =
11744 (WDI_WowlAddBcPtrnReqParamsType *)vos_mem_malloc(
11745 sizeof(WDI_WowlAddBcPtrnReqParamsType)) ;
11746 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11747 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11748 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11749 if(NULL == wdiWowlAddBcPtrnInfo)
11750 {
11751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11752 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11753 VOS_ASSERT(0);
11754 return VOS_STATUS_E_NOMEM;
11755 }
11756 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11757 if(NULL == pWdaParams)
11758 {
11759 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11760 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11761 VOS_ASSERT(0);
11762 vos_mem_free(wdiWowlAddBcPtrnInfo);
11763 return VOS_STATUS_E_NOMEM;
11764 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11765 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternId =
11766 pWowlAddBcPtrnParams->ucPatternId;
11767 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternByteOffset =
11768 pWowlAddBcPtrnParams->ucPatternByteOffset;
11769 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize =
11770 pWowlAddBcPtrnParams->ucPatternMaskSize;
11771 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize =
11772 pWowlAddBcPtrnParams->ucPatternSize;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11773 if (wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize <= WDI_WOWL_BCAST_PATTERN_MAX_SIZE)
11774 {
11775 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
11776 pWowlAddBcPtrnParams->ucPattern,
11777 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize);
11778 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
11779 pWowlAddBcPtrnParams->ucPatternMask,
11780 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize);
11781 }
11782 else
11783 {
11784 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPattern,
11785 pWowlAddBcPtrnParams->ucPattern,
11786 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
11787 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMask,
11788 pWowlAddBcPtrnParams->ucPatternMask,
11789 WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
11790
11791 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternExt,
11792 pWowlAddBcPtrnParams->ucPatternExt,
11793 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
11794 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskExt,
11795 pWowlAddBcPtrnParams->ucPatternMaskExt,
11796 wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.ucPatternMaskSize - WDI_WOWL_BCAST_PATTERN_MAX_SIZE);
11797 }
11798
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11799 vos_mem_copy(wdiWowlAddBcPtrnInfo->wdiWowlAddBcPtrnInfo.bssId,
11800 pWowlAddBcPtrnParams->bssId, sizeof(wpt_macAddr));
11801
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11802 wdiWowlAddBcPtrnInfo->wdiReqStatusCB = WDA_WowlAddBcPtrnReqCallback;
11803 wdiWowlAddBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11804 /* Store param pointer as passed in by caller */
11805 /* store Params pass it to WDI */
11806 pWdaParams->wdaWdiApiMsgParam = wdiWowlAddBcPtrnInfo;
11807 pWdaParams->pWdaContext = pWDA;
11808 pWdaParams->wdaMsgParam = pWowlAddBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11809 wstatus = WDI_WowlAddBcPtrnReq(wdiWowlAddBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11810 (WDI_WowlAddBcPtrnCb)WDA_WowlAddBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11811 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11812 {
11813 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11814 "Failure in Wowl add Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11815 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11816 vos_mem_free(pWdaParams->wdaMsgParam) ;
11817 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11818 vos_mem_free(pWdaParams) ;
11819 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11820 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11821
11822}/*WDA_ProcessWowlAddBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11823/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11824 * FUNCTION: WDA_WowlDelBcPtrnRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11825 *
11826 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11827void WDA_WowlDelBcPtrnRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11828 WDI_WowlDelBcPtrnRspParamsType *pWdiWowlDelBcstPtrRsp,
11829 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11830{
11831 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11833 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11834 if(NULL == pWdaParams)
11835 {
11836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11837 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11838 VOS_ASSERT(0) ;
11839 return ;
11840 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11841 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11842 vos_mem_free(pWdaParams->wdaMsgParam);
11843 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11844 return ;
11845}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11846/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11847 * FUNCTION: WDA_WowlDelBcPtrnReqCallback
11848 * Free memory.
11849 * Invoked when WOWLDelBCPTRN REQ failed in WDI and no RSP callback is generated.
11850 */
11851void WDA_WowlDelBcPtrnReqCallback(WDI_Status wdiStatus, void* pUserData)
11852{
11853 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
11854
11855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11856 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11857
11858 if(NULL == pWdaParams)
11859 {
11860 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11861 "%s: pWdaParams received NULL", __func__);
11862 VOS_ASSERT(0);
11863 return;
11864 }
11865
11866 if(IS_WDI_STATUS_FAILURE(wdiStatus))
11867 {
11868 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11869 vos_mem_free(pWdaParams->wdaMsgParam);
11870 vos_mem_free(pWdaParams);
11871 }
11872
11873 return;
11874}
11875/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11876 * FUNCTION: WDA_ProcessWowlDelBcPtrnReq
11877 * Request to WDI to delete WOWL Bcast pattern
11878 */
11879VOS_STATUS WDA_ProcessWowlDelBcPtrnReq(tWDA_CbContext *pWDA,
11880 tSirWowlDelBcastPtrn *pWowlDelBcPtrnParams)
11881{
11882 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11883 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11884 WDI_WowlDelBcPtrnReqParamsType *wdiWowlDelBcPtrnInfo =
11885 (WDI_WowlDelBcPtrnReqParamsType *)vos_mem_malloc(
11886 sizeof(WDI_WowlDelBcPtrnReqParamsType)) ;
11887 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11888 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11889 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11890 if(NULL == wdiWowlDelBcPtrnInfo)
11891 {
11892 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11893 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11894 VOS_ASSERT(0);
11895 return VOS_STATUS_E_NOMEM;
11896 }
11897 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
11898 if(NULL == pWdaParams)
11899 {
11900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11901 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11902 VOS_ASSERT(0);
11903 vos_mem_free(wdiWowlDelBcPtrnInfo);
11904 return VOS_STATUS_E_NOMEM;
11905 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11906 wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.ucPatternId =
11907 pWowlDelBcPtrnParams->ucPatternId;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11908
11909 vos_mem_copy(wdiWowlDelBcPtrnInfo->wdiWowlDelBcPtrnInfo.bssId,
11910 pWowlDelBcPtrnParams->bssId, sizeof(wpt_macAddr));
11911
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11912 wdiWowlDelBcPtrnInfo->wdiReqStatusCB = WDA_WowlDelBcPtrnReqCallback;
11913 wdiWowlDelBcPtrnInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11914 /* Store param pointer as passed in by caller */
11915 /* store Params pass it to WDI */
11916 pWdaParams->wdaWdiApiMsgParam = wdiWowlDelBcPtrnInfo;
11917 pWdaParams->pWdaContext = pWDA;
11918 pWdaParams->wdaMsgParam = pWowlDelBcPtrnParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11919 wstatus = WDI_WowlDelBcPtrnReq(wdiWowlDelBcPtrnInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11920 (WDI_WowlDelBcPtrnCb)WDA_WowlDelBcPtrnRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11921 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11922 {
11923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11924 "Failure in Wowl delete Bcast ptrn REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11925 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11926 vos_mem_free(pWdaParams->wdaMsgParam) ;
11927 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11928 vos_mem_free(pWdaParams) ;
11929 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]11930 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11931
11932}/*WDA_ProcessWowlDelBcPtrnReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11933/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11934 * FUNCTION: WDA_WowlEnterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11935 *
11936 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11937void WDA_WowlEnterRespCallback(WDI_WowlEnterRspParamsType *pwdiWowlEnterRspParam, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11938{
11939 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11940 tWDA_CbContext *pWDA = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11941 tSirHalWowlEnterParams *pWowlEnterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11942 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11943 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11944 if(NULL == pWdaParams)
11945 {
11946 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]11947 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11948 VOS_ASSERT(0) ;
11949 return ;
11950 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11951 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11952 if (NULL == pWDA)
11953 {
11954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11955 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]11956
11957 if(pWdaParams->wdaWdiApiMsgParam)
11958 {
11959 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11960 }
11961 vos_mem_free(pWdaParams);
11962
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11963 VOS_ASSERT(0);
11964 return ;
11965 }
11966
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11967 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam ;
11968
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11969 pWowlEnterParams->bssIdx = pwdiWowlEnterRspParam->bssIdx;
11970
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11971 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
11972 vos_mem_free(pWdaParams) ;
11973
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]11974 pWowlEnterParams->status =
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]11975 (pwdiWowlEnterRspParam->status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11976 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11977 return ;
11978}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]11979/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11980 * FUNCTION: WDA_WowlEnterReqCallback
11981 * Free memory and send WOWL Enter RSP back to PE.
11982 * Invoked when WOWL Enter REQ failed in WDI and no RSP callback is generated.
11983 */
11984void WDA_WowlEnterReqCallback(WDI_Status wdiStatus, void* pUserData)
11985{
11986 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]11987 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]11988 tSirHalWowlEnterParams *pWowlEnterParams;
11989
11990 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
11991 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
11992
11993 if(NULL == pWdaParams)
11994 {
11995 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
11996 "%s: pWdaParams received NULL", __func__);
11997 VOS_ASSERT(0);
11998 return;
11999 }
12000
12001 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12002 if (NULL == pWDA)
12003 {
12004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12005 "%s:pWDA is NULL", __func__);
12006 VOS_ASSERT(0);
12007 return ;
12008 }
12009
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12010 pWowlEnterParams = (tSirHalWowlEnterParams *)pWdaParams->wdaMsgParam;
12011 pWowlEnterParams->status = wdiStatus;
12012
12013 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12014 {
12015 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12016 vos_mem_free(pWdaParams);
12017 WDA_SendMsg(pWDA, WDA_WOWL_ENTER_RSP, (void *)pWowlEnterParams , 0);
12018 }
12019
12020 return;
12021}
12022/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12023 * FUNCTION: WDA_ProcessWowlEnterReq
12024 * Request to WDI to enter WOWL
12025 */
12026VOS_STATUS WDA_ProcessWowlEnterReq(tWDA_CbContext *pWDA,
12027 tSirHalWowlEnterParams *pWowlEnterParams)
12028{
12029 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12030 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12031 WDI_WowlEnterReqParamsType *wdiWowlEnterInfo =
12032 (WDI_WowlEnterReqParamsType *)vos_mem_malloc(
12033 sizeof(WDI_WowlEnterReqParamsType)) ;
12034 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12036 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12037 if(NULL == wdiWowlEnterInfo)
12038 {
12039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12040 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12041 VOS_ASSERT(0);
12042 return VOS_STATUS_E_NOMEM;
12043 }
12044 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12045 if(NULL == pWdaParams)
12046 {
12047 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12048 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12049 VOS_ASSERT(0);
12050 vos_mem_free(wdiWowlEnterInfo);
12051 return VOS_STATUS_E_NOMEM;
12052 }
Kumar Anandaca924e2013-07-22 14:35:34 -0700[diff] [blame]12053
12054 vos_mem_zero(pWdaParams, sizeof(tWDA_ReqParams));
12055
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12056 vos_mem_copy(wdiWowlEnterInfo->wdiWowlEnterInfo.magicPtrn,
12057 pWowlEnterParams->magicPtrn,
12058 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12059 wdiWowlEnterInfo->wdiWowlEnterInfo.ucMagicPktEnable =
12060 pWowlEnterParams->ucMagicPktEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12061 wdiWowlEnterInfo->wdiWowlEnterInfo.ucPatternFilteringEnable =
12062 pWowlEnterParams->ucPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12063 wdiWowlEnterInfo->wdiWowlEnterInfo.ucUcastPatternFilteringEnable =
12064 pWowlEnterParams->ucUcastPatternFilteringEnable;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12065 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowChnlSwitchRcv =
12066 pWowlEnterParams->ucWowChnlSwitchRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12067 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDeauthRcv =
12068 pWowlEnterParams->ucWowDeauthRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12069 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowDisassocRcv =
12070 pWowlEnterParams->ucWowDisassocRcv;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12071 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxMissedBeacons =
12072 pWowlEnterParams->ucWowMaxMissedBeacons;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12073 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowMaxSleepUsec =
12074 pWowlEnterParams->ucWowMaxSleepUsec;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12075#ifdef WLAN_WAKEUP_EVENTS
12076 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPIDRequestEnable =
12077 pWowlEnterParams->ucWoWEAPIDRequestEnable;
12078
12079 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWEAPOL4WayEnable =
12080 pWowlEnterParams->ucWoWEAPOL4WayEnable;
12081
12082 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowNetScanOffloadMatch =
12083 pWowlEnterParams->ucWowNetScanOffloadMatch;
12084
12085 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWowGTKRekeyError =
12086 pWowlEnterParams->ucWowGTKRekeyError;
12087
12088 wdiWowlEnterInfo->wdiWowlEnterInfo.ucWoWBSSConnLoss =
12089 pWowlEnterParams->ucWoWBSSConnLoss;
12090#endif // WLAN_WAKEUP_EVENTS
12091
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12092 wdiWowlEnterInfo->wdiWowlEnterInfo.bssIdx =
12093 pWowlEnterParams->bssIdx;
12094
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12095 wdiWowlEnterInfo->wdiReqStatusCB = WDA_WowlEnterReqCallback;
12096 wdiWowlEnterInfo->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12097 /* Store param pointer as passed in by caller */
12098 /* store Params pass it to WDI */
12099 pWdaParams->wdaWdiApiMsgParam = wdiWowlEnterInfo;
12100 pWdaParams->pWdaContext = pWDA;
12101 pWdaParams->wdaMsgParam = pWowlEnterParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12102 wstatus = WDI_WowlEnterReq(wdiWowlEnterInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12103 (WDI_WowlEnterReqCb)WDA_WowlEnterRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12104 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12105 {
12106 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12107 "Failure in Wowl enter REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12108 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12109 vos_mem_free(pWdaParams->wdaMsgParam) ;
12110 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12111 vos_mem_free(pWdaParams) ;
12112 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12113 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12114
12115}/*WDA_ProcessWowlEnterReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12116/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12117 * FUNCTION: WDA_WowlExitRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12118 *
12119 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12120void WDA_WowlExitRespCallback( WDI_WowlExitRspParamsType *pwdiWowlExitRsp, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12121{
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12122 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12123 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12124 tSirHalWowlExitParams *pWowlExitParams;
12125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12126 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12127 if(NULL == pWdaParams)
12128 {
12129 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12130 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12131 VOS_ASSERT(0) ;
12132 return ;
12133 }
12134 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12135 if (NULL == pWDA)
12136 {
12137 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12138 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]12139
12140 if(pWdaParams->wdaWdiApiMsgParam)
12141 {
12142 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12143 }
12144 vos_mem_free(pWdaParams);
12145
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12146 VOS_ASSERT(0);
12147 return ;
12148 }
12149
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12150 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam ;
12151
12152 pWowlExitParams->bssIdx = pwdiWowlExitRsp->bssIdx;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]12153 pWowlExitParams->status = (pwdiWowlExitRsp->status);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12154
12155 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12156 vos_mem_free(pWdaParams) ;
12157
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12158 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12159 "<------ %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12160 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12161 return ;
12162}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12163/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12164 * FUNCTION: WDA_WowlExitReqCallback
12165 * Free memory and send WOWL Exit RSP back to PE.
12166 * Invoked when WOWL Exit REQ failed in WDI and no RSP callback is generated.
12167 */
12168void WDA_WowlExitReqCallback(WDI_Status wdiStatus, void* pUserData)
12169{
12170 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12171 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12172 tSirHalWowlExitParams *pWowlExitParams;
12173
12174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12175 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
12176
12177 if(NULL == pWdaParams)
12178 {
12179 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12180 "%s: pWdaParams received NULL", __func__);
12181 VOS_ASSERT(0);
12182 return;
12183 }
12184
12185 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12186 if (NULL == pWDA)
12187 {
12188 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12189 "%s:pWDA is NULL", __func__);
12190 VOS_ASSERT(0);
12191 return ;
12192 }
12193
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12194 pWowlExitParams = (tSirHalWowlExitParams *)pWdaParams->wdaMsgParam;
12195 pWowlExitParams->status = wdiStatus;
12196
12197 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12198 {
12199 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12200 vos_mem_free(pWdaParams);
12201 WDA_SendMsg(pWDA, WDA_WOWL_EXIT_RSP, (void *)pWowlExitParams, 0);
12202 }
12203
12204 return;
12205}
12206/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12207 * FUNCTION: WDA_ProcessWowlExitReq
12208 * Request to WDI to add WOWL Bcast pattern
12209 */
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12210VOS_STATUS WDA_ProcessWowlExitReq(tWDA_CbContext *pWDA,
12211 tSirHalWowlExitParams *pWowlExitParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12212{
12213 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12214 WDI_Status wstatus;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12215 WDI_WowlExitReqParamsType *wdiWowlExitInfo =
12216 (WDI_WowlExitReqParamsType *)vos_mem_malloc(
12217 sizeof(WDI_WowlExitReqParamsType)) ;
12218 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12219 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12220 "------> %s " ,__func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12221 if(NULL == wdiWowlExitInfo)
12222 {
12223 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12224 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12225 VOS_ASSERT(0);
12226 return VOS_STATUS_E_NOMEM;
12227 }
12228 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12229 if(NULL == pWdaParams)
12230 {
12231 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12232 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12233 VOS_ASSERT(0);
12234 vos_mem_free(wdiWowlExitInfo);
12235 return VOS_STATUS_E_NOMEM;
12236 }
12237
12238 wdiWowlExitInfo->wdiWowlExitInfo.bssIdx =
12239 pWowlExitParams->bssIdx;
12240
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12241 wdiWowlExitInfo->wdiReqStatusCB = WDA_WowlExitReqCallback;
12242 wdiWowlExitInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12243
12244 /* Store param pointer as passed in by caller */
12245 /* store Params pass it to WDI */
12246 pWdaParams->wdaWdiApiMsgParam = wdiWowlExitInfo;
12247 pWdaParams->pWdaContext = pWDA;
12248 pWdaParams->wdaMsgParam = pWowlExitParams;
12249
12250 wstatus = WDI_WowlExitReq(wdiWowlExitInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12251 (WDI_WowlExitReqCb)WDA_WowlExitRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12252
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12253 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12254 {
12255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12256 "Failure in Wowl exit REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12257 status = CONVERT_WDI2VOS_STATUS(wstatus);
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12258 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12259 vos_mem_free(pWdaParams->wdaMsgParam);
12260 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12261 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]12262 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12263}/*WDA_ProcessWowlExitReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12264/*
12265 * FUNCTION: WDA_IsHwFrameTxTranslationCapable
12266 * Request to WDI to determine whether a given station is capable of
12267 * using HW-based frame translation
12268 */
12269v_BOOL_t WDA_IsHwFrameTxTranslationCapable(v_PVOID_t pVosGCtx,
12270 tANI_U8 staIdx)
12271{
12272 return WDI_IsHwFrameTxTranslationCapable(staIdx);
12273}
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]12274
12275/*
12276 * FUNCTION: WDA_IsSelfSTA
12277 * Request to WDI to determine whether a given STAID is self station
12278 * index.
12279 */
12280v_BOOL_t WDA_IsSelfSTA(v_PVOID_t pVosContext, tANI_U8 ucSTAIdx)
12281{
12282
12283 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
12284
Girish Gowli05cf44e2014-06-12 21:53:37 +0530[diff] [blame]12285 if (NULL != pWDA)
12286 return WDI_IsSelfSTA(pWDA->pWdiContext,ucSTAIdx);
12287 else
12288 return VOS_TRUE;
Katya Nigam6201c3e2014-05-27 17:51:42 +0530[diff] [blame]12289}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12290/*
12291 * FUNCTION: WDA_NvDownloadReqCallback
12292 * send NV Download RSP back to PE
12293 */
12294void WDA_NvDownloadReqCallback(WDI_NvDownloadRspInfoType *pNvDownloadRspParams,
12295 void* pUserData)
12296{
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12297
12298 tWDA_ReqParams *pWdaParams= ( tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12299 tWDA_CbContext *pWDA = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12300
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12301 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12302 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12303
12304 if(NULL == pWdaParams)
12305 {
12306 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12307 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12308 VOS_ASSERT(0) ;
12309 return ;
12310 }
12311
12312 pWDA = pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12313 if (NULL == pWDA)
12314 {
12315 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12316 "%s:pWDA is NULL", __func__);
Anand N Sunkadc5ab6092015-03-16 14:22:00 +0530[diff] [blame]12317
12318 if(pWdaParams->wdaWdiApiMsgParam)
12319 {
12320 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12321 }
12322 vos_mem_free(pWdaParams);
12323
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12324 VOS_ASSERT(0);
12325 return ;
12326 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12327
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12328 /*Cleaning */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12329 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12330 vos_mem_free(pWdaParams);
12331
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12332 vos_WDAComplete_cback(pWDA->pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12333 return ;
12334}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12335/*
12336 * FUNCTION: WDA_ProcessNvDownloadReq
12337 * Read the NV blob to a buffer and send a request to WDI to download the blob to NV memory.
12338 */
12339VOS_STATUS WDA_NVDownload_Start(v_PVOID_t pVosContext)
12340{
12341 /* Initialize the local Variables*/
12342 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
12343 v_VOID_t *pNvBuffer=NULL;
12344 v_SIZE_t bufferSize = 0;
12345 WDI_Status status = WDI_STATUS_E_FAILURE;
12346 WDI_NvDownloadReqParamsType * wdiNvDownloadReqParam =NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12347 tWDA_ReqParams *pWdaParams ;
12348
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12349 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12350 "------> %s " ,__func__);
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12351 if (NULL == pWDA)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12352 {
12353 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12354 "%s:pWDA is NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12355 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12356 return VOS_STATUS_E_FAILURE;
12357 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12358
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12359 /* Get the NV structure base address and size from VOS */
Prasanna Kumarf6c94ae2013-04-11 20:05:21 -0700[diff] [blame]12360 vos_nv_getNVEncodedBuffer(&pNvBuffer,&bufferSize);
12361
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12362 wdiNvDownloadReqParam = (WDI_NvDownloadReqParamsType *)vos_mem_malloc(
12363 sizeof(WDI_NvDownloadReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12364 if(NULL == wdiNvDownloadReqParam)
12365 {
12366 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12367 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12368 VOS_ASSERT(0);
12369 return VOS_STATUS_E_NOMEM;
12370 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12371 /* Copy Params to wdiNvDownloadReqParam*/
12372 wdiNvDownloadReqParam->wdiBlobInfo.pBlobAddress = pNvBuffer;
12373 wdiNvDownloadReqParam->wdiBlobInfo.uBlobSize = bufferSize;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12374
12375 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12376 if(NULL == pWdaParams)
12377 {
12378 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12379 "%s: VOS MEM Alloc Failure", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12380 VOS_ASSERT(0);
12381 vos_mem_free(wdiNvDownloadReqParam);
12382 return VOS_STATUS_E_NOMEM;
12383 }
12384
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12385 /* store Params pass it to WDI */
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12386 pWdaParams->wdaWdiApiMsgParam = (void *)wdiNvDownloadReqParam ;
12387 pWdaParams->wdaMsgParam = NULL;
12388 pWdaParams->pWdaContext = pWDA;
12389
12390
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12391 wdiNvDownloadReqParam->wdiReqStatusCB = NULL ;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12392
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12393 status = WDI_NvDownloadReq(wdiNvDownloadReqParam,
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12394 (WDI_NvDownloadRspCb)WDA_NvDownloadReqCallback,(void *)pWdaParams);
12395
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12396 if(IS_WDI_STATUS_FAILURE(status))
12397 {
12398 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12399 "Failure in NV Download REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12400 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12401 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12402 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12403 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12404}
12405/*
12406 * FUNCTION: WDA_FlushAcReqCallback
12407 * send Flush AC RSP back to TL
12408 */
12409void WDA_FlushAcReqCallback(WDI_Status status, void* pUserData)
12410{
12411 vos_msg_t wdaMsg = {0} ;
12412 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
12413 tFlushACReq *pFlushACReqParams;
12414 tFlushACRsp *pFlushACRspParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12415 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12416 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12417 if(NULL == pWdaParams)
12418 {
12419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12420 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12421 VOS_ASSERT(0) ;
12422 return ;
12423 }
12424
12425 pFlushACReqParams = (tFlushACReq *)pWdaParams->wdaMsgParam;
12426 pFlushACRspParams = vos_mem_malloc(sizeof(tFlushACRsp));
12427 if(NULL == pFlushACRspParams)
12428 {
12429 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12430 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12431 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]12432 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12433 return ;
12434 }
12435 vos_mem_zero(pFlushACRspParams,sizeof(tFlushACRsp));
12436 pFlushACRspParams->mesgLen = sizeof(tFlushACRsp);
12437 pFlushACRspParams->mesgType = WDA_TL_FLUSH_AC_RSP;
12438 pFlushACRspParams->ucSTAId = pFlushACReqParams->ucSTAId;
12439 pFlushACRspParams->ucTid = pFlushACReqParams->ucTid;
Venkata Prathyusha Kuntupalli778f4792013-03-21 14:18:02 -0700[diff] [blame]12440 pFlushACRspParams->status = (status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12441 vos_mem_free(pWdaParams->wdaMsgParam) ;
12442 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12443 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12444 wdaMsg.type = WDA_TL_FLUSH_AC_RSP ;
12445 wdaMsg.bodyptr = (void *)pFlushACRspParams;
12446 // POST message to TL
12447 vos_mq_post_message(VOS_MQ_ID_TL, (vos_msg_t *) &wdaMsg);
12448
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12449 return ;
12450}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12451/*
12452 * FUNCTION: WDA_ProcessFlushAcReq
12453 * Request to WDI to Update the DELBA REQ params.
12454 */
12455VOS_STATUS WDA_ProcessFlushAcReq(tWDA_CbContext *pWDA,
12456 tFlushACReq *pFlushAcReqParams)
12457{
12458 WDI_Status status = WDI_STATUS_SUCCESS ;
12459 WDI_FlushAcReqParamsType *wdiFlushAcReqParam =
12460 (WDI_FlushAcReqParamsType *)vos_mem_malloc(
12461 sizeof(WDI_FlushAcReqParamsType)) ;
12462 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12463 if(NULL == wdiFlushAcReqParam)
12464 {
12465 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12466 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12467 VOS_ASSERT(0);
12468 return VOS_STATUS_E_NOMEM;
12469 }
12470 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12471 if(NULL == pWdaParams)
12472 {
12473 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12474 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12475 VOS_ASSERT(0);
12476 vos_mem_free(wdiFlushAcReqParam);
12477 return VOS_STATUS_E_NOMEM;
12478 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12479 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12480 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12481 wdiFlushAcReqParam->wdiFlushAcInfo.ucSTAId = pFlushAcReqParams->ucSTAId;
12482 wdiFlushAcReqParam->wdiFlushAcInfo.ucTid = pFlushAcReqParams->ucTid;
12483 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgLen = pFlushAcReqParams->mesgLen;
12484 wdiFlushAcReqParam->wdiFlushAcInfo.usMesgType = pFlushAcReqParams->mesgType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12485 /* Store Flush AC pointer, as this will be used for response */
12486 /* store Params pass it to WDI */
12487 pWdaParams->pWdaContext = pWDA;
12488 pWdaParams->wdaMsgParam = pFlushAcReqParams;
12489 pWdaParams->wdaWdiApiMsgParam = wdiFlushAcReqParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12490 status = WDI_FlushAcReq(wdiFlushAcReqParam,
12491 (WDI_FlushAcRspCb)WDA_FlushAcReqCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12492 if(IS_WDI_STATUS_FAILURE(status))
12493 {
12494 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12495 "Failure in Flush AC REQ Params WDI API, free all the memory " );
12496 vos_mem_free(pWdaParams->wdaMsgParam) ;
12497 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12498 vos_mem_free(pWdaParams) ;
12499 //TODO: respond to TL with failure
12500 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12501 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12502}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12503/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12504 * FUNCTION: WDA_BtAmpEventRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12505 *
12506 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12507void WDA_BtAmpEventRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12508{
12509 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12510 tWDA_CbContext *pWDA = NULL;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12511 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12512
12513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12514 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12515 if(NULL == pWdaParams)
12516 {
12517 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12518 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12519 VOS_ASSERT(0) ;
12520 return ;
12521 }
12522 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12523 if (NULL == pWDA)
12524 {
12525 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12526 "%s:pWDA is NULL", __func__);
Hema Aparna Medicharla749399f2015-03-10 13:02:04 +0530[diff] [blame]12527 vos_mem_free(pWdaParams->wdaMsgParam) ;
12528 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12529 vos_mem_free(pWdaParams) ;
12530
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12531 VOS_ASSERT(0);
12532 return ;
12533 }
12534
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12535 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
12536 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
12537 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
12538 {
12539 pWDA->wdaAmpSessionOn = VOS_FALSE;
12540 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12541 vos_mem_free(pWdaParams->wdaMsgParam) ;
12542 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12543 vos_mem_free(pWdaParams) ;
12544 /*
12545 * No respone required for WDA_SIGNAL_BTAMP_EVENT so just free the request
12546 * param here
12547 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12548 return ;
12549}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12550/*
12551 * FUNCTION: WDA_BtAmpEventReqCallback
12552 * Free memory.
12553 * Invoked when BTAMPEvent REQ failed in WDI and no RSP callback is generated.
12554 */
12555void WDA_BtAmpEventReqCallback(WDI_Status wdiStatus, void* pUserData)
12556{
12557 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12558 tWDA_CbContext *pWDA = NULL;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12559 WDI_BtAmpEventParamsType *wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12560
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12561 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12562 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
12563
12564 if(NULL == pWdaParams)
12565 {
12566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12567 "%s: pWdaParams received NULL", __func__);
12568 VOS_ASSERT(0);
12569 return;
12570 }
12571
12572 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12573 if (NULL == pWDA)
12574 {
12575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12576 "%s:pWDA is NULL", __func__);
12577 VOS_ASSERT(0);
12578 return ;
12579 }
12580
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12581 wdiBtAmpEventParam = (WDI_BtAmpEventParamsType *)pWdaParams->wdaWdiApiMsgParam;
12582
12583 if(BTAMP_EVENT_CONNECTION_TERMINATED ==
12584 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
12585 {
12586 pWDA->wdaAmpSessionOn = VOS_FALSE;
12587 }
12588
12589 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12590 {
12591 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12592 vos_mem_free(pWdaParams->wdaMsgParam);
12593 vos_mem_free(pWdaParams);
12594 }
12595
12596 return;
12597}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12598/*
12599 * FUNCTION: WDA_ProcessBtAmpEventReq
12600 * Request to WDI to Update with BT AMP events.
12601 */
12602VOS_STATUS WDA_ProcessBtAmpEventReq(tWDA_CbContext *pWDA,
12603 tSmeBtAmpEvent *pBtAmpEventParams)
12604{
12605 WDI_Status status = WDI_STATUS_SUCCESS ;
12606 WDI_BtAmpEventParamsType *wdiBtAmpEventParam =
12607 (WDI_BtAmpEventParamsType *)vos_mem_malloc(
12608 sizeof(WDI_BtAmpEventParamsType)) ;
12609 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12610 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12611 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12612 if(NULL == wdiBtAmpEventParam)
12613 {
12614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12615 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12616 VOS_ASSERT(0);
12617 return VOS_STATUS_E_NOMEM;
12618 }
12619 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12620 if(NULL == pWdaParams)
12621 {
12622 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12623 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12624 VOS_ASSERT(0);
12625 vos_mem_free(wdiBtAmpEventParam);
12626 return VOS_STATUS_E_NOMEM;
12627 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12628 wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType =
12629 pBtAmpEventParams->btAmpEventType;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12630 wdiBtAmpEventParam->wdiReqStatusCB = WDA_BtAmpEventReqCallback;
12631 wdiBtAmpEventParam->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12632 /* Store BT AMP event pointer, as this will be used for response */
12633 /* store Params pass it to WDI */
12634 pWdaParams->pWdaContext = pWDA;
12635 pWdaParams->wdaMsgParam = pBtAmpEventParams;
12636 pWdaParams->wdaWdiApiMsgParam = wdiBtAmpEventParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12637 status = WDI_BtAmpEventReq(wdiBtAmpEventParam,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12638 (WDI_BtAmpEventRspCb)WDA_BtAmpEventRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12639 if(IS_WDI_STATUS_FAILURE(status))
12640 {
12641 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12642 "Failure in BT AMP event REQ Params WDI API, free all the memory " );
12643 vos_mem_free(pWdaParams->wdaMsgParam) ;
12644 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12645 vos_mem_free(pWdaParams) ;
12646 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12647 if(BTAMP_EVENT_CONNECTION_START == wdiBtAmpEventParam->wdiBtAmpEventInfo.ucBtAmpEventType)
12648 {
12649 pWDA->wdaAmpSessionOn = VOS_TRUE;
12650 }
12651 return CONVERT_WDI2VOS_STATUS(status) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12652}
12653
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12654/*
12655 * FUNCTION: WDA_FTMCommandReqCallback
12656 * Handle FTM CMD response came from HAL
12657 * Route responce to HDD FTM
12658 */
12659void WDA_FTMCommandReqCallback(void *ftmCmdRspData,
12660 void *usrData)
12661{
12662 tWDA_CbContext *pWDA = (tWDA_CbContext *)usrData ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12663 if((NULL == pWDA) || (NULL == ftmCmdRspData))
12664 {
12665 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]12666 "%s, invalid input %p, %p",__func__, pWDA, ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12667 return;
12668 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12669 /* Release Current FTM Command Request */
12670 vos_mem_free(pWDA->wdaFTMCmdReq);
12671 pWDA->wdaFTMCmdReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12672 /* Post FTM Responce to HDD FTM */
12673 wlan_sys_ftm(ftmCmdRspData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12674 return;
12675}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12676/*
12677 * FUNCTION: WDA_ProcessFTMCommand
12678 * Send FTM command to WDI
12679 */
12680VOS_STATUS WDA_ProcessFTMCommand(tWDA_CbContext *pWDA,
12681 tPttMsgbuffer *pPTTFtmCmd)
12682{
12683 WDI_Status status = WDI_STATUS_SUCCESS;
12684 WDI_FTMCommandReqType *ftmCMDReq = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12685 ftmCMDReq = (WDI_FTMCommandReqType *)
12686 vos_mem_malloc(sizeof(WDI_FTMCommandReqType));
12687 if(NULL == ftmCMDReq)
12688 {
12689 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12690 "WDA FTM Command buffer alloc fail");
12691 return VOS_STATUS_E_NOMEM;
12692 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12693 ftmCMDReq->bodyLength = pPTTFtmCmd->msgBodyLength;
12694 ftmCMDReq->FTMCommandBody = (void *)pPTTFtmCmd;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12695 pWDA->wdaFTMCmdReq = (void *)ftmCMDReq;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12696 /* Send command to WDI */
12697 status = WDI_FTMCommandReq(ftmCMDReq, WDA_FTMCommandReqCallback, pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12698 return status;
12699}
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12700#ifdef FEATURE_OEM_DATA_SUPPORT
12701/*
12702 * FUNCTION: WDA_StartOemDataReqCallback
12703 *
12704 */
12705void WDA_StartOemDataReqCallback(
12706 WDI_oemDataRspParamsType *wdiOemDataRspParams,
12707 void* pUserData)
12708{
12709 VOS_STATUS status = VOS_STATUS_E_FAILURE;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12710 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12711 tWDA_CbContext *pWDA = NULL;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12712 tStartOemDataRsp *pOemDataRspParams = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12713
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12715 "<------ %s " ,__func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12716
12717 if(NULL == pWdaParams)
12718 {
12719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12720 "%s: pWdaParams received NULL", __func__);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12721 VOS_ASSERT(0) ;
12722 return ;
12723 }
12724 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
12725
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12726 if (NULL == pWDA)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12727 {
12728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12729 "%s:pWDA is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12730 VOS_ASSERT(0);
12731 return ;
12732 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]12733
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12734 /*
12735 * Allocate memory for response params sent to PE
12736 */
12737 pOemDataRspParams = vos_mem_malloc(sizeof(tStartOemDataRsp));
12738
12739 // Check if memory is allocated for OemdataMeasRsp Params.
12740 if(NULL == pOemDataRspParams)
12741 {
12742 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12743 "OEM DATA WDA callback alloc fail");
12744 VOS_ASSERT(0) ;
12745 return;
12746 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12747
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12748 // Free the memory allocated during request.
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12749 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12750 vos_mem_free(pWdaParams->wdaMsgParam);
12751 vos_mem_free(pWdaParams) ;
12752
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12753 /*
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]12754 * Now go ahead and copy other stuff for PE in incase of success only
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12755 * Also, here success always means that we have atleast one BSSID.
12756 */
12757 vos_mem_copy(pOemDataRspParams->oemDataRsp, wdiOemDataRspParams->oemDataRsp, OEM_DATA_RSP_SIZE);
12758
12759 //enable Tx
12760 status = WDA_ResumeDataTx(pWDA);
12761 if(status != VOS_STATUS_SUCCESS)
12762 {
12763 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL, "WDA Resume Data Tx fail");
12764 }
12765 WDA_SendMsg(pWDA, WDA_START_OEM_DATA_RSP, (void *)pOemDataRspParams, 0) ;
12766 return ;
12767}
12768/*
12769 * FUNCTION: WDA_ProcessStartOemDataReq
12770 * Send Start Oem Data Req to WDI
12771 */
12772VOS_STATUS WDA_ProcessStartOemDataReq(tWDA_CbContext *pWDA,
12773 tStartOemDataReq *pOemDataReqParams)
12774{
12775 WDI_Status status = WDI_STATUS_SUCCESS;
12776 WDI_oemDataReqParamsType *wdiOemDataReqParams = NULL;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12777 tWDA_ReqParams *pWdaParams ;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12778
12779 wdiOemDataReqParams = (WDI_oemDataReqParamsType*)vos_mem_malloc(sizeof(WDI_oemDataReqParamsType)) ;
12780
12781 if(NULL == wdiOemDataReqParams)
12782 {
12783 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12784 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12785 VOS_ASSERT(0);
12786 return VOS_STATUS_E_NOMEM;
12787 }
12788
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12789 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.selfMacAddr,
12790 pOemDataReqParams->selfMacAddr, sizeof(tSirMacAddr));
12791 vos_mem_copy(wdiOemDataReqParams->wdiOemDataReqInfo.oemDataReq,
12792 pOemDataReqParams->oemDataReq, OEM_DATA_REQ_SIZE);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12793
12794 wdiOemDataReqParams->wdiReqStatusCB = NULL;
12795
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12796 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12797 if(NULL == pWdaParams)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12798 {
12799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12800 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12801 vos_mem_free(wdiOemDataReqParams);
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12802 vos_mem_free(pOemDataReqParams);
12803 VOS_ASSERT(0);
12804 return VOS_STATUS_E_NOMEM;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12805 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12806
Bernald44a1ae2013-01-09 08:30:39 -0800[diff] [blame]12807 pWdaParams->pWdaContext = (void*)pWDA;
12808 pWdaParams->wdaMsgParam = (void*)pOemDataReqParams;
12809 pWdaParams->wdaWdiApiMsgParam = (void*)wdiOemDataReqParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12810
12811 status = WDI_StartOemDataReq(wdiOemDataReqParams,
12812 (WDI_oemDataRspCb)WDA_StartOemDataReqCallback, pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12813
12814 if(IS_WDI_STATUS_FAILURE(status))
12815 {
12816 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12817 "Failure in Start OEM DATA REQ Params WDI API, free all the memory " );
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]12818 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
12819 vos_mem_free(pWdaParams->wdaMsgParam);
12820 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]12821 }
12822 return CONVERT_WDI2VOS_STATUS(status) ;
12823}
12824#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12825/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12826 * FUNCTION: WDA_SetTxPerTrackingRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12827 *
12828 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12829void WDA_SetTxPerTrackingRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12830{
12831 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12832 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12833 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12834 if(NULL == pWdaParams)
12835 {
12836 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12837 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12838 VOS_ASSERT(0) ;
12839 return ;
12840 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12841
12842 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12843 vos_mem_free(pWdaParams->wdaMsgParam);
12844 vos_mem_free(pWdaParams);
12845
12846 return ;
12847}
12848/*
12849 * FUNCTION: WDA_SetTxPerTrackingReqCallback
12850 * Free memory.
12851 * Invoked when SetTXPerTracking REQ failed in WDI and no RSP callback is generated.
12852 */
12853void WDA_SetTxPerTrackingReqCallback(WDI_Status wdiStatus, void* pUserData)
12854{
12855 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
12856
12857 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12858 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
12859
12860 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12861 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12862 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12863 "%s: pWdaParams received NULL", __func__);
12864 VOS_ASSERT(0);
12865 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12866 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12867
12868 if(IS_WDI_STATUS_FAILURE(wdiStatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12869 {
12870 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12871 vos_mem_free(pWdaParams->wdaMsgParam);
12872 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12873 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12874
12875 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12876}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12877#ifdef WLAN_FEATURE_GTK_OFFLOAD
12878/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12879 * FUNCTION: WDA_GTKOffloadRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12880 *
12881 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12882void WDA_GTKOffloadRespCallback( WDI_GtkOffloadRspParams *pwdiGtkOffloadRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12883 void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12884{
12885 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
12886
12887 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12888 "<------ %s " ,__func__);
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]12889 if(NULL == pWdaParams)
12890 {
12891 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12892 "%s: pWdaParams received NULL", __func__);
12893 VOS_ASSERT(0);
12894 return;
12895 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12896
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12897 vos_mem_free(pWdaParams->wdaMsgParam) ;
12898 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12899 vos_mem_free(pWdaParams) ;
12900
12901 //print a msg, nothing else to do
12902 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12903 "WDA_GTKOffloadRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12904
12905 return ;
12906}
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12907/*
12908 * FUNCTION: WDA_GTKOffloadReqCallback
12909 * Free memory.
12910 * Invoked when GTKOffload REQ failed in WDI and no RSP callback is generated.
12911 */
12912void WDA_GTKOffloadReqCallback(WDI_Status wdiStatus, void* pUserData)
12913{
12914 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12915
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
12917 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
12918
12919 if(NULL == pWdaParams)
12920 {
12921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
12922 "%s: pWdaParams received NULL", __func__);
12923 VOS_ASSERT(0);
12924 return;
12925 }
12926
12927 if(IS_WDI_STATUS_FAILURE(wdiStatus))
12928 {
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]12929 vos_mem_zero(pWdaParams->wdaWdiApiMsgParam,
12930 sizeof(WDI_GtkOffloadReqMsg));
12931 vos_mem_zero(pWdaParams->wdaMsgParam,
12932 sizeof(tSirGtkOffloadParams));
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12933 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
12934 vos_mem_free(pWdaParams->wdaMsgParam);
12935 vos_mem_free(pWdaParams);
12936 }
12937
12938 return;
12939}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12940/*
12941 * FUNCTION: WDA_ProcessGTKOffloadReq
12942 * Request to WDI to set the filter to minimize unnecessary host wakeup due
12943 * to broadcast traffic (sta mode).
12944 */
12945VOS_STATUS WDA_ProcessGTKOffloadReq(tWDA_CbContext *pWDA,
12946 tpSirGtkOffloadParams pGtkOffloadParams)
12947{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]12948 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12949 WDI_GtkOffloadReqMsg *wdiGtkOffloadReqMsg =
12950 (WDI_GtkOffloadReqMsg *)vos_mem_malloc(
12951 sizeof(WDI_GtkOffloadReqMsg)) ;
12952 tWDA_ReqParams *pWdaParams ;
12953
12954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12955 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12956
12957 if(NULL == wdiGtkOffloadReqMsg)
12958 {
12959 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12960 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12961 VOS_ASSERT(0);
12962 return VOS_STATUS_E_NOMEM;
12963 }
12964
12965 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
12966 if(NULL == pWdaParams)
12967 {
12968 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]12969 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12970 VOS_ASSERT(0);
12971 vos_mem_free(wdiGtkOffloadReqMsg);
12972 return VOS_STATUS_E_NOMEM;
12973 }
12974
12975 //
12976 // Fill wdiGtkOffloadInfo from pGtkOffloadParams
12977 //
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12978
12979 vos_mem_copy(wdiGtkOffloadReqMsg->gtkOffloadReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]12980 pGtkOffloadParams->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]12981
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12982 wdiGtkOffloadReqMsg->gtkOffloadReqParams.ulFlags = pGtkOffloadParams->ulFlags;
12983 // Copy KCK
12984 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKCK[0]), &(pGtkOffloadParams->aKCK[0]), 16);
12985 // Copy KEK
12986 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.aKEK[0]), &(pGtkOffloadParams->aKEK[0]), 16);
12987 // Copy KeyReplayCounter
12988 vos_mem_copy(&(wdiGtkOffloadReqMsg->gtkOffloadReqParams.ullKeyReplayCounter),
12989 &(pGtkOffloadParams->ullKeyReplayCounter), sizeof(v_U64_t));
12990
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]12991 wdiGtkOffloadReqMsg->wdiReqStatusCB = WDA_GTKOffloadReqCallback;
12992 wdiGtkOffloadReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12993
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]12994
12995 /* Store Params pass it to WDI */
12996 pWdaParams->wdaWdiApiMsgParam = (void *)wdiGtkOffloadReqMsg;
12997 pWdaParams->pWdaContext = pWDA;
12998 /* Store param pointer as passed in by caller */
12999 pWdaParams->wdaMsgParam = pGtkOffloadParams;
13000
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13001 status = WDI_GTKOffloadReq(wdiGtkOffloadReqMsg, (WDI_GtkOffloadCb)WDA_GTKOffloadRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13002
13003 if(IS_WDI_STATUS_FAILURE(status))
13004 {
13005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13006 "Failure in WDA_ProcessGTKOffloadReq(), free all the memory " );
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]13007 vos_mem_zero(wdiGtkOffloadReqMsg, sizeof(WDI_GtkOffloadReqMsg));
13008 vos_mem_zero(pGtkOffloadParams, sizeof(tSirGtkOffloadParams));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13009 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
13010 vos_mem_free(pWdaParams->wdaMsgParam);
13011 vos_mem_free(pWdaParams);
13012 }
13013
13014 return CONVERT_WDI2VOS_STATUS(status) ;
13015}
13016
13017/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13018 * FUNCTION: WDA_GtkOffloadGetInfoRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13019 *
13020 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13021void WDA_GtkOffloadGetInfoRespCallback( WDI_GtkOffloadGetInfoRspParams *pwdiGtkOffloadGetInfoRsparams,
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]13022 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13023{
13024 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13025 tWDA_CbContext *pWDA;
13026 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoReq;
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]13027 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13028 vos_msg_t vosMsg;
13029
13030 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13031 "<------ %s " ,__func__);
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]13032
Manjunathappa Prakashfb585462013-12-23 19:07:07 -0800[diff] [blame]13033 if(NULL == pWdaParams)
13034 {
13035 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13036 "%s: pWdaParams received NULL", __func__);
13037 VOS_ASSERT(0);
13038 return;
13039 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13040
Nirav Shah374de6e2014-02-13 16:40:01 +0530[diff] [blame]13041 pGtkOffloadGetInfoRsp = vos_mem_malloc(sizeof(tSirGtkOffloadGetInfoRspParams));
13042 if(NULL == pGtkOffloadGetInfoRsp)
13043 {
13044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13045 "%s: vos_mem_malloc failed ", __func__);
13046 VOS_ASSERT(0);
13047 return;
13048 }
13049
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13050 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
13051 pGtkOffloadGetInfoReq = (tpSirGtkOffloadGetInfoRspParams)pWdaParams->wdaMsgParam;
13052
13053 // Fill pGtkOffloadGetInfoRsp from tSirGtkOffloadGetInfoRspParams
13054 vos_mem_zero(pGtkOffloadGetInfoRsp, sizeof(tSirGtkOffloadGetInfoRspParams));
13055
13056 /* Message Header */
13057 pGtkOffloadGetInfoRsp->mesgType = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
Kiran Kumar Lokerefdf42412013-07-17 17:40:58 -0700[diff] [blame]13058 pGtkOffloadGetInfoRsp->mesgLen = sizeof(tSirGtkOffloadGetInfoRspParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13059
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]13060 pGtkOffloadGetInfoRsp->ulStatus = pwdiGtkOffloadGetInfoRsparams->ulStatus;
13061 pGtkOffloadGetInfoRsp->ullKeyReplayCounter = pwdiGtkOffloadGetInfoRsparams->ullKeyReplayCounter;
13062 pGtkOffloadGetInfoRsp->ulTotalRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulTotalRekeyCount;
13063 pGtkOffloadGetInfoRsp->ulGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulGTKRekeyCount;
13064 pGtkOffloadGetInfoRsp->ulIGTKRekeyCount = pwdiGtkOffloadGetInfoRsparams->ulIGTKRekeyCount;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13065
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]13066 vos_mem_copy( pGtkOffloadGetInfoRsp->bssId,
13067 pwdiGtkOffloadGetInfoRsparams->bssId,
13068 sizeof (wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13069 /* VOS message wrapper */
13070 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
13071 vosMsg.bodyptr = (void *)pGtkOffloadGetInfoRsp;
13072 vosMsg.bodyval = 0;
13073
13074 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
13075 {
13076 /* free the mem and return */
Vinay Krishna Eranna6f22c1f2014-10-13 16:03:06 +0530[diff] [blame]13077 vos_mem_zero(pGtkOffloadGetInfoRsp,
13078 sizeof(tSirGtkOffloadGetInfoRspParams));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13079 vos_mem_free((v_VOID_t *) pGtkOffloadGetInfoRsp);
13080 }
13081
13082 vos_mem_free(pWdaParams->wdaMsgParam) ;
13083 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13084 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13085
13086 return;
13087}
13088/*
13089 * FUNCTION: WDA_GtkOffloadGetInfoReqCallback
13090 * Free memory and send RSP back to SME.
13091 * Invoked when GTKOffloadGetInfo REQ failed in WDI and no RSP callback is generated.
13092 */
13093void WDA_GtkOffloadGetInfoReqCallback(WDI_Status wdiStatus, void * pUserData)
13094{
13095 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13096 vos_msg_t vosMsg;
13097
13098 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13099 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
13100
13101 if(NULL == pWdaParams)
13102 {
13103 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13104 "%s: pWdaParams received NULL", __func__);
13105 VOS_ASSERT(0);
13106 return;
13107 }
13108
13109 /* VOS message wrapper */
13110 vosMsg.type = eWNI_PMC_GTK_OFFLOAD_GETINFO_RSP;
13111 vosMsg.bodyptr = NULL;
13112 vosMsg.bodyval = 0;
13113
13114 if(IS_WDI_STATUS_FAILURE(wdiStatus))
13115 {
13116 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13117 vos_mem_free(pWdaParams->wdaMsgParam);
13118 vos_mem_free(pWdaParams);
13119 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
13120 }
13121
13122 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13123}
13124#endif
13125
13126/*
13127 * FUNCTION: WDA_ProcessSetTxPerTrackingReq
13128 * Request to WDI to set Tx Per Tracking configurations
13129 */
13130VOS_STATUS WDA_ProcessSetTxPerTrackingReq(tWDA_CbContext *pWDA, tSirTxPerTrackingParam *pTxPerTrackingParams)
13131{
13132 VOS_STATUS status = VOS_STATUS_SUCCESS;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]13133 WDI_Status wstatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13134 WDI_SetTxPerTrackingReqParamsType *pwdiSetTxPerTrackingReqParams =
13135 (WDI_SetTxPerTrackingReqParamsType *)vos_mem_malloc(
13136 sizeof(WDI_SetTxPerTrackingReqParamsType)) ;
13137 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13138 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13139 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13140 if(NULL == pwdiSetTxPerTrackingReqParams)
13141 {
13142 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13143 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13144 vos_mem_free(pTxPerTrackingParams);
13145 VOS_ASSERT(0);
13146 return VOS_STATUS_E_NOMEM;
13147 }
13148 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
13149 if(NULL == pWdaParams)
13150 {
13151 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13152 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13153 vos_mem_free(pwdiSetTxPerTrackingReqParams);
13154 vos_mem_free(pTxPerTrackingParams);
13155 VOS_ASSERT(0);
13156 return VOS_STATUS_E_NOMEM;
13157 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13158 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingEnable =
13159 pTxPerTrackingParams->ucTxPerTrackingEnable;
13160 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingPeriod =
13161 pTxPerTrackingParams->ucTxPerTrackingPeriod;
13162 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.ucTxPerTrackingRatio =
13163 pTxPerTrackingParams->ucTxPerTrackingRatio;
13164 pwdiSetTxPerTrackingReqParams->wdiTxPerTrackingParam.uTxPerTrackingWatermark =
13165 pTxPerTrackingParams->uTxPerTrackingWatermark;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13166 pwdiSetTxPerTrackingReqParams->wdiReqStatusCB = WDA_SetTxPerTrackingReqCallback;
13167 pwdiSetTxPerTrackingReqParams->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13168 /* Store param pointer as passed in by caller */
13169 /* store Params pass it to WDI
13170 Ideally, the memory allocated here will be free at WDA_SetTxPerTrackingReqCallback */
13171 pWdaParams->wdaWdiApiMsgParam = pwdiSetTxPerTrackingReqParams;
13172 pWdaParams->pWdaContext = pWDA;
13173 pWdaParams->wdaMsgParam = pTxPerTrackingParams;
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]13174 wstatus = WDI_SetTxPerTrackingReq(pwdiSetTxPerTrackingReqParams,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13175 (WDI_SetTxPerTrackingRspCb)WDA_SetTxPerTrackingRespCallback, pWdaParams);
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]13176 if(IS_WDI_STATUS_FAILURE(wstatus))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13177 {
13178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13179 "Failure in Set Tx PER REQ WDI API, free all the memory " );
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]13180 status = CONVERT_WDI2VOS_STATUS(wstatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13181 vos_mem_free(pWdaParams->wdaMsgParam) ;
13182 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13183 vos_mem_free(pWdaParams) ;
13184 }
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]13185 return status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13186
13187}/*WDA_ProcessSetTxPerTrackingReq*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13188/*
13189 * FUNCTION: WDA_HALDumpCmdCallback
13190 * Send the VOS complete .
13191 */
13192void WDA_HALDumpCmdCallback(WDI_HALDumpCmdRspParamsType *wdiRspParams,
13193 void* pUserData)
13194{
13195 tANI_U8 *buffer = NULL;
13196 tWDA_CbContext *pWDA = NULL;
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13197 tWDA_HalDumpReqParams *pWdaParams = (tWDA_HalDumpReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13198 if(NULL == pWdaParams)
13199 {
13200 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13201 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13202 VOS_ASSERT(0) ;
13203 return ;
13204 }
13205
13206 pWDA = pWdaParams->pWdaContext;
13207 buffer = (tANI_U8 *)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13208 if(wdiRspParams->usBufferLen > 0)
13209 {
13210 /*Copy the Resp data to UMAC supplied buffer*/
13211 vos_mem_copy(buffer, wdiRspParams->pBuffer, wdiRspParams->usBufferLen);
13212 }
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13213
13214 if (!pWdaParams->wdaHALDumpAsync)
13215 {/* Indicate VOSS about the start complete */
13216 vos_WDAComplete_cback(pWDA->pVosContext);
13217 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13218 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13219 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13220 return ;
13221}
13222
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13223/*
13224 * FUNCTION: WDA_ProcessHALDumpCmdReq
13225 * Send Dump command to WDI
13226 */
13227VOS_STATUS WDA_HALDumpCmdReq(tpAniSirGlobal pMac, tANI_U32 cmd,
13228 tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3,
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13229 tANI_U32 arg4, tANI_U8 *pBuffer, wpt_boolean async)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13230{
13231 WDI_Status status = WDI_STATUS_SUCCESS;
13232 WDI_HALDumpCmdReqParamsType *wdiHALDumpCmdReqParam = NULL;
13233 WDI_HALDumpCmdReqInfoType *wdiHalDumpCmdInfo = NULL ;
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13234 tWDA_HalDumpReqParams *pWdaParams ;
13235
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13236 pVosContextType pVosContext = NULL;
13237 VOS_STATUS vStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13238 pVosContext = (pVosContextType)vos_get_global_context(VOS_MODULE_ID_PE,
13239 (void *)pMac);
Katya Nigame4bafe02014-02-28 15:37:57 +0530[diff] [blame]13240 if(pVosContext)
13241 {
13242 if (pVosContext->isLogpInProgress)
13243 {
13244 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_FATAL,
13245 "%s:LOGP in Progress. Ignore!!!", __func__);
13246 return VOS_STATUS_E_BUSY;
13247 }
13248 }
13249 else
13250 {
13251 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13252 "%s: VOS Context Null", __func__);
13253 return VOS_STATUS_E_RESOURCES;
13254 }
13255
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13256 if (NULL == pVosContext->pWDAContext)
13257 {
13258 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13259 "%s: WDA Context Null", __func__);
13260 return VOS_STATUS_E_RESOURCES;
13261 }
13262 pWdaParams = (tWDA_HalDumpReqParams *)vos_mem_malloc(sizeof(tWDA_HalDumpReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13263 if(NULL == pWdaParams)
13264 {
13265 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13266 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13267 return VOS_STATUS_E_NOMEM;
13268 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13269 /* Allocate memory WDI request structure*/
13270 wdiHALDumpCmdReqParam = (WDI_HALDumpCmdReqParamsType *)
13271 vos_mem_malloc(sizeof(WDI_HALDumpCmdReqParamsType));
13272 if(NULL == wdiHALDumpCmdReqParam)
13273 {
13274 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13275 "WDA HAL DUMP Command buffer alloc fail");
13276 vos_mem_free(pWdaParams);
13277 return WDI_STATUS_E_FAILURE;
13278 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13279 wdiHalDumpCmdInfo = &wdiHALDumpCmdReqParam->wdiHALDumpCmdInfoType;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13280 /* Extract the arguments */
13281 wdiHalDumpCmdInfo->command = cmd;
13282 wdiHalDumpCmdInfo->argument1 = arg1;
13283 wdiHalDumpCmdInfo->argument2 = arg2;
13284 wdiHalDumpCmdInfo->argument3 = arg3;
13285 wdiHalDumpCmdInfo->argument4 = arg4;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13286 wdiHALDumpCmdReqParam->wdiReqStatusCB = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13287 pWdaParams->pWdaContext = pVosContext->pWDAContext;
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13288 pWdaParams->wdaHALDumpAsync = async;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13289
13290 /* Response message will be passed through the buffer */
13291 pWdaParams->wdaMsgParam = (void *)pBuffer;
13292
13293 /* store Params pass it to WDI */
13294 pWdaParams->wdaWdiApiMsgParam = (void *)wdiHALDumpCmdReqParam ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13295 /* Send command to WDI */
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13296 status = WDI_HALDumpCmdReq(wdiHALDumpCmdReqParam, WDA_HALDumpCmdCallback,
13297 pWdaParams);
13298 /* For Sync event only wait for rsp until completion of wdaCompleteEvent*/
13299 if (!async)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13300 {
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13301 vStatus = vos_wait_single_event( &(pVosContext->wdaCompleteEvent),
13302 WDA_DUMPCMD_WAIT_TIMEOUT );
13303 if ( vStatus != VOS_STATUS_SUCCESS )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13304 {
Siddharth Bhal68115602015-01-18 20:44:55 +0530[diff] [blame]13305 if ( vStatus == VOS_STATUS_E_TIMEOUT )
13306 {
13307 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
13308 "%s: Timeout occurred before WDA_HALDUMP complete",__func__);
13309 }
13310 else
13311 {
13312 VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
13313 "%s: WDA_HALDUMP reporting other error",__func__);
13314 }
13315 VOS_ASSERT(0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13316 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13317 }
13318 return status;
13319}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13320#ifdef WLAN_FEATURE_GTK_OFFLOAD
13321/*
13322 * FUNCTION: WDA_ProcessGTKOffloadgetInfoReq
13323 * Request to WDI to get GTK Offload Information
13324 */
13325VOS_STATUS WDA_ProcessGTKOffloadGetInfoReq(tWDA_CbContext *pWDA,
13326 tpSirGtkOffloadGetInfoRspParams pGtkOffloadGetInfoRsp)
13327{
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]13328 WDI_Status status = WDI_STATUS_E_FAILURE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13329 WDI_GtkOffloadGetInfoReqMsg *pwdiGtkOffloadGetInfoReqMsg =
13330 (WDI_GtkOffloadGetInfoReqMsg *)vos_mem_malloc(sizeof(WDI_GtkOffloadGetInfoReqMsg));
13331 tWDA_ReqParams *pWdaParams ;
13332
13333 if(NULL == pwdiGtkOffloadGetInfoReqMsg)
13334 {
13335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13336 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13337 VOS_ASSERT(0);
13338 return VOS_STATUS_E_NOMEM;
13339 }
13340
13341 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
13342 if(NULL == pWdaParams)
13343 {
13344 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13345 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13346 VOS_ASSERT(0);
13347 vos_mem_free(pwdiGtkOffloadGetInfoReqMsg);
13348 return VOS_STATUS_E_NOMEM;
13349 }
13350
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13351 pwdiGtkOffloadGetInfoReqMsg->wdiReqStatusCB = WDA_GtkOffloadGetInfoReqCallback;
13352 pwdiGtkOffloadGetInfoReqMsg->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13353
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13354 /* Store Params pass it to WDI */
13355 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiGtkOffloadGetInfoReqMsg;
13356 pWdaParams->pWdaContext = pWDA;
13357 /* Store param pointer as passed in by caller */
13358 pWdaParams->wdaMsgParam = pGtkOffloadGetInfoRsp;
13359
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]13360 vos_mem_copy(pwdiGtkOffloadGetInfoReqMsg->WDI_GtkOffloadGetInfoReqParams.bssId,
Gopichand Nakkala870cbae2013-03-15 21:16:09 +0530[diff] [blame]13361 pGtkOffloadGetInfoRsp->bssId, sizeof (wpt_macAddr));
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]13362
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]13363 status = WDI_GTKOffloadGetInfoReq(pwdiGtkOffloadGetInfoReqMsg, (WDI_GtkOffloadGetInfoCb)WDA_GtkOffloadGetInfoRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13364
13365 if(IS_WDI_STATUS_FAILURE(status))
13366 {
13367 /* failure returned by WDI API */
13368 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13369 "Failure in WDA_ProcessGTKOffloadGetInfoReq(), free all the memory " );
13370 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13371 vos_mem_free(pWdaParams) ;
13372 pGtkOffloadGetInfoRsp->ulStatus = eSIR_FAILURE ;
13373 WDA_SendMsg(pWDA, WDA_GTK_OFFLOAD_GETINFO_RSP, (void *)pGtkOffloadGetInfoRsp, 0) ;
13374 }
13375
13376 return CONVERT_WDI2VOS_STATUS(status) ;
13377}
13378#endif // WLAN_FEATURE_GTK_OFFLOAD
13379
13380/*
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13381 * FUNCTION: WDA_ProcessAddPeriodicTxPtrnInd
13382 *
13383 */
13384VOS_STATUS WDA_ProcessAddPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
13385 tSirAddPeriodicTxPtrn *pAddPeriodicTxPtrnParams)
13386{
13387 WDI_Status wdiStatus;
13388 WDI_AddPeriodicTxPtrnParamsType *addPeriodicTxPtrnParams;
13389
13390 addPeriodicTxPtrnParams =
13391 vos_mem_malloc(sizeof(WDI_AddPeriodicTxPtrnParamsType));
13392
13393 if (NULL == addPeriodicTxPtrnParams)
13394 {
13395 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13396 "%s: Not able to allocate memory for addPeriodicTxPtrnParams!",
13397 __func__);
13398
13399 return VOS_STATUS_E_NOMEM;
13400 }
13401
13402 vos_mem_copy(&(addPeriodicTxPtrnParams->wdiAddPeriodicTxPtrnParams),
13403 pAddPeriodicTxPtrnParams, sizeof(tSirAddPeriodicTxPtrn));
13404
13405 addPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
13406 addPeriodicTxPtrnParams->pUserData = pWDA;
13407
13408 wdiStatus = WDI_AddPeriodicTxPtrnInd(addPeriodicTxPtrnParams);
13409
13410 if (WDI_STATUS_PENDING == wdiStatus)
13411 {
13412 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13413 "Pending received for %s:%d", __func__, __LINE__ );
13414 }
13415 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13416 {
13417 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13418 "Failure in %s:%d", __func__, __LINE__ );
13419 }
13420
13421 vos_mem_free(addPeriodicTxPtrnParams);
13422
13423 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13424}
13425
13426/*
13427 * FUNCTION: WDA_ProcessDelPeriodicTxPtrnInd
13428 *
13429 */
13430VOS_STATUS WDA_ProcessDelPeriodicTxPtrnInd(tWDA_CbContext *pWDA,
13431 tSirDelPeriodicTxPtrn *pDelPeriodicTxPtrnParams)
13432{
13433 WDI_Status wdiStatus;
13434 WDI_DelPeriodicTxPtrnParamsType *delPeriodicTxPtrnParams;
13435
13436 delPeriodicTxPtrnParams =
13437 vos_mem_malloc(sizeof(WDI_DelPeriodicTxPtrnParamsType));
13438
13439 if (NULL == delPeriodicTxPtrnParams)
13440 {
13441 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13442 "%s: Not able to allocate memory for delPeriodicTxPtrnParams!",
13443 __func__);
13444
13445 return VOS_STATUS_E_NOMEM;
13446 }
13447
13448 vos_mem_copy(&(delPeriodicTxPtrnParams->wdiDelPeriodicTxPtrnParams),
13449 pDelPeriodicTxPtrnParams, sizeof(tSirDelPeriodicTxPtrn));
13450
13451 delPeriodicTxPtrnParams->wdiReqStatusCB = WDA_WdiIndicationCallback;
13452 delPeriodicTxPtrnParams->pUserData = pWDA;
13453
13454 wdiStatus = WDI_DelPeriodicTxPtrnInd(delPeriodicTxPtrnParams);
13455
13456 if (WDI_STATUS_PENDING == wdiStatus)
13457 {
13458 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13459 "Pending received for %s:%d", __func__, __LINE__ );
13460 }
13461 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13462 {
13463 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13464 "Failure in %s:%d", __func__, __LINE__ );
13465 }
13466
13467 vos_mem_free(delPeriodicTxPtrnParams);
13468
13469 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13470}
13471
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13472#ifdef FEATURE_WLAN_BATCH_SCAN
13473/*
13474 * FUNCTION: WDA_ProcessStopBatchScanInd
13475 *
13476 * DESCRIPTION: This function sends stop batch scan inidcation message to WDI
13477 *
13478 * PARAM:
13479 * pWDA: pointer to WDA context
13480 * pReq: pointer to stop batch scan request
13481 */
13482VOS_STATUS WDA_ProcessStopBatchScanInd(tWDA_CbContext *pWDA,
13483 tSirStopBatchScanInd *pReq)
13484{
13485 WDI_Status wdiStatus;
13486 WDI_StopBatchScanIndType wdiReq;
13487
13488 wdiReq.param = pReq->param;
13489
13490 wdiStatus = WDI_StopBatchScanInd(&wdiReq);
13491
13492 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13493 {
13494 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13495 "Stop batch scan ind failed %s:%d", __func__, wdiStatus);
13496 }
13497
13498 vos_mem_free(pReq);
13499
13500 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13501}
13502/*==========================================================================
13503 FUNCTION WDA_ProcessTriggerBatchScanResultInd
13504
13505 DESCRIPTION
13506 API to pull batch scan result from FW
13507
13508 PARAMETERS
13509 pWDA: Pointer to WDA context
13510 pGetBatchScanReq: Pointer to get batch scan result indication
13511
13512 RETURN VALUE
13513 NONE
13514
13515===========================================================================*/
13516VOS_STATUS WDA_ProcessTriggerBatchScanResultInd(tWDA_CbContext *pWDA,
13517 tSirTriggerBatchScanResultInd *pReq)
13518{
13519 WDI_Status wdiStatus;
13520 WDI_TriggerBatchScanResultIndType wdiReq;
13521
13522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13523 "------> %s " ,__func__);
13524
13525 wdiReq.param = pReq->param;
13526
13527 wdiStatus = WDI_TriggerBatchScanResultInd(&wdiReq);
13528
13529 if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13530 {
13531 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13532 "Trigger batch scan result ind failed %s:%d",
13533 __func__, wdiStatus);
13534 }
13535
13536 vos_mem_free(pReq);
13537
13538 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13539}
13540
13541/*==========================================================================
13542 FUNCTION WDA_SetBatchScanRespCallback
13543
13544 DESCRIPTION
13545 API to process set batch scan response from FW
13546
13547 PARAMETERS
13548 pRsp: Pointer to set batch scan response
13549 pUserData: Pointer to user data
13550
13551 RETURN VALUE
13552 NONE
13553
13554===========================================================================*/
13555void WDA_SetBatchScanRespCallback
13556(
13557 WDI_SetBatchScanRspType *pRsp,
13558 void* pUserData
13559)
13560{
13561 tSirSetBatchScanRsp *pHddSetBatchScanRsp;
13562 tpAniSirGlobal pMac;
13563 void *pCallbackContext;
13564 tWDA_CbContext *pWDA = NULL ;
13565 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
13566
13567
13568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13569 "<------ %s " ,__func__);
13570 if (NULL == pWdaParams)
13571 {
13572 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13573 "%s: pWdaParams received NULL", __func__);
13574 VOS_ASSERT(0) ;
13575 return ;
13576 }
13577
13578 /*extract WDA context*/
13579 pWDA = pWdaParams->pWdaContext;
13580 if (NULL == pWDA)
13581 {
13582 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13583 "%s:pWDA is NULL can't invole HDD callback",
13584 __func__);
13585 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13586 vos_mem_free(pWdaParams->wdaMsgParam);
13587 vos_mem_free(pWdaParams);
13588 VOS_ASSERT(0);
13589 return;
13590 }
13591
13592 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13593 vos_mem_free(pWdaParams->wdaMsgParam);
13594 vos_mem_free(pWdaParams);
13595
13596 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13597 if (NULL == pMac)
13598 {
13599 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13600 "%s:pMac is NULL", __func__);
13601 VOS_ASSERT(0);
13602 return;
13603 }
13604
13605 pHddSetBatchScanRsp =
13606 (tSirSetBatchScanRsp *)vos_mem_malloc(sizeof(tSirSetBatchScanRsp));
13607 if (NULL == pHddSetBatchScanRsp)
13608 {
13609 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13610 "%s: VOS MEM Alloc Failure can't invoke HDD callback", __func__);
13611 VOS_ASSERT(0);
13612 return;
13613 }
13614
13615 pHddSetBatchScanRsp->nScansToBatch = pRsp->nScansToBatch;
13616
13617 pCallbackContext = pMac->pmc.setBatchScanReqCallbackContext;
13618 /*call hdd callback with set batch scan response data*/
13619 if(pMac->pmc.setBatchScanReqCallback)
13620 {
13621 pMac->pmc.setBatchScanReqCallback(pCallbackContext, pHddSetBatchScanRsp);
13622 }
13623 else
13624 {
13625 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13626 "%s:HDD callback is null", __func__);
13627 VOS_ASSERT(0);
13628 }
13629
13630 vos_mem_free(pHddSetBatchScanRsp);
13631 return ;
13632}
13633
13634/*==========================================================================
13635 FUNCTION WDA_ProcessSetBatchScanReq
13636
13637 DESCRIPTION
13638 API to send set batch scan request to WDI
13639
13640 PARAMETERS
13641 pWDA: Pointer to WDA context
13642 pSetBatchScanReq: Pointer to set batch scan req
13643
13644 RETURN VALUE
13645 NONE
13646
13647===========================================================================*/
13648VOS_STATUS WDA_ProcessSetBatchScanReq(tWDA_CbContext *pWDA,
13649 tSirSetBatchScanReq *pSetBatchScanReq)
13650{
13651 WDI_Status status;
13652 tWDA_ReqParams *pWdaParams ;
13653 WDI_SetBatchScanReqType *pWdiSetBatchScanReq;
13654
13655 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
13656 "------> %s " ,__func__);
13657
13658 pWdiSetBatchScanReq =
13659 (WDI_SetBatchScanReqType *)vos_mem_malloc(sizeof(WDI_SetBatchScanReqType));
13660 if (NULL == pWdiSetBatchScanReq)
13661 {
13662 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13663 "%s: VOS MEM Alloc Failure", __func__);
13664 vos_mem_free(pSetBatchScanReq);
13665 VOS_ASSERT(0);
13666 return VOS_STATUS_E_NOMEM;
13667 }
13668
13669 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
13670 if (NULL == pWdaParams)
13671 {
13672 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13673 "%s: VOS MEM Alloc Failure", __func__);
13674 VOS_ASSERT(0);
13675 vos_mem_free(pSetBatchScanReq);
13676 vos_mem_free(pWdiSetBatchScanReq);
13677 return VOS_STATUS_E_NOMEM;
13678 }
13679
13680 pWdiSetBatchScanReq->scanFrequency = pSetBatchScanReq->scanFrequency;
13681 pWdiSetBatchScanReq->numberOfScansToBatch =
13682 pSetBatchScanReq->numberOfScansToBatch;
13683 pWdiSetBatchScanReq->bestNetwork = pSetBatchScanReq->bestNetwork;
13684 pWdiSetBatchScanReq->rfBand = pSetBatchScanReq->rfBand;
13685 pWdiSetBatchScanReq->rtt = pSetBatchScanReq->rtt;
13686
13687 pWdaParams->wdaWdiApiMsgParam = pWdiSetBatchScanReq;
13688 pWdaParams->pWdaContext = pWDA;
13689 pWdaParams->wdaMsgParam = pSetBatchScanReq;
13690
13691 status = WDI_SetBatchScanReq(pWdiSetBatchScanReq, pWdaParams,
13692 (WDI_SetBatchScanCb)WDA_SetBatchScanRespCallback);
13693 if (IS_WDI_STATUS_FAILURE(status))
13694 {
13695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13696 "Failure in Set Batch Scan REQ WDI API, free all the memory " );
13697 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
13698 vos_mem_free(pWdaParams->wdaMsgParam);
13699 vos_mem_free(pWdaParams);
13700 }
13701 return CONVERT_WDI2VOS_STATUS(status);
13702}
13703
13704#endif
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13705/*
13706 * FUNCTION: WDA_ProcessHT40OBSSScanInd
13707 *
13708 * DESCRIPTION: This function sends start/update OBSS scan
13709 * inidcation message to WDI
13710 *
13711 * PARAM:
13712 * pWDA: pointer to WDA context
13713 * pReq: pointer to start OBSS scan request
13714 */
13715VOS_STATUS WDA_ProcessHT40OBSSScanInd(tWDA_CbContext *pWDA,
13716 tSirHT40OBSSScanInd *pReq)
13717{
13718 WDI_Status status;
13719 WDI_HT40ObssScanParamsType wdiOBSSScanParams;
13720 WDI_HT40ObssScanIndType *pWdiOBSSScanInd;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]13721
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]13722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13723 "------> %s " ,__func__);
13724 wdiOBSSScanParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
13725 wdiOBSSScanParams.pUserData = pWDA;
13726
13727 pWdiOBSSScanInd = &(wdiOBSSScanParams.wdiHT40ObssScanParam);
13728 pWdiOBSSScanInd->cmdType = pReq->cmdType;
13729 pWdiOBSSScanInd->scanType = pReq->scanType;
13730 pWdiOBSSScanInd->OBSSScanActiveDwellTime =
13731 pReq->OBSSScanActiveDwellTime;
13732 pWdiOBSSScanInd->OBSSScanPassiveDwellTime =
13733 pReq->OBSSScanPassiveDwellTime;
13734 pWdiOBSSScanInd->BSSChannelWidthTriggerScanInterval =
13735 pReq->BSSChannelWidthTriggerScanInterval;
13736 pWdiOBSSScanInd->BSSWidthChannelTransitionDelayFactor =
13737 pReq->BSSWidthChannelTransitionDelayFactor;
13738 pWdiOBSSScanInd->OBSSScanActiveTotalPerChannel =
13739 pReq->OBSSScanActiveTotalPerChannel;
13740 pWdiOBSSScanInd->OBSSScanPassiveTotalPerChannel =
13741 pReq->OBSSScanPassiveTotalPerChannel;
13742 pWdiOBSSScanInd->OBSSScanActivityThreshold =
13743 pReq->OBSSScanActivityThreshold;
13744 pWdiOBSSScanInd->channelCount = pReq->channelCount;
13745 vos_mem_copy(pWdiOBSSScanInd->channels,
13746 pReq->channels,
13747 pReq->channelCount);
13748 pWdiOBSSScanInd->selfStaIdx = pReq->selfStaIdx;
13749 pWdiOBSSScanInd->fortyMHZIntolerent = pReq->fortyMHZIntolerent;
13750 pWdiOBSSScanInd->bssIdx = pReq->bssIdx;
13751 pWdiOBSSScanInd->currentOperatingClass = pReq->currentOperatingClass;
13752 pWdiOBSSScanInd->ieFieldLen = pReq->ieFieldLen;
13753
13754 vos_mem_copy(pWdiOBSSScanInd->ieField,
13755 pReq->ieField,
13756 pReq->ieFieldLen);
13757
13758 status = WDI_HT40OBSSScanInd(&wdiOBSSScanParams);
13759 if (WDI_STATUS_PENDING == status)
13760 {
13761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13762 "Pending received for %s:%d ",__func__,__LINE__ );
13763 }
13764 else if (WDI_STATUS_SUCCESS_SYNC != status)
13765 {
13766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13767 "Failure in %s:%d ",__func__,__LINE__ );
13768 }
13769 return CONVERT_WDI2VOS_STATUS(status) ;
13770}
13771/*
13772 * FUNCTION: WDA_ProcessHT40OBSSStopScanInd
13773 *
13774 * DESCRIPTION: This function sends stop OBSS scan inidcation message to WDI
13775 *
13776 * PARAM:
13777 * pWDA: pointer to WDA context
13778 * pReq: pointer to stop batch scan request
13779 */
13780VOS_STATUS WDA_ProcessHT40OBSSStopScanInd(tWDA_CbContext *pWDA,
13781 tANI_U8 *bssIdx)
13782{
13783 WDI_Status status;
13784
13785 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13786 "------> %s " ,__func__);
13787
13788 status = WDI_HT40OBSSStopScanInd(*bssIdx);
13789 if (WDI_STATUS_PENDING == status)
13790 {
13791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13792 "Pending received for %s:%d ",__func__,__LINE__ );
13793 }
13794 else if (WDI_STATUS_SUCCESS_SYNC != status)
13795 {
13796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13797 "Failure in %s:%d ",__func__,__LINE__ );
13798 }
13799 return CONVERT_WDI2VOS_STATUS(status) ;
13800}
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]13801/*
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]13802 * FUNCTION: WDA_ProcessRateUpdateInd
13803 *
13804 */
13805VOS_STATUS WDA_ProcessRateUpdateInd(tWDA_CbContext *pWDA,
13806 tSirRateUpdateInd *pRateUpdateParams)
13807{
13808 WDI_Status wdiStatus;
13809 WDI_RateUpdateIndParams rateUpdateParams;
13810
13811 vos_mem_copy(rateUpdateParams.bssid,
13812 pRateUpdateParams->bssid, sizeof(tSirMacAddr));
13813
13814 rateUpdateParams.ucastDataRateTxFlag =
13815 pRateUpdateParams->ucastDataRateTxFlag;
13816 rateUpdateParams.reliableMcastDataRateTxFlag =
13817 pRateUpdateParams->reliableMcastDataRateTxFlag;
13818 rateUpdateParams.mcastDataRate24GHzTxFlag =
13819 pRateUpdateParams->mcastDataRate24GHzTxFlag;
13820 rateUpdateParams.mcastDataRate5GHzTxFlag =
13821 pRateUpdateParams->mcastDataRate5GHzTxFlag;
13822
13823 rateUpdateParams.ucastDataRate = pRateUpdateParams->ucastDataRate;
13824 rateUpdateParams.reliableMcastDataRate =
13825 pRateUpdateParams->reliableMcastDataRate;
13826 rateUpdateParams.mcastDataRate24GHz = pRateUpdateParams->mcastDataRate24GHz;
13827 rateUpdateParams.mcastDataRate5GHz = pRateUpdateParams->mcastDataRate5GHz;
13828
13829 rateUpdateParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
13830 rateUpdateParams.pUserData = pWDA;
13831
13832 wdiStatus = WDI_RateUpdateInd(&rateUpdateParams);
13833
13834 if (WDI_STATUS_PENDING == wdiStatus)
13835 {
13836 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
13837 "Pending received for %s:%d", __func__, __LINE__ );
13838 }
13839 else if (WDI_STATUS_SUCCESS_SYNC != wdiStatus)
13840 {
13841 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13842 "Failure in %s:%d", __func__, __LINE__ );
13843 }
13844
13845 vos_mem_free(pRateUpdateParams);
13846
13847 return CONVERT_WDI2VOS_STATUS(wdiStatus);
13848}
13849
13850/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13851 * -------------------------------------------------------------------------
13852 * DATA interface with WDI for Mgmt Frames
13853 * -------------------------------------------------------------------------
13854 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13855/*
13856 * FUNCTION: WDA_TxComplete
13857 * Callback function for the WDA_TxPacket
13858 */
13859VOS_STATUS WDA_TxComplete( v_PVOID_t pVosContext, vos_pkt_t *pData,
13860 VOS_STATUS status )
13861{
13862
13863 tWDA_CbContext *wdaContext= (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
13864 tpAniSirGlobal pMac = (tpAniSirGlobal)VOS_GET_MAC_CTXT((void *)pVosContext) ;
Anjaneedevi Kapparapuf4883a72015-11-12 18:18:35 +0530[diff] [blame]13865 tANI_U64 uUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13866
Mihir Shete63341222015-03-24 15:39:18 +0530[diff] [blame]13867 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Enter:%s", __func__);
13868
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13869 if(NULL == wdaContext)
13870 {
13871 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13872 "%s:pWDA is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13873 __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13874 VOS_ASSERT(0);
Sushant Kaushik8355d202014-12-17 16:48:10 +0530[diff] [blame]13875 vos_pkt_return_packet(pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13876 return VOS_STATUS_E_FAILURE;
13877 }
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]13878
13879 /*Check if frame was timed out or not*/
13880 vos_pkt_get_user_data_ptr( pData, VOS_PKT_USER_DATA_ID_WDA,
13881 (v_PVOID_t)&uUserData);
13882
13883 if ( WDA_TL_TX_MGMT_TIMED_OUT == uUserData )
13884 {
13885 /*Discard frame - no further processing is needed*/
Mihir Shete63341222015-03-24 15:39:18 +0530[diff] [blame]13886 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
13887 "%s: MGMT Frame Tx timed out",
13888 __func__);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]13889 vos_pkt_return_packet(pData);
13890 return VOS_STATUS_SUCCESS;
13891 }
13892
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13893 /*check whether the callback is null or not,made null during WDA_TL_TX_FRAME_TIMEOUT timeout*/
13894 if( NULL!=wdaContext->pTxCbFunc)
13895 {
13896 /*check if packet is freed already*/
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]13897 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]13898 {
13899 wdaContext->pTxCbFunc(pMac, pData);
13900 }
13901 else
13902 {
13903 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]13904 "%s:packet (%p) is already freed",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13905 __func__, pData);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13906 //Return from here since we reaching here because the packet already timeout
13907 return status;
13908 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13909 }
13910
13911 /*
13912 * Trigger the event to bring the HAL TL Tx complete function to come
13913 * out of wait
13914 * Let the coe above to complete the packet first. When this event is set,
13915 * the thread waiting for the event may run and set Vospacket_freed causing the original
13916 * packet not being freed.
13917 */
13918 status = vos_event_set(&wdaContext->txFrameEvent);
13919 if(!VOS_IS_STATUS_SUCCESS(status))
13920 {
13921 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13922 "NEW VOS Event Set failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13923 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13924 return status;
13925}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13926/*
13927 * FUNCTION: WDA_TxPacket
13928 * Forward TX management frame to WDI
13929 */
13930VOS_STATUS WDA_TxPacket(tWDA_CbContext *pWDA,
13931 void *pFrmBuf,
13932 tANI_U16 frmLen,
13933 eFrameType frmType,
13934 eFrameTxDir txDir,
13935 tANI_U8 tid,
13936 pWDATxRxCompFunc pCompFunc,
13937 void *pData,
13938 pWDAAckFnTxComp pAckTxComp,
Ganesh Kondabattini10e67352015-03-16 17:41:57 +0530[diff] [blame]13939 tANI_U32 txFlag,
13940 tANI_U32 txBdToken
13941 )
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13942{
13943 VOS_STATUS status = VOS_STATUS_SUCCESS ;
13944 tpSirMacFrameCtl pFc = (tpSirMacFrameCtl ) pData;
13945 tANI_U8 ucTypeSubType = pFc->type <<4 | pFc->subType;
13946 tANI_U8 eventIdx = 0;
13947 tBssSystemRole systemRole = eSYSTEM_UNKNOWN_ROLE;
13948 tpAniSirGlobal pMac;
Ganesh Kondabattini29d844f2015-06-15 17:17:16 +0530[diff] [blame]13949 tpSirTxBdStatus txBdStatus = {0};
Abhishek Singh447839d2015-11-30 14:22:10 +0530[diff] [blame]13950 v_TIME_t time_snapshot;
Ganesh Kondabattini10e67352015-03-16 17:41:57 +0530[diff] [blame]13951
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13952 if((NULL == pWDA)||(NULL == pFrmBuf))
13953 {
13954 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Gopichand Nakkala66c0bd02013-04-10 11:36:29 +0530[diff] [blame]13955 "%s:pWDA %p or pFrmBuf %p is NULL",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13956 __func__,pWDA,pFrmBuf);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13957 VOS_ASSERT(0);
13958 return VOS_STATUS_E_FAILURE;
13959 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]13960
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13961 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
Ganesh Kondabattini10e67352015-03-16 17:41:57 +0530[diff] [blame]13962 "Tx Mgmt Frame Subtype: %d alloc(%p) txBdToken = %u",
13963 pFc->subType, pFrmBuf, txBdToken);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13964 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
13965 if(NULL == pMac)
13966 {
13967 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]13968 "%s:pMac is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13969 VOS_ASSERT(0);
13970 return VOS_STATUS_E_FAILURE;
13971 }
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]13972
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13973 /* store the call back function in WDA context */
13974 pWDA->pTxCbFunc = pCompFunc;
13975 /* store the call back for the function of ackTxComplete */
13976 if( pAckTxComp )
13977 {
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13978 if( NULL != pWDA->pAckTxCbFunc )
13979 {
13980 /* Already TxComp is active no need to active again */
Agarwal Ashish3b3f3cb2015-07-02 16:43:47 +0530[diff] [blame]13981 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]13982 "There is already one request pending for tx complete");
Ganesh Kondabattini29d844f2015-06-15 17:17:16 +0530[diff] [blame]13983 pWDA->pAckTxCbFunc( pMac, &txBdStatus);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13984 pWDA->pAckTxCbFunc = NULL;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]13985
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13986 if( VOS_STATUS_SUCCESS !=
13987 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
13988 {
13989 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
13990 "Tx Complete timeout Timer Stop Failed ");
13991 }
13992 else
13993 {
Agarwal Ashish3b3f3cb2015-07-02 16:43:47 +0530[diff] [blame]13994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsonfeddb2d2012-12-10 14:41:22 -0800[diff] [blame]13995 "Tx Complete timeout Timer Stop Success ");
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]13996 }
13997 }
13998
13999 txFlag |= HAL_TXCOMP_REQUESTED_MASK;
14000 pWDA->pAckTxCbFunc = pAckTxComp;
14001 if( VOS_STATUS_SUCCESS !=
14002 WDA_START_TIMER(&pWDA->wdaTimers.TxCompleteTimer) )
14003 {
14004 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14005 "Tx Complete Timer Start Failed ");
14006 pWDA->pAckTxCbFunc = NULL;
14007 return eHAL_STATUS_FAILURE;
14008 }
14009 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14010 /* Reset the event to be not signalled */
14011 status = vos_event_reset(&pWDA->txFrameEvent);
14012 if(!VOS_IS_STATUS_SUCCESS(status))
14013 {
14014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14015 "VOS Event reset failed - status = %d",status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14016 pCompFunc(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf);
14017 if( pAckTxComp )
14018 {
14019 pWDA->pAckTxCbFunc = NULL;
14020 if( VOS_STATUS_SUCCESS !=
14021 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
14022 {
14023 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14024 "Tx Complete timeout Timer Stop Failed ");
14025 }
14026 }
14027 return VOS_STATUS_E_FAILURE;
14028 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]14029
14030 /* If Peer Sta mask is set don't overwrite to self sta */
14031 if(txFlag & HAL_USE_PEER_STA_REQUESTED_MASK)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14032 {
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]14033 txFlag &= ~HAL_USE_PEER_STA_REQUESTED_MASK;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14034 }
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]14035 else
14036 {
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]14037 /* Get system role, use the self station if in unknown role or STA role */
14038 systemRole = wdaGetGlobalSystemRole(pMac);
14039 if (( eSYSTEM_UNKNOWN_ROLE == systemRole ) ||
14040 (( eSYSTEM_STA_ROLE == systemRole )
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14041#if defined FEATURE_WLAN_ESE || defined FEATURE_WLAN_TDLS
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]14042 && frmType == HAL_TXRX_FRM_802_11_MGMT
Madan Mohan Koyyalamudi7ff89c12012-11-28 15:50:13 -0800[diff] [blame]14043#endif
Ganesh K08bce952012-12-13 15:04:41 -0800[diff] [blame]14044 ))
14045 {
14046 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
14047 }
Madan Mohan Koyyalamudi0d40e662012-12-07 14:24:14 -0800[diff] [blame]14048 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14049
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]14050 /* Divert Disassoc/Deauth frames thru self station, as by the time unicast
14051 disassoc frame reaches the HW, HAL has already deleted the peer station */
14052 if ((pFc->type == SIR_MAC_MGMT_FRAME))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14053 {
Madan Mohan Koyyalamudi521ff192012-11-15 17:13:08 -0800[diff] [blame]14054 if ((pFc->subType == SIR_MAC_MGMT_REASSOC_RSP) ||
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]14055 (pFc->subType == SIR_MAC_MGMT_PROBE_REQ))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14056 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14057 /*Send Probe request frames on self sta idx*/
14058 txFlag |= HAL_USE_SELF_STA_REQUESTED_MASK;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]14059 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14060 /* Since we donot want probe responses to be retried, send probe responses
14061 through the NO_ACK queues */
14062 if (pFc->subType == SIR_MAC_MGMT_PROBE_RSP)
14063 {
14064 //probe response is sent out using self station and no retries options.
14065 txFlag |= (HAL_USE_NO_ACK_REQUESTED_MASK | HAL_USE_SELF_STA_REQUESTED_MASK);
14066 }
14067 if(VOS_TRUE == pWDA->wdaAmpSessionOn)
14068 {
14069 txFlag |= HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME;
14070 }
14071 }
Pradeep Reddy POTTETI01710062015-06-29 13:35:53 +0530[diff] [blame]14072#ifdef FEATURE_WLAN_TDLS
14073 /* TDLS Management frames are sent using Peer Sta mask */
14074 else if ((pFc->type == SIR_MAC_DATA_FRAME) &&
14075 (txFlag & HAL_USE_BD_RATE2_FOR_MANAGEMENT_FRAME))
14076 {
14077 txFlag |= HAL_USE_PEER_STA_REQUESTED_MASK;
14078
14079 }
14080#endif
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]14081 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]14082
14083 /*Set frame tag to 0
14084 We will use the WDA user data in order to tag a frame as expired*/
14085 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
14086 (v_PVOID_t)0);
14087
14088
14089 if((status = WLANTL_TxMgmtFrm(pWDA->pVosContext, (vos_pkt_t *)pFrmBuf,
Ganesh Kondabattini10e67352015-03-16 17:41:57 +0530[diff] [blame]14090 frmLen, ucTypeSubType, tid, WDA_TxComplete, NULL, txFlag,
14091 txBdToken))!= VOS_STATUS_SUCCESS)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14092 {
14093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]14094 "Sending Mgmt Frame failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14095 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]14096 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]14097 if( pAckTxComp )
14098 {
14099 pWDA->pAckTxCbFunc = NULL;
14100 if( VOS_STATUS_SUCCESS !=
14101 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
14102 {
14103 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14104 "Tx Complete timeout Timer Stop Failed ");
14105 }
14106 }
14107 return VOS_STATUS_E_FAILURE;
14108 }
Abhishek Singh447839d2015-11-30 14:22:10 +0530[diff] [blame]14109 time_snapshot = vos_timer_get_system_time();
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14110 /*
14111 * Wait for the event to be set by the TL, to get the response of TX
14112 * complete, this event should be set by the Callback function called by TL
14113 */
14114 status = vos_wait_events(&pWDA->txFrameEvent, 1, WDA_TL_TX_FRAME_TIMEOUT,
14115 &eventIdx);
14116 if(!VOS_IS_STATUS_SUCCESS(status))
14117 {
14118 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14119 "%s: Status %d when waiting for TX Frame Event",
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14120 __func__, status);
Sushant Kaushik8355d202014-12-17 16:48:10 +0530[diff] [blame]14121
14122 /*Tag Frame as timed out for later deletion*/
14123 vos_pkt_set_user_data_ptr( (vos_pkt_t *)pFrmBuf, VOS_PKT_USER_DATA_ID_WDA,
14124 (v_PVOID_t)WDA_TL_TX_MGMT_TIMED_OUT);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14125 pWDA->pTxCbFunc = NULL; /*To stop the limTxComplete being called again ,
14126 after the packet gets completed(packet freed once)*/
14127
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]14128 /* TX MGMT fail with COMP timeout, try to detect DXE stall */
Katya Nigam53677462014-08-04 11:37:28 +0530[diff] [blame]14129 WDA_TransportChannelDebug(pMac, 1, 0);
Madan Mohan Koyyalamudiea777012012-10-31 14:22:34 -0700[diff] [blame]14130
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14131 /* check whether the packet was freed already,so need not free again when
14132 * TL calls the WDA_Txcomplete routine
14133 */
Arun Kumar Khandavalli4f8f3f22014-02-07 17:50:12 +0530[diff] [blame]14134 vos_atomic_set((uintptr_t*)&pWDA->VosPacketToFree, (uintptr_t)WDA_TX_PACKET_FREED);
14135 /*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]14136 {
14137 pCompFunc(VOS_GET_MAC_CTXT(pWDA->pVosContext), (vos_pkt_t *)pFrmBuf);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]14138 } */
Abhishek Singhb74bfc02015-11-26 16:53:47 +0530[diff] [blame]14139
14140 WLANTL_TLDebugMessage(WLANTL_DEBUG_FW_CLEANUP);
14141
Abhishek Singh837adf22015-10-01 17:37:37 +0530[diff] [blame]14142 if (vos_isFatalEventEnabled())
14143 vos_fatal_event_logs_req(WLAN_LOG_TYPE_FATAL,
14144 WLAN_LOG_INDICATOR_HOST_DRIVER,
14145 WLAN_LOG_REASON_MGMT_FRAME_TIMEOUT,
14146 FALSE, TRUE);
Madan Mohan Koyyalamudi85cc1d72012-10-30 18:28:37 -0700[diff] [blame]14147
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14148 if( pAckTxComp )
14149 {
14150 pWDA->pAckTxCbFunc = NULL;
14151 if( VOS_STATUS_SUCCESS !=
14152 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
14153 {
14154 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14155 "Tx Complete timeout Timer Stop Failed ");
14156 }
14157 }
Abhishek Singh447839d2015-11-30 14:22:10 +0530[diff] [blame]14158 pWDA->mgmtTxfailureCnt++;
14159
14160 /* SSR if timeout continously for
14161 * WDA_TX_FAILURE_RECOVERY_THRESHOLD times.
14162 */
14163 if (WDA_TX_FAILURE_RECOVERY_THRESHOLD ==
14164 pWDA->mgmtTxfailureCnt)
14165 {
14166 vos_wlanRestart();
14167 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14168 status = VOS_STATUS_E_FAILURE;
14169 }
Abhishek Singh447839d2015-11-30 14:22:10 +0530[diff] [blame]14170
Madan Mohan Koyyalamudi99af06e2013-08-08 02:17:17 +0530[diff] [blame]14171#ifdef WLAN_DUMP_MGMTFRAMES
14172 if (VOS_IS_STATUS_SUCCESS(status))
14173 {
14174 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14175 "%s() TX packet : SubType %d", __func__,pFc->subType);
14176 VOS_TRACE_HEX_DUMP( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14177 pData, frmLen);
14178 }
14179#endif
14180
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]14181 if (VOS_IS_STATUS_SUCCESS(status))
14182 {
Abhishek Singh447839d2015-11-30 14:22:10 +0530[diff] [blame]14183 pWDA->mgmtTxfailureCnt = 0;
14184 if ((vos_timer_get_system_time() - time_snapshot) >=
14185 WDA_TX_TIME_THRESHOLD)
14186 {
14187 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14188 "Tx Complete took %lu ms",
14189 vos_timer_get_system_time() - time_snapshot);
14190 }
14191
Tushnim Bhattacharyya8506f262014-01-30 12:08:37 -0800[diff] [blame]14192 if (pMac->fEnableDebugLog & 0x1)
14193 {
14194 if ((pFc->type == SIR_MAC_MGMT_FRAME) &&
14195 (pFc->subType != SIR_MAC_MGMT_PROBE_REQ) &&
14196 (pFc->subType != SIR_MAC_MGMT_PROBE_RSP))
14197 {
14198 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, "TX MGMT - Type %hu, SubType %hu",
14199 pFc->type, pFc->subType);
14200 }
14201 }
14202 }
14203
14204
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14205 return status;
14206}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14207/*
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14208 * FUNCTION: WDA_ProcessDHCPStartInd
14209 * Forward DHCP Start to WDI
14210 */
14211static VOS_STATUS WDA_ProcessDHCPStartInd (tWDA_CbContext *pWDA,
14212 tAniDHCPInd *dhcpStartInd)
14213{
14214 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14215 WDI_DHCPInd wdiDHCPInd;
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14216
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14217 wdiDHCPInd.device_mode = dhcpStartInd->device_mode;
14218 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStartInd->macAddr,
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14219 sizeof(tSirMacAddr));
14220
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14221 status = WDI_dhcpStartInd(&wdiDHCPInd);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14222
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14223 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14224 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14225 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14226 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14227 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14228 else if (WDI_STATUS_SUCCESS_SYNC != status)
14229 {
14230 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14231 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
14232 }
14233
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14234 vos_mem_free(dhcpStartInd);
14235 return CONVERT_WDI2VOS_STATUS(status) ;
14236}
14237
14238 /*
14239 * FUNCTION: WDA_ProcessDHCPStopInd
14240 * Forward DHCP Stop to WDI
14241 */
14242 static VOS_STATUS WDA_ProcessDHCPStopInd (tWDA_CbContext *pWDA,
14243 tAniDHCPInd *dhcpStopInd)
14244 {
14245 WDI_Status status;
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14246 WDI_DHCPInd wdiDHCPInd;
14247
14248 wdiDHCPInd.device_mode = dhcpStopInd->device_mode;
14249 vos_mem_copy(wdiDHCPInd.macAddr, dhcpStopInd->macAddr, sizeof(tSirMacAddr));
14250
14251 status = WDI_dhcpStopInd(&wdiDHCPInd);
14252
14253 if (WDI_STATUS_PENDING == status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14254 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14255 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14256 "Pending received for %s:%d ",__func__,__LINE__ );
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14257 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14258 else if (WDI_STATUS_SUCCESS_SYNC != status)
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14259 {
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14260 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14261 "Failure status: %d in %s:%d ", status, __func__, __LINE__);
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14262 }
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14263
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14264 vos_mem_free(dhcpStopInd);
c_hpothu0b0cab72014-02-13 21:52:40 +0530[diff] [blame]14265
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]14266 return CONVERT_WDI2VOS_STATUS(status) ;
14267 }
14268
14269/*
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]14270 * FUNCTION: WDA_ProcessSetSpoofMacAddrReq
14271 *
14272 * DESCRIPTION: This function sends Spoof Mac Addr Req to WDI
14273 *
14274 * PARAM:
14275 * pWDA: pointer to WDA context
14276 * pReq: pointer to stop batch scan request
14277 */
14278VOS_STATUS WDA_ProcessSetSpoofMacAddrReq(tWDA_CbContext *pWDA,
14279 tpSpoofMacAddrReqParams pReq)
14280{
14281 WDI_Status wdiStatus;
14282 WDI_SpoofMacAddrInfoType *WDI_SpoofMacAddrInfoParams;
14283 tWDA_ReqParams *pWdaParams;
14284
14285 WDI_SpoofMacAddrInfoParams = (WDI_SpoofMacAddrInfoType *)vos_mem_malloc(
14286 sizeof(WDI_SpoofMacAddrInfoType));
14287 if(NULL == WDI_SpoofMacAddrInfoParams) {
14288 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14289 "%s: VOS MEM Alloc Failure in Spoof Req", __func__);
14290 VOS_ASSERT(0);
14291 return VOS_STATUS_E_NOMEM;
14292 }
14293 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14294 if(NULL == pWdaParams) {
14295 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14296 "%s: VOS MEM Alloc Failure", __func__);
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]14297 vos_mem_free(WDI_SpoofMacAddrInfoParams);
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]14298 VOS_ASSERT(0);
14299 return VOS_STATUS_E_NOMEM;
14300 }
14301
14302 vos_mem_copy(WDI_SpoofMacAddrInfoParams->macAddr,
14303 pReq->macAddr, VOS_MAC_ADDRESS_LEN);
14304
14305 pWdaParams->pWdaContext = pWDA;
14306 /* Store Upper layer req pointer, as this will be used for response */
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]14307 pWdaParams->wdaMsgParam = (void *)pReq;
14308
14309 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, WDA_MAC_ADDRESS_STR,
14310 WDA_MAC_ADDR_ARRAY(WDI_SpoofMacAddrInfoParams->macAddr));
14311
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]14312 /* store Params pass it to WDI */
14313 pWdaParams->wdaWdiApiMsgParam = (void *)WDI_SpoofMacAddrInfoParams ;
14314
14315 wdiStatus = WDI_SetSpoofMacAddrReq(WDI_SpoofMacAddrInfoParams,
Siddharth Bhal029d6732014-10-09 21:31:23 +0530[diff] [blame]14316 (WDI_SetSpoofMacAddrRspCb) WDA_SpoofMacAddrRspCallback,
14317 pWdaParams );
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]14318
14319 if(IS_WDI_STATUS_FAILURE(wdiStatus))
14320 {
14321 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14322 "Failure in SetSpoofMacAddrReq Params WDI API, free all the memory " );
14323 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14324 vos_mem_free(pWdaParams->wdaMsgParam);
14325 vos_mem_free(pWdaParams);
14326 }
14327
14328 return CONVERT_WDI2VOS_STATUS(wdiStatus) ;
14329}
14330
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]14331
14332/*
14333 * FUNCTION: WDA_FwrMemDumpRespCallback
14334 * recieves Mgmt Logging init response from FW
14335 */
14336 void WDA_FwrMemDumpRespCallback(WDI_FwrMemDumpRsp* wdiRsp,
14337 void* pUserData)
14338{
14339 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
14340 tAniFwrDumpReq *pFwrMemDumpReq;
14341 tAniFwrDumpRsp *pFwrMemDumpRsp;
14342 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14343 "<------ %s " ,__func__);
14344
14345 if(NULL == pWdaParams)
14346 {
14347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14348 "%s: pWdaParams received NULL", __func__);
14349 VOS_ASSERT(0);
14350 return ;
14351 }
14352
14353 if(NULL == pWdaParams->wdaMsgParam)
14354 {
14355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14356 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
14357 VOS_ASSERT(0);
14358 vos_mem_free(pWdaParams);
14359 return ;
14360 }
14361
14362 pFwrMemDumpRsp = (tAniFwrDumpRsp *)vos_mem_malloc(sizeof(tAniFwrDumpRsp));
14363 if(pFwrMemDumpRsp == NULL)
14364 {
14365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14366 "%s: pFwrMemDumpRsp is NULL", __func__);
14367 VOS_ASSERT(0);
14368 vos_mem_free(pWdaParams);
14369 return ;
14370 }
14371
14372 pFwrMemDumpRsp->dump_status = wdiRsp->dump_status;
14373 pFwrMemDumpReq = (tAniFwrDumpReq *)pWdaParams->wdaMsgParam;
14374
14375 if(pFwrMemDumpReq->fwMemDumpReqCallback)
14376 {
14377 pFwrMemDumpReq->fwMemDumpReqCallback(
14378 pFwrMemDumpReq->fwMemDumpReqContext,
14379 pFwrMemDumpRsp);
14380 }
14381 else
14382 {
14383 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14384 "%s: FwrMemDump callback is NULL", __func__);
14385 }
14386
14387 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
14388 vos_mem_free(pWdaParams->wdaMsgParam);
14389 vos_mem_free(pWdaParams);
14390 vos_mem_free(pFwrMemDumpRsp);
14391
14392 return ;
14393}
14394
14395VOS_STATUS WDA_ProcessFwrMemDumpReq(tWDA_CbContext * pWDA,
14396 tAniFwrDumpReq* pFwrMemDumpReq)
14397{
14398 VOS_STATUS status = VOS_STATUS_SUCCESS;
14399 WDI_Status wstatus;
14400 WDI_FwrMemDumpReqType * pWdiFwrMemDumpReq;
14401 tWDA_ReqParams *pWdaParams ;
14402
14403 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14404 "------> %s " ,__func__);
14405 /* Sanity Check*/
14406 if(NULL == pFwrMemDumpReq)
14407 {
14408 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14409 "%s: pFwrMemDumpReq received NULL", __func__);
14410 VOS_ASSERT(0) ;
14411 return VOS_STATUS_E_FAULT;
14412 }
14413
14414 pWdiFwrMemDumpReq = (WDI_FwrMemDumpReqType *)vos_mem_malloc(sizeof(WDI_FwrMemDumpReqType));
14415 if(NULL == pWdiFwrMemDumpReq)
14416 {
14417 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14418 "%s: pWdiFwrMemDumpReq Alloc Failure", __func__);
14419 VOS_ASSERT(0);
14420 return VOS_STATUS_E_NOMEM;
14421 }
14422
14423 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
14424 if(NULL == pWdaParams)
14425 {
14426 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14427 "%s: pWdaParams Alloc Failure", __func__);
14428 VOS_ASSERT(0);
14429 vos_mem_free(pWdiFwrMemDumpReq);
14430 return VOS_STATUS_E_NOMEM;
14431 }
14432
14433 /* Store Params pass it to WDI */
14434 pWdaParams->wdaWdiApiMsgParam = (void *)pWdiFwrMemDumpReq;
14435 pWdaParams->pWdaContext = pWDA;
14436 /* Store param pointer as passed in by caller */
14437 pWdaParams->wdaMsgParam = pFwrMemDumpReq;
14438
14439 status = WDI_FwrMemDumpReq(pWdiFwrMemDumpReq,
14440 (WDI_FwrMemDumpCb)WDA_FwrMemDumpRespCallback,
14441 pWdaParams);
14442
14443 if(IS_WDI_STATUS_FAILURE(wstatus))
14444 {
14445 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14446 FL("Fwr Mem Dump Req failed, free all the memory"));
14447 status = CONVERT_WDI2VOS_STATUS(wstatus);
14448 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
14449 vos_mem_free(pWdaParams->wdaMsgParam);
14450 vos_mem_free(pWdaParams);
14451 pWdaParams->wdaWdiApiMsgParam = NULL;
14452 pWdaParams->wdaMsgParam = NULL;
14453 }
14454
14455 return status;
14456
14457}
14458
14459
14460
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]14461/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14462 * FUNCTION: WDA_McProcessMsg
14463 * Trigger DAL-AL to start CFG download
14464 */
14465VOS_STATUS WDA_McProcessMsg( v_CONTEXT_t pVosContext, vos_msg_t *pMsg )
14466{
14467 VOS_STATUS status = VOS_STATUS_SUCCESS;
14468 tWDA_CbContext *pWDA = NULL ;
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]14469 if(NULL == pMsg)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14470 {
14471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14472 "%s:pMsg is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14473 VOS_ASSERT(0);
14474 return VOS_STATUS_E_FAILURE;
14475 }
14476
14477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]14478 "=========> %s msgType: %x " ,__func__, pMsg->type);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14479
14480 pWDA = (tWDA_CbContext *)vos_get_context( VOS_MODULE_ID_WDA, pVosContext );
14481 if(NULL == pWDA )
14482 {
14483 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]14484 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14485 VOS_ASSERT(0);
Madan Mohan Koyyalamudi1bed5982012-10-22 14:38:06 -0700[diff] [blame]14486 vos_mem_free(pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14487 return VOS_STATUS_E_FAILURE;
14488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14489 /* Process all the WDA messages.. */
14490 switch( pMsg->type )
14491 {
14492 case WNI_CFG_DNLD_REQ:
14493 {
14494 status = WDA_WniCfgDnld(pWDA);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14495 /* call WDA complete event if config download success */
14496 if( VOS_IS_STATUS_SUCCESS(status) )
14497 {
14498 vos_WDAComplete_cback(pVosContext);
14499 }
14500 else
14501 {
14502 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
14503 "WDA Config Download failure" );
14504 }
14505 break ;
14506 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14507 /*
14508 * Init SCAN request from PE, convert it into DAL format
14509 * and send it to DAL
14510 */
14511 case WDA_INIT_SCAN_REQ:
14512 {
14513 WDA_ProcessInitScanReq(pWDA, (tInitScanParams *)pMsg->bodyptr) ;
14514 break ;
14515 }
14516 /* start SCAN request from PE */
14517 case WDA_START_SCAN_REQ:
14518 {
14519 WDA_ProcessStartScanReq(pWDA, (tStartScanParams *)pMsg->bodyptr) ;
14520 break ;
14521 }
14522 /* end SCAN request from PE */
14523 case WDA_END_SCAN_REQ:
14524 {
14525 WDA_ProcessEndScanReq(pWDA, (tEndScanParams *)pMsg->bodyptr) ;
14526 break ;
14527 }
14528 /* end SCAN request from PE */
14529 case WDA_FINISH_SCAN_REQ:
14530 {
14531 WDA_ProcessFinishScanReq(pWDA, (tFinishScanParams *)pMsg->bodyptr) ;
14532 break ;
14533 }
14534 /* join request from PE */
14535 case WDA_CHNL_SWITCH_REQ:
14536 {
14537 if(WDA_PRE_ASSOC_STATE == pWDA->wdaState)
14538 {
14539 WDA_ProcessJoinReq(pWDA, (tSwitchChannelParams *)pMsg->bodyptr) ;
14540 }
14541 else
14542 {
Kalikinkar dhara1e83b772014-02-06 12:59:22 -0800[diff] [blame]14543 if (IS_FEATURE_SUPPORTED_BY_FW(CH_SWITCH_V1) &&
14544 eHAL_CHANNEL_SWITCH_SOURCE_CSA ==
14545 ((tSwitchChannelParams*)pMsg->bodyptr)->channelSwitchSrc )
14546 {
14547 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14548 "call ProcessChannelSwitchReq_V1" );
14549 WDA_ProcessChannelSwitchReq_V1(pWDA,
14550 (tSwitchChannelParams*)pMsg->bodyptr) ;
14551 }
14552 else
14553 {
14554 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14555 "call ProcessChannelSwitchReq" );
14556 WDA_ProcessChannelSwitchReq(pWDA,
14557 (tSwitchChannelParams*)pMsg->bodyptr) ;
14558 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14559 }
14560 break ;
14561 }
14562 /* ADD BSS request from PE */
14563 case WDA_ADD_BSS_REQ:
14564 {
14565 WDA_ProcessConfigBssReq(pWDA, (tAddBssParams*)pMsg->bodyptr) ;
14566 break ;
14567 }
14568 case WDA_ADD_STA_REQ:
14569 {
14570 WDA_ProcessAddStaReq(pWDA, (tAddStaParams *)pMsg->bodyptr) ;
14571 break ;
14572 }
14573 case WDA_DELETE_BSS_REQ:
14574 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14575 WDA_ProcessDelBssReq(pWDA, (tDeleteBssParams *)pMsg->bodyptr) ;
14576 break ;
14577 }
14578 case WDA_DELETE_STA_REQ:
14579 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14580 WDA_ProcessDelStaReq(pWDA, (tDeleteStaParams *)pMsg->bodyptr) ;
14581 break ;
14582 }
14583 case WDA_CONFIG_PARAM_UPDATE_REQ:
14584 {
14585 WDA_UpdateCfg(pWDA, (tSirMsgQ *)pMsg) ;
14586 break ;
14587 }
14588 case WDA_SET_BSSKEY_REQ:
14589 {
14590 WDA_ProcessSetBssKeyReq(pWDA, (tSetBssKeyParams *)pMsg->bodyptr);
14591 break ;
14592 }
14593 case WDA_SET_STAKEY_REQ:
14594 {
14595 WDA_ProcessSetStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
14596 break ;
14597 }
14598 case WDA_SET_STA_BCASTKEY_REQ:
14599 {
14600 WDA_ProcessSetBcastStaKeyReq(pWDA, (tSetStaKeyParams *)pMsg->bodyptr);
14601 break ;
14602 }
14603 case WDA_REMOVE_BSSKEY_REQ:
14604 {
14605 WDA_ProcessRemoveBssKeyReq(pWDA,
14606 (tRemoveBssKeyParams *)pMsg->bodyptr);
14607 break ;
14608 }
14609 case WDA_REMOVE_STAKEY_REQ:
14610 {
14611 WDA_ProcessRemoveStaKeyReq(pWDA,
14612 (tRemoveStaKeyParams *)pMsg->bodyptr);
14613 break ;
14614 }
14615 case WDA_REMOVE_STA_BCASTKEY_REQ:
14616 {
14617 /* TODO: currently UMAC is not sending this request, Add the code for
14618 handling this request when UMAC supports */
14619 break;
14620 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14621#ifdef FEATURE_WLAN_ESE
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14622 case WDA_TSM_STATS_REQ:
14623 {
Srinivas Girigowda5cecb202013-10-08 09:13:25 -0700[diff] [blame]14624 WDA_ProcessTsmStatsReq(pWDA, (tpAniGetTsmStatsReq)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14625 break;
14626 }
14627#endif
14628 case WDA_UPDATE_EDCA_PROFILE_IND:
14629 {
14630 WDA_ProcessUpdateEDCAParamReq(pWDA, (tEdcaParams *)pMsg->bodyptr);
14631 break;
14632 }
14633 case WDA_ADD_TS_REQ:
14634 {
14635 WDA_ProcessAddTSReq(pWDA, (tAddTsParams *)pMsg->bodyptr);
14636 break;
14637 }
14638 case WDA_DEL_TS_REQ:
14639 {
14640 WDA_ProcessDelTSReq(pWDA, (tDelTsParams *)pMsg->bodyptr);
14641 break;
14642 }
14643 case WDA_ADDBA_REQ:
14644 {
14645 WDA_ProcessAddBASessionReq(pWDA, (tAddBAParams *)pMsg->bodyptr);
14646 break;
14647 }
14648 case WDA_DELBA_IND:
14649 {
14650 WDA_ProcessDelBAReq(pWDA, (tDelBAParams *)pMsg->bodyptr);
14651 break;
14652 }
Manjunathappa Prakash86f78ca2014-02-10 18:09:15 -0800[diff] [blame]14653 case WDA_UPDATE_CHAN_LIST_REQ:
14654 {
14655 WDA_ProcessUpdateChannelList(pWDA,
14656 (tSirUpdateChanList *)pMsg->bodyptr);
14657 break;
14658 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14659 case WDA_SET_LINK_STATE:
14660 {
14661 WDA_ProcessSetLinkState(pWDA, (tLinkStateParams *)pMsg->bodyptr);
14662 break;
14663 }
14664 case WDA_GET_STATISTICS_REQ:
14665 {
14666 WDA_ProcessGetStatsReq(pWDA, (tAniGetPEStatsReq *)pMsg->bodyptr);
14667 break;
14668 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]14669#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_ESE || defined(FEATURE_WLAN_LFR)
Srinivas Girigowdad34cedb2013-01-25 13:33:11 -0800[diff] [blame]14670 case WDA_GET_ROAM_RSSI_REQ:
14671 {
14672 WDA_ProcessGetRoamRssiReq(pWDA, (tAniGetRssiReq *)pMsg->bodyptr);
14673 break;
14674 }
14675#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14676 case WDA_PWR_SAVE_CFG:
14677 {
14678 if(pWDA->wdaState == WDA_READY_STATE)
14679 {
14680 WDA_ProcessSetPwrSaveCfgReq(pWDA, (tSirPowerSaveCfg *)pMsg->bodyptr);
14681 }
14682 else
14683 {
14684 if(NULL != pMsg->bodyptr)
14685 {
14686 vos_mem_free(pMsg->bodyptr);
14687 }
14688 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14689 "WDA_PWR_SAVE_CFG req in wrong state %d", pWDA->wdaState );
14690 }
14691 break;
14692 }
14693 case WDA_ENTER_IMPS_REQ:
14694 {
14695 if(pWDA->wdaState == WDA_READY_STATE)
14696 {
14697 WDA_ProcessEnterImpsReq(pWDA);
14698 }
14699 else
14700 {
14701 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14702 "WDA_ENTER_IMPS_REQ req in wrong state %d", pWDA->wdaState );
14703 }
14704 break;
14705 }
14706 case WDA_EXIT_IMPS_REQ:
14707 {
14708 if(pWDA->wdaState == WDA_READY_STATE)
14709 {
14710 WDA_ProcessExitImpsReq(pWDA);
14711 }
14712 else
14713 {
14714 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14715 "WDA_EXIT_IMPS_REQ req in wrong state %d", pWDA->wdaState );
14716 }
14717 break;
14718 }
14719 case WDA_ENTER_BMPS_REQ:
14720 {
14721 if(pWDA->wdaState == WDA_READY_STATE)
14722 {
14723 WDA_ProcessEnterBmpsReq(pWDA, (tEnterBmpsParams *)pMsg->bodyptr);
14724 }
14725 else
14726 {
14727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14728 "WDA_ENTER_BMPS_REQ req in wrong state %d", pWDA->wdaState );
14729 }
14730 break;
14731 }
14732 case WDA_EXIT_BMPS_REQ:
14733 {
14734 if(pWDA->wdaState == WDA_READY_STATE)
14735 {
14736 WDA_ProcessExitBmpsReq(pWDA, (tExitBmpsParams *)pMsg->bodyptr);
14737 }
14738 else
14739 {
14740 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14741 "WDA_EXIT_BMPS_REQ req in wrong state %d", pWDA->wdaState );
14742 }
14743 break;
14744 }
14745 case WDA_ENTER_UAPSD_REQ:
14746 {
14747 if(pWDA->wdaState == WDA_READY_STATE)
14748 {
14749 WDA_ProcessEnterUapsdReq(pWDA, (tUapsdParams *)pMsg->bodyptr);
14750 }
14751 else
14752 {
14753 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14754 "WDA_ENTER_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
14755 }
14756 break;
14757 }
14758 case WDA_EXIT_UAPSD_REQ:
14759 {
14760 if(pWDA->wdaState == WDA_READY_STATE)
14761 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]14762 WDA_ProcessExitUapsdReq(pWDA, (tExitUapsdParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14763 }
14764 else
14765 {
14766 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14767 "WDA_EXIT_UAPSD_REQ req in wrong state %d", pWDA->wdaState );
14768 }
14769 break;
14770 }
14771 case WDA_UPDATE_UAPSD_IND:
14772 {
14773 if(pWDA->wdaState == WDA_READY_STATE)
14774 {
14775 WDA_UpdateUapsdParamsReq(pWDA, (tUpdateUapsdParams *)pMsg->bodyptr);
14776 }
14777 else
14778 {
14779 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
14780 "WDA_UPDATE_UAPSD_IND req in wrong state %d", pWDA->wdaState );
14781 }
14782 break;
14783 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14784 case WDA_REGISTER_PE_CALLBACK :
14785 {
14786 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
14787 "Handling msg type WDA_REGISTER_PE_CALLBACK " );
14788 /*TODO: store the PE callback */
14789 /* Do Nothing? MSG Body should be freed at here */
14790 if(NULL != pMsg->bodyptr)
14791 {
14792 vos_mem_free(pMsg->bodyptr);
14793 }
14794 break;
14795 }
14796 case WDA_SYS_READY_IND :
14797 {
14798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
14799 "Handling msg type WDA_SYS_READY_IND " );
14800 pWDA->wdaState = WDA_READY_STATE;
14801 if(NULL != pMsg->bodyptr)
14802 {
14803 vos_mem_free(pMsg->bodyptr);
14804 }
14805 break;
14806 }
14807 case WDA_BEACON_FILTER_IND :
14808 {
14809 WDA_SetBeaconFilterReq(pWDA, (tBeaconFilterMsg *)pMsg->bodyptr);
14810 break;
14811 }
14812 case WDA_BTC_SET_CFG:
14813 {
14814 /*TODO: handle this while dealing with BTC */
14815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
14816 "Handling msg type WDA_BTC_SET_CFG " );
14817 /* Do Nothing? MSG Body should be freed at here */
14818 if(NULL != pMsg->bodyptr)
14819 {
14820 vos_mem_free(pMsg->bodyptr);
14821 }
14822 break;
14823 }
14824 case WDA_SIGNAL_BT_EVENT:
14825 {
14826 /*TODO: handle this while dealing with BTC */
14827 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
14828 "Handling msg type WDA_SIGNAL_BT_EVENT " );
14829 /* Do Nothing? MSG Body should be freed at here */
14830 if(NULL != pMsg->bodyptr)
14831 {
14832 vos_mem_free(pMsg->bodyptr);
14833 }
14834 break;
14835 }
14836 case WDA_CFG_RXP_FILTER_REQ:
14837 {
14838 WDA_ProcessConfigureRxpFilterReq(pWDA,
14839 (tSirWlanSetRxpFilters *)pMsg->bodyptr);
14840 break;
14841 }
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]14842 case WDA_MGMT_LOGGING_INIT_REQ:
14843 {
Siddharth Bhald1be97f2015-05-27 22:39:59 +0530[diff] [blame]14844 WDA_ProcessFWLoggingInitReq(pWDA,
14845 (tSirFWLoggingInitParam *)pMsg->bodyptr);
Siddharth Bhalb7c421c2015-02-27 00:26:09 +0530[diff] [blame]14846 break;
14847 }
Siddharth Bhal64246172015-02-27 01:04:37 +0530[diff] [blame]14848 case WDA_GET_FRAME_LOG_REQ:
14849 {
14850 WDA_ProcessGetFrameLogReq(pWDA,
14851 (tAniGetFrameLogReq *)pMsg->bodyptr);
14852 break;
14853 }
Gupta, Kapil7c34b322015-09-30 13:12:35 +0530[diff] [blame]14854 case WDA_START_RSSI_MONITOR_REQ:
14855 {
14856 WDA_ProcessStartRssiMonitorReq(pWDA,(tSirRssiMonitorReq *)pMsg->bodyptr);
14857 break;
14858 }
14859 case WDA_STOP_RSSI_MONITOR_REQ:
14860 {
14861 WDA_ProcessStopRssiMonitorReq(pWDA,(tSirRssiMonitorReq *)pMsg->bodyptr);
14862 break;
14863 }
Karthick Sa35b0692015-08-21 15:57:05 +0530[diff] [blame]14864 case WDA_SEND_LOG_DONE_IND:
14865 {
Hanumantha Reddy Pothulae00a7e22015-09-15 20:11:30 +0530[diff] [blame]14866 WDA_FWLoggingDXEdoneInd(pMsg->bodyval);
Karthick Sa35b0692015-08-21 15:57:05 +0530[diff] [blame]14867 break;
14868 }
Sachin Ahuja715aafc2015-07-21 23:35:10 +0530[diff] [blame]14869 case WDA_FATAL_EVENT_LOGS_REQ:
14870 {
14871 WDA_ProcessFatalEventLogsReq(pWDA,
14872 (tSirFatalEventLogsReqParam *)pMsg->bodyptr);
14873 break;
14874 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14875 case WDA_SET_HOST_OFFLOAD:
14876 {
14877 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
14878 break;
14879 }
14880 case WDA_SET_KEEP_ALIVE:
14881 {
14882 WDA_ProcessKeepAliveReq(pWDA, (tSirKeepAliveReq *)pMsg->bodyptr);
14883 break;
14884 }
14885#ifdef WLAN_NS_OFFLOAD
14886 case WDA_SET_NS_OFFLOAD:
14887 {
14888 WDA_ProcessHostOffloadReq(pWDA, (tSirHostOffloadReq *)pMsg->bodyptr);
14889 break;
14890 }
14891#endif //WLAN_NS_OFFLOAD
14892 case WDA_ADD_STA_SELF_REQ:
14893 {
14894 WDA_ProcessAddStaSelfReq(pWDA, (tAddStaSelfParams *)pMsg->bodyptr);
14895 break;
14896 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14897 case WDA_DEL_STA_SELF_REQ:
14898 {
14899 WDA_ProcessDelSTASelfReq(pWDA, (tDelStaSelfParams *)pMsg->bodyptr);
14900 break;
14901 }
14902 case WDA_WOWL_ADD_BCAST_PTRN:
14903 {
14904 WDA_ProcessWowlAddBcPtrnReq(pWDA, (tSirWowlAddBcastPtrn *)pMsg->bodyptr);
14905 break;
14906 }
14907 case WDA_WOWL_DEL_BCAST_PTRN:
14908 {
14909 WDA_ProcessWowlDelBcPtrnReq(pWDA, (tSirWowlDelBcastPtrn *)pMsg->bodyptr);
14910 break;
14911 }
14912 case WDA_WOWL_ENTER_REQ:
14913 {
14914 WDA_ProcessWowlEnterReq(pWDA, (tSirHalWowlEnterParams *)pMsg->bodyptr);
14915 break;
14916 }
14917 case WDA_WOWL_EXIT_REQ:
14918 {
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]14919 WDA_ProcessWowlExitReq(pWDA, (tSirHalWowlExitParams *)pMsg->bodyptr);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]14920 break;
14921 }
14922 case WDA_TL_FLUSH_AC_REQ:
14923 {
14924 WDA_ProcessFlushAcReq(pWDA, (tFlushACReq *)pMsg->bodyptr);
14925 break;
14926 }
14927 case WDA_SIGNAL_BTAMP_EVENT:
14928 {
14929 WDA_ProcessBtAmpEventReq(pWDA, (tSmeBtAmpEvent *)pMsg->bodyptr);
14930 break;
14931 }
Abhishek Singh85b74712014-10-08 11:38:19 +0530[diff] [blame]14932 case WDA_FW_STATS_GET_REQ:
14933 {
14934 WDA_ProcessFWStatsGetReq(pWDA,
14935 (tSirFWStatsGetReq *)pMsg->bodyptr);
14936 break;
14937 }
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]14938#ifdef WLAN_FEATURE_LINK_LAYER_STATS
14939 case WDA_LINK_LAYER_STATS_SET_REQ:
14940 {
14941 WDA_ProcessLLStatsSetReq(pWDA, (tSirLLStatsSetReq *)pMsg->bodyptr);
14942 break;
14943 }
14944 case WDA_LINK_LAYER_STATS_GET_REQ:
14945 {
14946 WDA_ProcessLLStatsGetReq(pWDA, (tSirLLStatsGetReq *)pMsg->bodyptr);
14947 break;
14948 }
14949 case WDA_LINK_LAYER_STATS_CLEAR_REQ:
14950 {
14951 WDA_ProcessLLStatsClearReq(pWDA, (tSirLLStatsClearReq *)pMsg->bodyptr);
14952 break;
14953 }
14954#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]14955#ifdef WLAN_FEATURE_EXTSCAN
14956 case WDA_EXTSCAN_GET_CAPABILITIES_REQ:
14957 {
14958 WDA_ProcessEXTScanGetCapabilitiesReq(pWDA,
14959 (tSirGetEXTScanCapabilitiesReqParams *)pMsg->bodyptr);
14960 break;
14961 }
14962 case WDA_EXTSCAN_START_REQ:
14963 {
14964 WDA_ProcessEXTScanStartReq(pWDA,
14965 (tSirEXTScanStartReqParams *)pMsg->bodyptr);
14966 break;
14967 }
14968 case WDA_EXTSCAN_STOP_REQ:
14969 {
14970 WDA_ProcessEXTScanStopReq(pWDA,
14971 (tSirEXTScanStopReqParams *)pMsg->bodyptr);
14972 break;
14973 }
14974 case WDA_EXTSCAN_GET_CACHED_RESULTS_REQ:
14975 {
14976 WDA_ProcessEXTScanGetCachedResultsReq(pWDA,
14977 (tSirEXTScanGetCachedResultsReqParams *)pMsg->bodyptr);
14978 break;
14979 }
14980 case WDA_EXTSCAN_SET_BSSID_HOTLIST_REQ:
14981 {
14982 WDA_ProcessEXTScanSetBSSIDHotlistReq(pWDA,
14983 (tSirEXTScanSetBssidHotListReqParams *)pMsg->bodyptr);
14984 break;
14985 }
14986 case WDA_EXTSCAN_RESET_BSSID_HOTLIST_REQ:
14987 {
14988 WDA_ProcessEXTScanResetBSSIDHotlistReq(pWDA,
14989 (tSirEXTScanResetBssidHotlistReqParams *)pMsg->bodyptr);
14990 break;
14991 }
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]14992 case WDA_EXTSCAN_SET_SSID_HOTLIST_REQ:
14993 {
14994 WDA_ProcessEXTScanSetSSIDHotlistReq(pWDA,
14995 (tSirEXTScanSetSsidHotListReqParams *)pMsg->bodyptr);
14996 break;
14997 }
14998 case WDA_EXTSCAN_RESET_SSID_HOTLIST_REQ:
14999 {
15000 WDA_ProcessEXTScanResetSSIDHotlistReq(pWDA,
15001 (tSirEXTScanResetSsidHotlistReqParams *)pMsg->bodyptr);
15002 break;
15003 }
Padma, Santhosh Kumarc1f7f052015-08-26 12:29:01 +0530[diff] [blame]15004 case WDA_HIGH_PRIORITY_DATA_INFO_IND:
15005 {
15006 WDA_ProcessHighPriorityDataInfoInd(pWDA,
15007 (tSirHighPriorityDataInfoInd *)pMsg->bodyptr);
15008 break;
15009 }
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]15010#endif /* WLAN_FEATURE_EXTSCAN */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15011#ifdef WDA_UT
15012 case WDA_WDI_EVENT_MSG:
15013 {
15014 WDI_processEvent(pMsg->bodyptr,(void *)pMsg->bodyval);
15015 break ;
15016 }
15017#endif
15018 case WDA_UPDATE_BEACON_IND:
15019 {
15020 WDA_ProcessUpdateBeaconParams(pWDA,
15021 (tUpdateBeaconParams *)pMsg->bodyptr);
15022 break;
15023 }
15024 case WDA_SEND_BEACON_REQ:
15025 {
15026 WDA_ProcessSendBeacon(pWDA, (tSendbeaconParams *)pMsg->bodyptr);
15027 break;
15028 }
15029 case WDA_UPDATE_PROBE_RSP_TEMPLATE_IND:
15030 {
15031 WDA_ProcessUpdateProbeRspTemplate(pWDA,
15032 (tSendProbeRespParams *)pMsg->bodyptr);
15033 break;
15034 }
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]15035#if defined(WLAN_FEATURE_VOWIFI) || defined(FEATURE_WLAN_ESE)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15036 case WDA_SET_MAX_TX_POWER_REQ:
15037 {
15038 WDA_ProcessSetMaxTxPowerReq(pWDA,
15039 (tMaxTxPowerParams *)pMsg->bodyptr);
15040 break;
15041 }
15042#endif
Arif Hussaina5ebce02013-08-09 15:09:58 -0700[diff] [blame]15043 case WDA_SET_MAX_TX_POWER_PER_BAND_REQ:
15044 {
15045 WDA_ProcessSetMaxTxPowerPerBandReq(pWDA, (tMaxTxPowerPerBandParams *)
15046 pMsg->bodyptr);
15047 break;
15048 }
schang86c22c42013-03-13 18:41:24 -0700[diff] [blame]15049 case WDA_SET_TX_POWER_REQ:
15050 {
15051 WDA_ProcessSetTxPowerReq(pWDA,
15052 (tSirSetTxPowerReq *)pMsg->bodyptr);
15053 break;
15054 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15055 case WDA_SET_P2P_GO_NOA_REQ:
15056 {
15057 WDA_ProcessSetP2PGONOAReq(pWDA,
15058 (tP2pPsParams *)pMsg->bodyptr);
15059 break;
15060 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15061 /* timer related messages */
15062 case WDA_TIMER_BA_ACTIVITY_REQ:
15063 {
15064 WDA_BaCheckActivity(pWDA) ;
15065 break ;
15066 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]15067
15068 /* timer related messages */
15069 case WDA_TIMER_TRAFFIC_STATS_IND:
15070 {
15071 WDA_TimerTrafficStatsInd(pWDA);
15072 break;
15073 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15074#ifdef WLAN_FEATURE_VOWIFI_11R
15075 case WDA_AGGR_QOS_REQ:
15076 {
15077 WDA_ProcessAggrAddTSReq(pWDA, (tAggrAddTsParams *)pMsg->bodyptr);
15078 break;
15079 }
15080#endif /* WLAN_FEATURE_VOWIFI_11R */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15081 case WDA_FTM_CMD_REQ:
15082 {
15083 WDA_ProcessFTMCommand(pWDA, (tPttMsgbuffer *)pMsg->bodyptr) ;
15084 break ;
15085 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]15086#ifdef FEATURE_OEM_DATA_SUPPORT
15087 case WDA_START_OEM_DATA_REQ:
15088 {
15089 WDA_ProcessStartOemDataReq(pWDA, (tStartOemDataReq *)pMsg->bodyptr) ;
15090 break;
15091 }
15092#endif /* FEATURE_OEM_DATA_SUPPORT */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15093 /* Tx Complete Time out Indication */
15094 case WDA_TX_COMPLETE_TIMEOUT_IND:
15095 {
15096 WDA_ProcessTxCompleteTimeOutInd(pWDA);
15097 break;
15098 }
15099 case WDA_WLAN_SUSPEND_IND:
15100 {
15101 WDA_ProcessWlanSuspendInd(pWDA,
15102 (tSirWlanSuspendParam *)pMsg->bodyptr) ;
15103 break;
15104 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15105 case WDA_WLAN_RESUME_REQ:
15106 {
15107 WDA_ProcessWlanResumeReq(pWDA,
15108 (tSirWlanResumeParam *)pMsg->bodyptr) ;
15109 break;
15110 }
15111
15112 case WDA_UPDATE_CF_IND:
15113 {
15114 vos_mem_free((v_VOID_t*)pMsg->bodyptr);
15115 pMsg->bodyptr = NULL;
15116 break;
15117 }
15118#ifdef FEATURE_WLAN_SCAN_PNO
15119 case WDA_SET_PNO_REQ:
15120 {
15121 WDA_ProcessSetPrefNetworkReq(pWDA, (tSirPNOScanReq *)pMsg->bodyptr);
15122 break;
15123 }
15124 case WDA_UPDATE_SCAN_PARAMS_REQ:
15125 {
15126 WDA_ProcessUpdateScanParams(pWDA, (tSirUpdateScanParams *)pMsg->bodyptr);
15127 break;
15128 }
15129 case WDA_SET_RSSI_FILTER_REQ:
15130 {
15131 WDA_ProcessSetRssiFilterReq(pWDA, (tSirSetRSSIFilterReq *)pMsg->bodyptr);
15132 break;
15133 }
15134#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15135#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15136 case WDA_ROAM_SCAN_OFFLOAD_REQ:
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15137 {
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]15138 WDA_ProcessRoamScanOffloadReq(pWDA, (tSirRoamOffloadScanReq *)pMsg->bodyptr);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]15139 break;
15140 }
15141#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15142 case WDA_SET_TX_PER_TRACKING_REQ:
15143 {
15144 WDA_ProcessSetTxPerTrackingReq(pWDA, (tSirTxPerTrackingParam *)pMsg->bodyptr);
15145 break;
15146 }
15147
15148#ifdef WLAN_FEATURE_PACKET_FILTERING
15149 case WDA_8023_MULTICAST_LIST_REQ:
15150 {
15151 WDA_Process8023MulticastListReq(pWDA, (tSirRcvFltMcAddrList *)pMsg->bodyptr);
15152 break;
15153 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15154 case WDA_RECEIVE_FILTER_SET_FILTER_REQ:
15155 {
15156 WDA_ProcessReceiveFilterSetFilterReq(pWDA, (tSirRcvPktFilterCfgType *)pMsg->bodyptr);
15157 break;
15158 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15159 case WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_REQ:
15160 {
15161 WDA_ProcessPacketFilterMatchCountReq(pWDA, (tpSirRcvFltPktMatchRsp)pMsg->bodyptr);
15162 break;
15163 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15164 case WDA_RECEIVE_FILTER_CLEAR_FILTER_REQ:
15165 {
15166 WDA_ProcessReceiveFilterClearFilterReq(pWDA, (tSirRcvFltPktClearParam *)pMsg->bodyptr);
15167 break;
15168 }
15169#endif // WLAN_FEATURE_PACKET_FILTERING
15170
15171
15172 case WDA_TRANSMISSION_CONTROL_IND:
15173 {
15174 WDA_ProcessTxControlInd(pWDA, (tpTxControlParams)pMsg->bodyptr);
15175 break;
15176 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15177 case WDA_SET_POWER_PARAMS_REQ:
15178 {
15179 WDA_ProcessSetPowerParamsReq(pWDA, (tSirSetPowerParamsReq *)pMsg->bodyptr);
15180 break;
15181 }
c_manjeecfd1efb2015-09-25 19:32:34 +0530[diff] [blame]15182 case WDA_FW_MEM_DUMP_REQ:
15183 {
15184 WDA_ProcessFwrMemDumpReq(pWDA, (tAniFwrDumpReq*)pMsg->bodyptr);
15185 break;
15186 }
15187
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15188#ifdef WLAN_FEATURE_GTK_OFFLOAD
15189 case WDA_GTK_OFFLOAD_REQ:
15190 {
15191 WDA_ProcessGTKOffloadReq(pWDA, (tpSirGtkOffloadParams)pMsg->bodyptr);
15192 break;
15193 }
15194
15195 case WDA_GTK_OFFLOAD_GETINFO_REQ:
15196 {
15197 WDA_ProcessGTKOffloadGetInfoReq(pWDA, (tpSirGtkOffloadGetInfoRspParams)pMsg->bodyptr);
15198 break;
15199 }
15200#endif //WLAN_FEATURE_GTK_OFFLOAD
15201
15202 case WDA_SET_TM_LEVEL_REQ:
15203 {
15204 WDA_ProcessSetTmLevelReq(pWDA, (tAniSetTmLevelReq *)pMsg->bodyptr);
15205 break;
15206 }
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]15207
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15208 case WDA_UPDATE_OP_MODE:
15209 {
Sandeep Puligilla60342762014-01-30 21:05:37 +0530[diff] [blame]15210 if(WDA_getHostWlanFeatCaps(HT40_OBSS_SCAN) &&
15211 WDA_getFwWlanFeatCaps(HT40_OBSS_SCAN))
15212 {
15213 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
15214 }
15215 else if(WDA_getHostWlanFeatCaps(DOT11AC) && WDA_getFwWlanFeatCaps(DOT11AC))
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15216 {
15217 if(WDA_getHostWlanFeatCaps(DOT11AC_OPMODE) && WDA_getFwWlanFeatCaps(DOT11AC_OPMODE))
15218 WDA_ProcessUpdateOpMode(pWDA, (tUpdateVHTOpMode *)pMsg->bodyptr);
15219 else
15220 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15221 " VHT OpMode Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15222 }
15223 else
15224 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]15225 " 11AC Feature is Not Supported");
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]15226 break;
15227 }
Chet Lanctot186b5732013-03-18 10:26:30 -0700[diff] [blame]15228#ifdef WLAN_FEATURE_11W
15229 case WDA_EXCLUDE_UNENCRYPTED_IND:
15230 {
15231 WDA_ProcessExcludeUnecryptInd(pWDA, (tSirWlanExcludeUnencryptParam *)pMsg->bodyptr);
15232 break;
15233 }
15234#endif
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]15235#ifdef FEATURE_WLAN_TDLS
15236 case WDA_SET_TDLS_LINK_ESTABLISH_REQ:
15237 {
15238 WDA_ProcessSetTdlsLinkEstablishReq(pWDA, (tTdlsLinkEstablishParams *)pMsg->bodyptr);
15239 break;
15240 }
15241#endif
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]15242 case WDA_DHCP_START_IND:
15243 {
15244 WDA_ProcessDHCPStartInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
15245 break;
15246 }
15247 case WDA_DHCP_STOP_IND:
15248 {
15249 WDA_ProcessDHCPStopInd(pWDA, (tAniDHCPInd *)pMsg->bodyptr);
15250 break;
15251 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15252#ifdef FEATURE_WLAN_LPHB
15253 case WDA_LPHB_CONF_REQ:
15254 {
15255 WDA_ProcessLPHBConfReq(pWDA, (tSirLPHBReq *)pMsg->bodyptr);
15256 break;
15257 }
15258#endif
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]15259 case WDA_ADD_PERIODIC_TX_PTRN_IND:
15260 {
15261 WDA_ProcessAddPeriodicTxPtrnInd(pWDA,
15262 (tSirAddPeriodicTxPtrn *)pMsg->bodyptr);
15263 break;
15264 }
15265 case WDA_DEL_PERIODIC_TX_PTRN_IND:
15266 {
15267 WDA_ProcessDelPeriodicTxPtrnInd(pWDA,
15268 (tSirDelPeriodicTxPtrn *)pMsg->bodyptr);
15269 break;
15270 }
15271
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]15272#ifdef FEATURE_WLAN_BATCH_SCAN
15273 case WDA_SET_BATCH_SCAN_REQ:
15274 {
15275 WDA_ProcessSetBatchScanReq(pWDA,
15276 (tSirSetBatchScanReq *)pMsg->bodyptr);
15277 break;
15278 }
Chittajit Mitraf5413a42013-10-18 14:20:08 -0700[diff] [blame]15279 case WDA_RATE_UPDATE_IND:
15280 {
15281 WDA_ProcessRateUpdateInd(pWDA, (tSirRateUpdateInd *)pMsg->bodyptr);
15282 break;
15283 }
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]15284 case WDA_TRIGGER_BATCH_SCAN_RESULT_IND:
15285 {
15286 WDA_ProcessTriggerBatchScanResultInd(pWDA,
15287 (tSirTriggerBatchScanResultInd *)pMsg->bodyptr);
15288 break;
15289 }
15290 case WDA_STOP_BATCH_SCAN_IND:
15291 {
15292 WDA_ProcessStopBatchScanInd(pWDA,
15293 (tSirStopBatchScanInd *)pMsg->bodyptr);
15294 break;
15295 }
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]15296 case WDA_GET_BCN_MISS_RATE_REQ:
15297 WDA_ProcessGetBcnMissRateReq(pWDA,
15298 (tSirBcnMissRateReq *)pMsg->bodyptr);
15299 break;
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]15300#endif
15301
Sandeep Puligilla8b8b74b2014-02-10 16:39:05 +0530[diff] [blame]15302 case WDA_HT40_OBSS_SCAN_IND:
15303 {
15304 WDA_ProcessHT40OBSSScanInd(pWDA,
15305 (tSirHT40OBSSScanInd *)pMsg->bodyptr);
15306 break;
15307 }
15308 case WDA_HT40_OBSS_STOP_SCAN_IND:
15309 {
15310 WDA_ProcessHT40OBSSStopScanInd(pWDA,
15311 (tANI_U8*)pMsg->bodyptr);
15312 break;
15313 }
Atul Mittalc0f739f2014-07-31 13:47:47 +0530[diff] [blame]15314// tdlsoffchan
15315#ifdef FEATURE_WLAN_TDLS
15316 case WDA_SET_TDLS_CHAN_SWITCH_REQ:
15317 {
15318 WDA_ProcessSetTdlsChanSwitchReq(pWDA, (tTdlsChanSwitchParams *)pMsg->bodyptr);
15319 break;
15320 }
15321#endif
Siddharth Bhal171788a2014-09-29 21:02:40 +0530[diff] [blame]15322 case WDA_SPOOF_MAC_ADDR_REQ:
15323 {
15324 WDA_ProcessSetSpoofMacAddrReq(pWDA, (tpSpoofMacAddrReqParams)pMsg->bodyptr);
15325 break;
15326 }
Srinivas Dasari4dae48f2014-11-26 21:14:16 +0530[diff] [blame]15327 case WDA_ENCRYPT_MSG_REQ:
15328 {
15329 WDA_ProcessEncryptMsgReq(pWDA, (u8 *)pMsg->bodyptr);
15330 break;
15331 }
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]15332
15333 case WDA_NAN_REQUEST:
15334 {
15335 WDA_ProcessNanRequest( pWDA, (tNanRequest *)pMsg->bodyptr);
15336 break;
15337 }
Abhishek Singh41988ba2015-05-25 19:42:29 +0530[diff] [blame]15338 case WDA_SET_RTS_CTS_HTVHT:
15339 {
15340 WDA_ProcessSetRtsCtsHTVhtInd( pWDA, pMsg->bodyval);
15341 break;
15342 }
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]15343
15344 case WDA_MON_START_REQ:
15345 {
15346 WDA_ProcessMonStartReq(pWDA,(v_PVOID_t)pMsg->bodyptr);
15347 break;
15348 }
15349 case WDA_MON_STOP_REQ:
15350 {
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]15351 WDA_ProcessMonStopReq(pWDA, (v_PVOID_t)pMsg->bodyptr);
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]15352 break;
15353 }
Mahesh A Saptasagarbeca12c2015-09-07 16:21:06 +0530[diff] [blame]15354 case WDA_SEND_FREQ_RANGE_CONTROL_IND:
15355 {
15356 WDA_ProcessEnableDisableCAEventInd(pWDA, pMsg->bodyval);
15357 break;
15358 }
Arun Khandavalli7eeb1592015-10-19 21:36:57 +0530[diff] [blame]15359 case WDA_WIFI_CONFIG_REQ:
15360 {
15361 WDA_ProcessWifiConfigReq(pWDA,(tSetWifiConfigParams *)pMsg->bodyptr);
15362 break;
15363 }
Padma, Santhosh Kumar2ccac212015-10-20 17:27:27 +0530[diff] [blame]15364#ifdef FEATURE_OEM_DATA_SUPPORT
15365 case WDA_START_OEM_DATA_REQ_IND_NEW:
15366 {
15367 WDA_ProcessStartOemDataReqIndNew(pWDA,
15368 (tOemDataReqNewConfig *)pMsg->bodyptr);
15369 break;
15370 }
15371#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15372 default:
15373 {
Agarwal Ashishbf98caf2014-03-25 13:29:11 +0530[diff] [blame]15374 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15375 "No Handling for msg type %x in WDA "
15376 ,pMsg->type);
15377 /* Do Nothing? MSG Body should be freed at here */
15378 if(NULL != pMsg->bodyptr)
15379 {
15380 vos_mem_free(pMsg->bodyptr);
15381 }
15382 //WDA_VOS_ASSERT(0) ;
15383 }
15384 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15385 return status ;
15386}
15387
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15388/*
15389 * FUNCTION: WDA_LowLevelIndCallback
15390 * IND API callback from WDI, send Ind to PE
15391 */
15392void WDA_lowLevelIndCallback(WDI_LowLevelIndType *wdiLowLevelInd,
15393 void* pUserData )
15394{
15395 tWDA_CbContext *pWDA = (tWDA_CbContext *)pUserData;
15396#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
15397 tSirRSSINotification rssiNotification;
15398#endif
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]15399 if (NULL == pWDA)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15400 {
15401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]15402 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15403 VOS_ASSERT(0);
15404 return ;
15405 }
15406
15407 switch(wdiLowLevelInd->wdiIndicationType)
15408 {
15409 case WDI_RSSI_NOTIFICATION_IND:
15410 {
15411 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15412 "Received WDI_HAL_RSSI_NOTIFICATION_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15413#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
15414 rssiNotification.bReserved =
15415 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bReserved;
15416 rssiNotification.bRssiThres1NegCross =
15417 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1NegCross;
15418 rssiNotification.bRssiThres1PosCross =
15419 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres1PosCross;
15420 rssiNotification.bRssiThres2NegCross =
15421 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2NegCross;
15422 rssiNotification.bRssiThres2PosCross =
15423 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres2PosCross;
15424 rssiNotification.bRssiThres3NegCross =
15425 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3NegCross;
15426 rssiNotification.bRssiThres3PosCross =
15427 wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.bRssiThres3PosCross;
Srinivasdaaec712012-12-12 15:59:44 -0800[diff] [blame]15428 rssiNotification.avgRssi = (v_S7_t)
15429 ((-1)*wdiLowLevelInd->wdiIndicationData.wdiLowRSSIInfo.avgRssi);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15430 WLANTL_BMPSRSSIRegionChangedNotification(
15431 pWDA->pVosContext,
15432 &rssiNotification);
15433#endif
15434 break ;
15435 }
15436 case WDI_MISSED_BEACON_IND:
15437 {
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]15438 tpSirSmeMissedBeaconInd pMissBeacInd =
15439 (tpSirSmeMissedBeaconInd)vos_mem_malloc(sizeof(tSirSmeMissedBeaconInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15440 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15441 "Received WDI_MISSED_BEACON_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15442 /* send IND to PE */
Leela Venkata Kiran Kumar Reddy Chirala3ca17902013-02-27 19:50:05 -0800[diff] [blame]15443 if(NULL == pMissBeacInd)
15444 {
15445 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15446 "%s: VOS MEM Alloc Failure", __func__);
15447 break;
15448 }
15449 pMissBeacInd->messageType = WDA_MISSED_BEACON_IND;
15450 pMissBeacInd->length = sizeof(tSirSmeMissedBeaconInd);
15451 pMissBeacInd->bssIdx =
15452 wdiLowLevelInd->wdiIndicationData.wdiMissedBeaconInd.bssIdx;
15453 WDA_SendMsg(pWDA, WDA_MISSED_BEACON_IND, (void *)pMissBeacInd , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15454 break ;
15455 }
15456 case WDI_UNKNOWN_ADDR2_FRAME_RX_IND:
15457 {
15458 /* TODO: Decode Ind and send Ind to PE */
15459 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15460 "Received WDI_UNKNOWN_ADDR2_FRAME_RX_IND from WDI ");
15461 break ;
15462 }
15463
15464 case WDI_MIC_FAILURE_IND:
15465 {
15466 tpSirSmeMicFailureInd pMicInd =
15467 (tpSirSmeMicFailureInd)vos_mem_malloc(sizeof(tSirSmeMicFailureInd));
15468
15469 if(NULL == pMicInd)
15470 {
15471 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15472 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15473 break;
15474 }
15475 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15476 "Received WDI_MIC_FAILURE_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15477 pMicInd->messageType = eWNI_SME_MIC_FAILURE_IND;
15478 pMicInd->length = sizeof(tSirSmeMicFailureInd);
15479 vos_mem_copy(pMicInd->bssId,
15480 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.bssId,
15481 sizeof(tSirMacAddr));
15482 vos_mem_copy(pMicInd->info.srcMacAddr,
15483 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macSrcAddr,
15484 sizeof(tSirMacAddr));
15485 vos_mem_copy(pMicInd->info.taMacAddr,
15486 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macTaAddr,
15487 sizeof(tSirMacAddr));
15488 vos_mem_copy(pMicInd->info.dstMacAddr,
15489 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macDstAddr,
15490 sizeof(tSirMacAddr));
15491 vos_mem_copy(pMicInd->info.rxMacAddr,
15492 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.macRxAddr,
15493 sizeof(tSirMacAddr));
15494 pMicInd->info.multicast =
15495 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucMulticast;
15496 pMicInd->info.keyId=
15497 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.keyId;
15498 pMicInd->info.IV1=
15499 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.ucIV1;
15500 vos_mem_copy(pMicInd->info.TSC,
15501 wdiLowLevelInd->wdiIndicationData.wdiMICFailureInfo.TSC,SIR_CIPHER_SEQ_CTR_SIZE);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15502 WDA_SendMsg(pWDA, SIR_HAL_MIC_FAILURE_IND,
15503 (void *)pMicInd , 0) ;
15504 break ;
15505 }
15506 case WDI_FATAL_ERROR_IND:
15507 {
Madan Mohan Koyyalamudia2fc6412012-10-21 12:06:12 -0700[diff] [blame]15508 pWDA->wdiFailed = true;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15509 /* TODO: Decode Ind and send Ind to PE */
15510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15511 "Received WDI_FATAL_ERROR_IND from WDI ");
15512 break ;
15513 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15514 case WDI_DEL_STA_IND:
15515 {
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15516 tpDeleteStaContext pDelSTACtx =
15517 (tpDeleteStaContext)vos_mem_malloc(sizeof(tDeleteStaContext));
15518
15519 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15520 "Received WDI_DEL_STA_IND from WDI ");
15521 if(NULL == pDelSTACtx)
15522 {
15523 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15524 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15525 break;
15526 }
15527 vos_mem_copy(pDelSTACtx->addr2,
15528 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macADDR2,
15529 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15530 vos_mem_copy(pDelSTACtx->bssId,
15531 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.macBSSID,
15532 sizeof(tSirMacAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15533 pDelSTACtx->assocId =
15534 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.usAssocId;
15535 pDelSTACtx->reasonCode =
15536 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.wptReasonCode;
15537 pDelSTACtx->staId =
15538 wdiLowLevelInd->wdiIndicationData.wdiDeleteSTAIndType.ucSTAIdx;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15539 WDA_SendMsg(pWDA, SIR_LIM_DELETE_STA_CONTEXT_IND,
15540 (void *)pDelSTACtx , 0) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15541 break ;
15542 }
15543 case WDI_COEX_IND:
15544 {
15545 tANI_U32 index;
15546 vos_msg_t vosMsg;
c_hpothub3458992014-09-19 19:58:57 +0530[diff] [blame]15547 tSirSmeCoexInd *pSmeCoexInd;
15548
15549 if (SIR_COEX_IND_TYPE_CXM_FEATURES_NOTIFICATION ==
15550 wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType)
15551 {
15552 if(wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData)
15553 {
15554 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15555 FL("Coex state: 0x%x coex feature: 0x%x"),
15556 wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[0],
15557 wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[1]);
15558
15559 if (wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[2] << 16)
15560 {
15561 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR, FL("power limit: 0x%x"),
15562 (tANI_U16)(wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[2]));
15563 }
15564 }
15565 break;
15566 }
15567
15568 pSmeCoexInd = (tSirSmeCoexInd *)vos_mem_malloc(sizeof(tSirSmeCoexInd));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15569 if(NULL == pSmeCoexInd)
15570 {
15571 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]15572 "%s: VOS MEM Alloc Failure-pSmeCoexInd", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15573 break;
15574 }
15575 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15576 "Received WDI_COEX_IND from WDI ");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15577 /* Message Header */
15578 pSmeCoexInd->mesgType = eWNI_SME_COEX_IND;
15579 pSmeCoexInd->mesgLen = sizeof(tSirSmeCoexInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15580 /* Info from WDI Indication */
15581 pSmeCoexInd->coexIndType = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndType;
15582 for (index = 0; index < SIR_COEX_IND_DATA_SIZE; index++)
15583 {
15584 pSmeCoexInd->coexIndData[index] = wdiLowLevelInd->wdiIndicationData.wdiCoexInfo.coexIndData[index];
15585 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15586 /* VOS message wrapper */
15587 vosMsg.type = eWNI_SME_COEX_IND;
15588 vosMsg.bodyptr = (void *)pSmeCoexInd;
15589 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15590 /* Send message to SME */
15591 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15592 {
15593 /* free the mem and return */
15594 vos_mem_free((v_VOID_t *)pSmeCoexInd);
15595 }
15596 else
15597 {
15598 /* DEBUG */
15599 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15600 "[COEX WDA] Coex Ind Type (%x) data (%x %x %x %x)",
15601 pSmeCoexInd->coexIndType,
15602 pSmeCoexInd->coexIndData[0],
15603 pSmeCoexInd->coexIndData[1],
15604 pSmeCoexInd->coexIndData[2],
15605 pSmeCoexInd->coexIndData[3]);
15606 }
15607 break;
15608 }
15609 case WDI_TX_COMPLETE_IND:
15610 {
15611 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
15612 /* Calling TxCompleteAck Indication from wda context*/
15613 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15614 "Complete Indication received from HAL");
15615 if( pWDA->pAckTxCbFunc )
15616 {
15617 if( VOS_STATUS_SUCCESS !=
15618 WDA_STOP_TIMER(&pWDA->wdaTimers.TxCompleteTimer))
15619 {
15620 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15621 "Tx Complete timeout Timer Stop Failed ");
Ganesh Kondabattinib18b3292015-03-16 16:59:26 +0530[diff] [blame]15622 }
Ganesh Kondabattinie1accae2015-06-11 17:18:00 +0530[diff] [blame]15623 if (!IS_FEATURE_SUPPORTED_BY_FW(ENHANCED_TXBD_COMPLETION))
Ganesh Kondabattinib18b3292015-03-16 16:59:26 +0530[diff] [blame]15624 pWDA->pAckTxCbFunc( pMac, &wdiLowLevelInd->wdiIndicationData.tx_complete_status);
15625 else
15626 pWDA->pAckTxCbFunc( pMac, &wdiLowLevelInd->wdiIndicationData.wdiTxBdInd);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15627 pWDA->pAckTxCbFunc = NULL;
15628 }
15629 else
15630 {
Ratheesh S P36dbc932015-08-07 14:28:57 +0530[diff] [blame]15631 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15632 "Tx Complete Indication is received after timeout ");
15633 }
15634 break;
15635 }
Viral Modid86bde22012-12-10 13:09:21 -0800[diff] [blame]15636 case WDI_P2P_NOA_START_IND :
15637 {
15638 tSirP2PNoaStart *pP2pNoaStart =
15639 (tSirP2PNoaStart *)vos_mem_malloc(sizeof(tSirP2PNoaStart));
15640
15641 if (NULL == pP2pNoaStart)
15642 {
15643 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15644 "Memory allocation failure, "
15645 "WDI_P2P_NOA_START_IND not forwarded");
15646 break;
15647 }
15648 pP2pNoaStart->status =
15649 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.status;
15650 pP2pNoaStart->bssIdx =
15651 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaStartInfo.bssIdx;
15652 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_START_IND,
15653 (void *)pP2pNoaStart , 0) ;
15654 break;
15655 }
15656
Gopichand Nakkala79ff85d2013-05-27 17:05:29 +0530[diff] [blame]15657#ifdef FEATURE_WLAN_TDLS
15658 case WDI_TDLS_IND :
15659 {
15660 tSirTdlsInd *pTdlsInd =
15661 (tSirTdlsInd *)vos_mem_malloc(sizeof(tSirTdlsInd));
15662
15663 if (NULL == pTdlsInd)
15664 {
15665 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15666 "Memory allocation failure, "
15667 "WDI_TDLS_IND not forwarded");
15668 break;
15669 }
15670 pTdlsInd->status =
15671 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.status;
15672 pTdlsInd->assocId =
15673 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.assocId;
15674 pTdlsInd->staIdx =
15675 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.staIdx;
15676 pTdlsInd->reasonCode =
15677 wdiLowLevelInd->wdiIndicationData.wdiTdlsIndInfo.reasonCode;
15678 WDA_SendMsg(pWDA, SIR_HAL_TDLS_IND,
15679 (void *)pTdlsInd , 0) ;
15680 break;
15681 }
15682#endif
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15683 case WDI_P2P_NOA_ATTR_IND :
15684 {
15685 tSirP2PNoaAttr *pP2pNoaAttr =
15686 (tSirP2PNoaAttr *)vos_mem_malloc(sizeof(tSirP2PNoaAttr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15688 "Received WDI_P2P_NOA_ATTR_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15689 if (NULL == pP2pNoaAttr)
15690 {
15691 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15692 "Memory allocation failure, "
15693 "WDI_P2P_NOA_ATTR_IND not forwarded");
15694 break;
15695 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15696 pP2pNoaAttr->index =
15697 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucIndex;
15698 pP2pNoaAttr->oppPsFlag =
15699 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.ucOppPsFlag;
15700 pP2pNoaAttr->ctWin =
15701 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usCtWin;
15702
15703 pP2pNoaAttr->uNoa1IntervalCnt =
15704 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa1IntervalCnt;
15705 pP2pNoaAttr->uNoa1Duration =
15706 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Duration;
15707 pP2pNoaAttr->uNoa1Interval =
15708 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1Interval;
15709 pP2pNoaAttr->uNoa1StartTime =
15710 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa1StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15711 pP2pNoaAttr->uNoa2IntervalCnt =
15712 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.usNoa2IntervalCnt;
15713 pP2pNoaAttr->uNoa2Duration =
15714 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Duration;
15715 pP2pNoaAttr->uNoa2Interval =
15716 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2Interval;
15717 pP2pNoaAttr->uNoa2StartTime =
15718 wdiLowLevelInd->wdiIndicationData.wdiP2pNoaAttrInfo.uslNoa2StartTime;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15719 WDA_SendMsg(pWDA, SIR_HAL_P2P_NOA_ATTR_IND,
15720 (void *)pP2pNoaAttr , 0) ;
15721 break;
15722 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15723#ifdef FEATURE_WLAN_SCAN_PNO
15724 case WDI_PREF_NETWORK_FOUND_IND:
15725 {
15726 vos_msg_t vosMsg;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]15727 v_U32_t size = sizeof(tSirPrefNetworkFoundInd) +
15728 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
15729 tSirPrefNetworkFoundInd *pPrefNetworkFoundInd =
15730 (tSirPrefNetworkFoundInd *)vos_mem_malloc(size);
15731
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15732 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15733 "Received WDI_PREF_NETWORK_FOUND_IND from WDI");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15734 if (NULL == pPrefNetworkFoundInd)
15735 {
15736 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15737 "Memory allocation failure, "
15738 "WDI_PREF_NETWORK_FOUND_IND not forwarded");
Kiet Lamb537cfb2013-11-07 12:56:49 +0530[diff] [blame]15739 if (NULL !=
15740 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
15741 {
15742 wpalMemoryFree(
15743 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData
15744 );
15745 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
15746 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15747 break;
15748 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15749 /* Message Header */
15750 pPrefNetworkFoundInd->mesgType = eWNI_SME_PREF_NETWORK_FOUND_IND;
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]15751 pPrefNetworkFoundInd->mesgLen = size;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15752
15753 /* Info from WDI Indication */
15754 pPrefNetworkFoundInd->ssId.length =
15755 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.ucLength;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15756 vos_mem_set( pPrefNetworkFoundInd->ssId.ssId, 32, 0);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15757 vos_mem_copy( pPrefNetworkFoundInd->ssId.ssId,
15758 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.ssId.sSSID,
15759 pPrefNetworkFoundInd->ssId.length);
Srikant Kuppa066904f2013-05-07 13:56:02 -0700[diff] [blame]15760 if (NULL !=
15761 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData)
15762 {
15763 pPrefNetworkFoundInd->frameLength =
15764 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.frameLength;
15765 vos_mem_copy( pPrefNetworkFoundInd->data,
15766 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData,
15767 pPrefNetworkFoundInd->frameLength);
15768 wpalMemoryFree(wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData);
15769 wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.pData = NULL;
15770 }
15771 else
15772 {
15773 pPrefNetworkFoundInd->frameLength = 0;
15774 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15775 pPrefNetworkFoundInd ->rssi = wdiLowLevelInd->wdiIndicationData.wdiPrefNetworkFoundInd.rssi;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15776 /* VOS message wrapper */
15777 vosMsg.type = eWNI_SME_PREF_NETWORK_FOUND_IND;
15778 vosMsg.bodyptr = (void *) pPrefNetworkFoundInd;
15779 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15780 /* Send message to SME */
15781 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15782 {
15783 /* free the mem and return */
15784 vos_mem_free((v_VOID_t *) pPrefNetworkFoundInd);
15785 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15786 break;
15787 }
15788#endif // FEATURE_WLAN_SCAN_PNO
15789
15790#ifdef WLAN_WAKEUP_EVENTS
15791 case WDI_WAKE_REASON_IND:
15792 {
15793 vos_msg_t vosMsg;
15794 tANI_U32 allocSize = sizeof(tSirWakeReasonInd)
15795 + (wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen - 1);
15796 tSirWakeReasonInd *pWakeReasonInd = (tSirWakeReasonInd *)vos_mem_malloc(allocSize);
15797
15798 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Sushant Kaushik1b645382014-10-13 16:39:36 +0530[diff] [blame]15799 "[WAKE_REASON WDI] WAKE_REASON_IND Type (%d) data (ulReason=0x%x, ulReasonArg=0x%x, ulStoredDataLen=0x%x)",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15800 wdiLowLevelInd->wdiIndicationType,
15801 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason,
15802 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg,
15803 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
15804
15805 if (NULL == pWakeReasonInd)
15806 {
15807 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15808 "Memory allocation failure, "
15809 "WDI_WAKE_REASON_IND not forwarded");
15810 break;
15811 }
15812
15813 vos_mem_zero(pWakeReasonInd, allocSize);
15814
15815 /* Message Header */
15816 pWakeReasonInd->mesgType = eWNI_SME_WAKE_REASON_IND;
15817 pWakeReasonInd->mesgLen = allocSize;
15818
15819 /* Info from WDI Indication */
15820 // Fill pWakeReasonInd structure from wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd
15821 pWakeReasonInd->ulReason = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReason;
15822 pWakeReasonInd->ulReasonArg = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulReasonArg;
15823 pWakeReasonInd->ulStoredDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen;
15824 pWakeReasonInd->ulActualDataLen = wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulActualDataLen;
15825 vos_mem_copy( (void *)&(pWakeReasonInd->aDataStart[0]),
15826 &(wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.aDataStart[0]),
15827 wdiLowLevelInd->wdiIndicationData.wdiWakeReasonInd.ulStoredDataLen);
15828
15829 /* VOS message wrapper */
15830 vosMsg.type = eWNI_SME_WAKE_REASON_IND;
15831 vosMsg.bodyptr = (void *) pWakeReasonInd;
15832 vosMsg.bodyval = 0;
15833
15834 /* Send message to SME */
15835 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15836 {
15837 /* free the mem and return */
15838 vos_mem_free((v_VOID_t *) pWakeReasonInd);
15839 }
15840
15841 break;
15842 }
15843#endif // WLAN_WAKEUP_EVENTS
15844
15845 case WDI_TX_PER_HIT_IND:
15846 {
15847 vos_msg_t vosMsg;
15848 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO, "Get WDI_TX_PER_HIT_IND");
15849 /* send IND to PE eWNI_SME_TX_PER_HIT_IND*/
15850 /* VOS message wrapper */
15851 vosMsg.type = eWNI_SME_TX_PER_HIT_IND;
15852 vosMsg.bodyptr = NULL;
15853 vosMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]15854 /* Send message to SME */
15855 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15856 {
15857 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN, "post eWNI_SME_TX_PER_HIT_IND to SME Failed");
15858 }
15859 break;
15860 }
15861
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15862#ifdef FEATURE_WLAN_LPHB
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15863 case WDI_LPHB_IND:
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15864 {
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15865 vos_msg_t vosMsg;
15866 tSirLPHBInd *lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15867
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15868 lphbInd =
15869 (tSirLPHBInd *)vos_mem_malloc(sizeof(tSirLPHBInd));
15870 if (NULL == lphbInd)
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15871 {
15872 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15873 "%s: LPHB IND buffer alloc Fail", __func__);
15874 return ;
15875 }
15876
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15877 lphbInd->sessionIdx =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15878 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.sessionIdx;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15879 lphbInd->protocolType =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15880 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.protocolType;
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15881 lphbInd->eventReason =
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15882 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.eventReason;
15883
15884 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15885 "Get WDI_LPHB_IND bssIdx %d",
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15886 wdiLowLevelInd->wdiIndicationData.wdiLPHBTimeoutInd.bssIdx);
15887
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15888 vosMsg.type = eWNI_SME_LPHB_IND;
15889 vosMsg.bodyptr = lphbInd;
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15890 vosMsg.bodyval = 0;
15891 /* Send message to SME */
15892 if (VOS_STATUS_SUCCESS !=
15893 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
15894 {
15895 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
15896 "post WDI_LPHB_WAIT_TIMEOUT_IND to SME Failed");
Leo Changd9df8aa2013-09-26 13:32:26 -0700[diff] [blame]15897 vos_mem_free(lphbInd);
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15898 }
15899 break;
15900 }
15901#endif /* FEATURE_WLAN_LPHB */
Yue Mab9c86f42013-08-14 15:59:08 -0700[diff] [blame]15902 case WDI_PERIODIC_TX_PTRN_FW_IND:
15903 {
15904 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
15905 "%s: WDI_PERIODIC_TX_PTRN_FW_IND received, bssIdx: %d, "
15906 "selfStaIdx: %d, status: %d, patternIdBitmap: %d", __func__,
15907 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.bssIdx,
15908 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.selfStaIdx,
15909 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.status,
15910 (int)wdiLowLevelInd->wdiIndicationData.wdiPeriodicTxPtrnFwInd.patternIdBitmap);
15911
15912 break;
15913 }
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]15914
Ravi Joshid2ca7c42013-07-23 08:37:49 -0700[diff] [blame]15915 case WDI_IBSS_PEER_INACTIVITY_IND:
15916 {
15917 tSirIbssPeerInactivityInd *pIbssInd =
15918 (tSirIbssPeerInactivityInd *)
15919 vos_mem_malloc(sizeof(tSirIbssPeerInactivityInd));
15920
15921 if (NULL == pIbssInd)
15922 {
15923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15924 "Memory allocation failure, "
15925 "WDI_IBSS_PEER_INACTIVITY_IND not forwarded");
15926 break;
15927 }
15928
15929 pIbssInd->bssIdx =
15930 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.bssIdx;
15931 pIbssInd->staIdx =
15932 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staIdx;
15933 vos_mem_copy(pIbssInd->peerAddr,
15934 wdiLowLevelInd->wdiIndicationData.wdiIbssPeerInactivityInd.staMacAddr,
15935 sizeof(tSirMacAddr));
15936 WDA_SendMsg(pWDA, WDA_IBSS_PEER_INACTIVITY_IND, (void *)pIbssInd, 0) ;
15937 break;
15938 }
15939
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]15940#ifdef FEATURE_WLAN_BATCH_SCAN
15941 case WDI_BATCH_SCAN_RESULT_IND:
15942 {
15943 void *pBatchScanResult;
15944 void *pCallbackContext;
15945 tpAniSirGlobal pMac;
15946
15947 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_HIGH,
15948 "Received WDI_BATCHSCAN_RESULT_IND from FW");
15949
15950 /*sanity check*/
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]15951 if (NULL == pWDA)
Rajeev79dbe4c2013-10-05 11:03:42 +0530[diff] [blame]15952 {
15953 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15954 "%s:pWDA is NULL", __func__);
15955 VOS_ASSERT(0);
15956 return;
15957 }
15958
15959 pBatchScanResult =
15960 (void *)wdiLowLevelInd->wdiIndicationData.pBatchScanResult;
15961 if (NULL == pBatchScanResult)
15962 {
15963 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15964 "%s:Batch scan result from FW is null can't invoke HDD callback",
15965 __func__);
15966 VOS_ASSERT(0);
15967 return;
15968 }
15969
15970 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
15971 if (NULL == pMac)
15972 {
15973 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15974 "%s:pMac is NULL", __func__);
15975 VOS_ASSERT(0);
15976 return;
15977 }
15978
15979 pCallbackContext = pMac->pmc.batchScanResultCallbackContext;
15980 /*call hdd callback with set batch scan response data*/
15981 if(pMac->pmc.batchScanResultCallback)
15982 {
15983 pMac->pmc.batchScanResultCallback(pCallbackContext,
15984 pBatchScanResult);
15985 }
15986 else
15987 {
15988 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
15989 "%s:HDD callback is null", __func__);
15990 VOS_ASSERT(0);
15991 }
15992 break;
15993 }
15994#endif
15995
Leo Chang0b0e45a2013-12-15 15:18:55 -0800[diff] [blame]15996#ifdef FEATURE_WLAN_CH_AVOID
15997 case WDI_CH_AVOID_IND:
15998 {
15999 vos_msg_t vosMsg;
16000 tSirChAvoidIndType *chAvoidInd;
16001
16002 chAvoidInd =
16003 (tSirChAvoidIndType *)vos_mem_malloc(sizeof(tSirChAvoidIndType));
16004 if (NULL == chAvoidInd)
16005 {
16006 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16007 "%s: CH_AVOID IND buffer alloc Fail", __func__);
16008 return ;
16009 }
16010
16011 chAvoidInd->avoidRangeCount =
16012 wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidRangeCount;
16013 wpalMemoryCopy((void *)chAvoidInd->avoidFreqRange,
16014 (void *)wdiLowLevelInd->wdiIndicationData.wdiChAvoidInd.avoidFreqRange,
16015 chAvoidInd->avoidRangeCount * sizeof(tSirChAvoidFreqType));
16016
16017 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16018 "%s : WDA CH avoid notification", __func__);
16019
16020 vosMsg.type = eWNI_SME_CH_AVOID_IND;
16021 vosMsg.bodyptr = chAvoidInd;
16022 vosMsg.bodyval = 0;
16023 /* Send message to SME */
16024 if (VOS_STATUS_SUCCESS !=
16025 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
16026 {
16027 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16028 "post eWNI_SME_CH_AVOID_IND to SME Failed");
16029 vos_mem_free(chAvoidInd);
16030 }
16031 break;
16032 }
16033#endif /* FEATURE_WLAN_CH_AVOID */
16034
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]16035#ifdef WLAN_FEATURE_LINK_LAYER_STATS
16036 case WDI_LL_STATS_RESULTS_IND:
16037 {
16038 void *pLinkLayerStatsInd;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]16039 tpAniSirGlobal pMac;
16040
16041 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16042 "Received WDI_LL_STATS_RESULTS_IND from FW");
16043
16044 /*sanity check*/
16045 if (NULL == pWDA)
16046 {
16047 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16048 "%s:pWDA is NULL", __func__);
16049 VOS_ASSERT(0);
16050 return;
16051 }
16052
16053 pLinkLayerStatsInd =
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]16054 (void *)wdiLowLevelInd->
16055 wdiIndicationData.wdiLinkLayerStatsResults.pLinkLayerStatsResults;
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]16056 if (NULL == pLinkLayerStatsInd)
16057 {
16058 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16059 "%s:Link Layer Statistics from FW is null can't invoke HDD callback",
16060 __func__);
16061 VOS_ASSERT(0);
16062 return;
16063 }
16064
16065 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16066 if (NULL == pMac)
16067 {
16068 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16069 "%s:pMac is NULL", __func__);
16070 VOS_ASSERT(0);
16071 return;
16072 }
16073
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]16074 /* call hdd callback with Link Layer Statistics.
16075 * vdev_id/ifacId in link_stats_results will be
16076 * used to retrieve the correct HDD context
16077 */
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]16078 if (pMac->sme.pLinkLayerStatsIndCallback)
16079 {
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]16080 pMac->sme.pLinkLayerStatsIndCallback(pMac->pAdapter,
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]16081 WDA_LINK_LAYER_STATS_RESULTS_RSP,
Dino Mycled3d50022014-07-07 12:58:25 +0530[diff] [blame]16082 pLinkLayerStatsInd,
16083 wdiLowLevelInd->
16084 wdiIndicationData.wdiLinkLayerStatsResults.macAddr);
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]16085 }
16086 else
16087 {
16088 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16089 "%s:HDD callback is null", __func__);
16090 }
16091 break;
16092 }
16093#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
16094
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16095#ifdef WLAN_FEATURE_EXTSCAN
16096 case WDI_EXTSCAN_PROGRESS_IND:
16097 case WDI_EXTSCAN_SCAN_AVAILABLE_IND:
16098 case WDI_EXTSCAN_SCAN_RESULT_IND:
16099 case WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND:
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]16100 case WDI_EXTSCAN_SSID_HOTLIST_RESULT_IND:
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16101 {
16102 void *pEXTScanData;
16103 void *pCallbackContext;
16104 tpAniSirGlobal pMac;
16105 tANI_U16 indType;
16106
16107 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16108 "Received WDI_EXTSCAN Indications from FW");
16109 /*sanity check*/
16110 if (NULL == pWDA)
16111 {
16112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16113 "%s:pWDA is NULL", __func__);
16114 VOS_ASSERT(0);
16115 return;
16116 }
16117 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_PROGRESS_IND)
16118 {
16119 indType = WDA_EXTSCAN_PROGRESS_IND;
16120
16121 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16122 "WDI_EXTSCAN Indication is WDI_EXTSCAN_PROGRESS_IND");
16123 }
16124 if (wdiLowLevelInd->wdiIndicationType ==
16125 WDI_EXTSCAN_SCAN_AVAILABLE_IND)
16126 {
16127 indType = WDA_EXTSCAN_SCAN_AVAILABLE_IND;
16128
16129 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16130 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_AVAILABLE_IND");
16131 }
16132 if (wdiLowLevelInd->wdiIndicationType == WDI_EXTSCAN_SCAN_RESULT_IND)
16133 {
16134 indType = WDA_EXTSCAN_SCAN_RESULT_IND;
16135
16136 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16137 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SCAN_RESULT_IND");
16138 }
16139 if (wdiLowLevelInd->wdiIndicationType ==
16140 WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND)
16141 {
16142 indType = WDA_EXTSCAN_BSSID_HOTLIST_RESULT_IND;
16143
16144 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16145 "WDI_EXTSCAN Indication is WDI_EXTSCAN_BSSID_HOTLIST_RESULT_IND");
16146 }
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]16147 if (wdiLowLevelInd->wdiIndicationType ==
16148 WDI_EXTSCAN_SSID_HOTLIST_RESULT_IND)
16149 {
16150 indType = WDA_EXTSCAN_SSID_HOTLIST_RESULT_IND;
16151
16152 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16153 "WDI_EXTSCAN Indication is WDI_EXTSCAN_SSID_HOTLIST_RESULT_IND");
16154 }
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16155
16156 pEXTScanData =
16157 (void *)wdiLowLevelInd->wdiIndicationData.pEXTScanIndData;
16158 if (NULL == pEXTScanData)
16159 {
16160 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16161 "%s: EXTSCAN Indication Data is null, can't invoke HDD callback",
16162 __func__);
16163 VOS_ASSERT(0);
16164 return;
16165 }
16166
16167 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16168 if (NULL == pMac)
16169 {
16170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16171 "%s:pMac is NULL", __func__);
16172 VOS_ASSERT(0);
16173 return;
16174 }
16175
16176 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
16177
16178 if(pMac->sme.pEXTScanIndCb)
16179 {
16180 pMac->sme.pEXTScanIndCb(pCallbackContext,
16181 indType,
16182 pEXTScanData);
16183 }
16184 else
16185 {
16186 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16187 "%s:HDD callback is null", __func__);
16188 }
16189 break;
16190 }
16191#endif /* WLAN_FEATURE_EXTSCAN */
Abhishek Singh66c16762014-08-14 19:13:19 +0530[diff] [blame]16192 case WDI_DEL_BA_IND:
16193 {
16194 tpBADeleteParams pDelBAInd =
16195 (tpBADeleteParams)vos_mem_malloc(sizeof(tpBADeleteParams));
16196
16197 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16198 "Received WDI_DEL_BA_IND from WDI ");
16199 if(NULL == pDelBAInd)
16200 {
16201 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16202 "%s: VOS MEM Alloc Failure", __func__);
16203 break;
16204 }
16205 vos_mem_copy(pDelBAInd->peerMacAddr,
16206 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.peerMacAddr,
16207 sizeof(tSirMacAddr));
16208 vos_mem_copy(pDelBAInd->bssId,
16209 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.bssId,
16210 sizeof(tSirMacAddr));
16211 pDelBAInd->staIdx =
16212 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.staIdx;
16213 pDelBAInd->baTID =
16214 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baTID;
16215 pDelBAInd->baDirection =
16216 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.baDirection;
16217 pDelBAInd->reasonCode =
16218 wdiLowLevelInd->wdiIndicationData.wdiDeleteBAInd.reasonCode;
16219
16220 WDA_SendMsg(pWDA, SIR_LIM_DEL_BA_IND,
16221 (void *)pDelBAInd , 0) ;
16222 break;
16223 }
Srinivas Dasari32a79262015-02-19 13:04:49 +0530[diff] [blame]16224 case WDI_NAN_EVENT_IND:
16225 {
16226 vos_msg_t vosMsg;
16227 tpSirNanEvent pSirNanEvent = NULL;
16228
16229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16230 "Received WDI_NAN_EVENT");
16231
16232 pSirNanEvent = (tpSirNanEvent)vos_mem_malloc( sizeof( tSirNanEvent )
16233 - sizeof( pSirNanEvent->event_data)
16234 + wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data_len);
16235
16236 if (NULL == pSirNanEvent)
16237 {
16238 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16239 "%s: VOS MEM Alloc Failure", __func__);
16240 VOS_ASSERT(0) ;
16241 break;
16242 }
16243
16244 pSirNanEvent->event_data_len =
16245 wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data_len;
16246
16247 if (wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data_len)
16248 {
16249 vos_mem_copy( pSirNanEvent->event_data,
16250 wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data,
16251 wdiLowLevelInd->wdiIndicationData.wdiNanEvent.event_data_len);
16252 }
16253
16254 /* VOS message wrapper */
16255 vosMsg.type = eWNI_SME_NAN_EVENT;
16256 vosMsg.bodyptr = pSirNanEvent;
16257 vosMsg.bodyval = 0;
16258
16259 /* Send message to SME */
16260 if (VOS_STATUS_SUCCESS
16261 != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
16262 {
16263 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
16264 "post eWNI_SME_NAN_EVENT to SME Failed");
16265 vos_mem_free(pSirNanEvent);
16266 }
16267 break;
16268 }
Sachin Ahuja3d47fcd2015-08-28 16:02:06 +0530[diff] [blame]16269 case WDI_LOST_LINK_PARAMS_IND:
16270 {
16271 tpSirSmeLostLinkParamsInd pLostLinkParamInd =
16272 (tpSirSmeLostLinkParamsInd)vos_mem_malloc(sizeof(tSirSmeLostLinkParamsInd));
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]16273
Sachin Ahuja3d47fcd2015-08-28 16:02:06 +0530[diff] [blame]16274 if (NULL == pLostLinkParamInd)
16275 {
16276 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16277 "%s: VOS MEM Alloc Failure", __func__);
16278 break;
16279 }
16280 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16281 "Received WDI_LOST_LINK_PARAMS_IND from WDI ");
16282
16283 pLostLinkParamInd->messageType = eWNI_SME_LOST_LINK_PARAMS_IND;
16284 pLostLinkParamInd->length = sizeof(tSirSmeMicFailureInd);
16285 pLostLinkParamInd->info.bssIdx =
16286 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.bssIdx;
16287 pLostLinkParamInd->info.rssi =
16288 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.rssi;
16289 vos_mem_copy(pLostLinkParamInd->info.selfMacAddr,
16290 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.selfMacAddr,
16291 sizeof(tSirMacAddr));
16292 pLostLinkParamInd->info.linkFlCnt =
16293 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.linkFlCnt;
16294 pLostLinkParamInd->info.linkFlTx =
16295 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.linkFlTx;
16296 pLostLinkParamInd->info.lastDataRate =
16297 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.lastDataRate;
16298 pLostLinkParamInd->info.rsvd1 =
16299 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.rsvd1;
16300 pLostLinkParamInd->info.rsvd2 =
16301 wdiLowLevelInd->wdiIndicationData.wdiLostLinkParamsInd.rsvd2;
16302 WDA_SendMsg(pWDA, SIR_HAL_LOST_LINK_PARAMS_IND,
16303 (void *)pLostLinkParamInd , 0) ;
16304 break;
16305 }
Gupta, Kapil7c34b322015-09-30 13:12:35 +0530[diff] [blame]16306 case WDI_RSSI_BREACHED_IND:
16307 {
16308 WDI_RssiBreachedIndType *pRssiBreachedInd;
16309 tpAniSirGlobal pMac;
16310
16311 pRssiBreachedInd =
16312 (WDI_RssiBreachedIndType *)vos_mem_malloc(sizeof(WDI_RssiBreachedIndType));
16313 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16314 "Received WDI_RSSI_BREACHED_IND from FW");
16315
16316 vos_mem_copy(pRssiBreachedInd,
16317 &wdiLowLevelInd->wdiIndicationData.wdiRssiBreachedInd,
16318 sizeof(WDI_RssiBreachedIndType));
16319
16320 /*sanity check*/
16321 if (NULL == pWDA)
16322 {
16323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16324 "%s:pWDA is NULL", __func__);
16325 vos_mem_free(pRssiBreachedInd);
16326 VOS_ASSERT(0);
16327 return;
16328 }
16329
16330 if (NULL == pRssiBreachedInd)
16331 {
16332 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16333 "%s:Breach indication from FW is null can't invoke HDD callback",
16334 __func__);
16335 VOS_ASSERT(0);
16336 return;
16337 }
16338
16339 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16340 if (NULL == pMac)
16341 {
16342 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16343 "%s:pMac is NULL", __func__);
16344 VOS_ASSERT(0);
16345 vos_mem_free(pRssiBreachedInd);
16346 return;
16347 }
16348
16349 if (pMac->sme.rssiThresholdBreachedCb)
16350 {
16351 pMac->sme.rssiThresholdBreachedCb(pMac->pAdapter, (void *)pRssiBreachedInd);
16352 }
16353 else
16354 {
16355 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16356 "%s:HDD callback is null", __func__);
16357 }
16358 vos_mem_free(pRssiBreachedInd);
16359 break;
16360 }
Padma, Santhosh Kumar2ccac212015-10-20 17:27:27 +0530[diff] [blame]16361#ifdef FEATURE_OEM_DATA_SUPPORT
16362 case WDI_START_OEM_DATA_RSP_IND_NEW:
16363 {
16364 void *pCallbackContext;
16365 tpAniSirGlobal pMac;
16366 tANI_U16 indType;
16367 void *pOemRspNewIndData;
16368
16369 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16370 "Received WDI_START_OEM_DATA_RSP_IND_NEW Indications from FW");
16371
16372 /*sanity check*/
16373 if (NULL == pWDA)
16374 {
16375 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16376 "%s:pWDA is NULL", __func__);
16377 VOS_ASSERT(0);
16378 return;
16379 }
16380
16381 indType = WDA_START_OEM_DATA_RSP_IND_NEW;
16382 pOemRspNewIndData =
16383 (void *)wdiLowLevelInd->wdiIndicationData.pOemRspNewIndData;
16384 if (NULL == pOemRspNewIndData)
16385 {
16386 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16387 "%s: OEM_DATA_RSP_IND_NEW Indication Data is null, can't invoke HDD callback",
16388 __func__);
16389 VOS_ASSERT(0);
16390 return;
16391 }
16392
16393 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16394 if (NULL == pMac)
16395 {
16396 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16397 "%s:pMac is NULL", __func__);
16398 VOS_ASSERT(0);
16399 return;
16400 }
16401
16402 pCallbackContext = pMac->sme.pOemDataCallbackContext;
16403
16404 if(pMac->sme.pOemDataIndCb)
16405 {
16406 pMac->sme.pOemDataIndCb(pCallbackContext,
16407 indType,
16408 pOemRspNewIndData);
16409 }
16410 else
16411 {
16412 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16413 "%s:HDD callback is null", __func__);
16414 }
16415 break;
16416 }
16417#endif /* FEATURE_OEM_DATA_SUPPORT */
16418
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16419 default:
16420 {
16421 /* TODO error */
16422 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16423 "Received UNKNOWN Indication from WDI ");
16424 }
16425 }
16426 return ;
16427}
16428
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16429/*
16430 * BA related processing in WDA.
16431 */
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16432void WDA_TriggerBaReqCallback(WDI_TriggerBARspParamsType *wdiTriggerBaRsp,
16433 void* pUserData)
16434{
16435 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
16436 tWDA_CbContext *pWDA;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16437 if(NULL == pWdaParams)
16438 {
16439 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16440 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16441 VOS_ASSERT(0) ;
16442 return ;
16443 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16444 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16445 vos_mem_free(pWdaParams->wdaMsgParam) ;
16446 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16447 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16448 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16449 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16450 if(WDI_STATUS_SUCCESS == wdiTriggerBaRsp->wdiStatus)
16451 {
16452 tANI_U8 i = 0 ;
16453 tBaActivityInd *baActivityInd = NULL ;
16454 tANI_U8 baCandidateCount = wdiTriggerBaRsp->usBaCandidateCnt ;
16455 tANI_U8 allocSize = sizeof(tBaActivityInd)
16456 + sizeof(tAddBaCandidate) * (baCandidateCount) ;
16457 WDI_TriggerBARspCandidateType *wdiBaCandidate = NULL ;
16458 tAddBaCandidate *baCandidate = NULL ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16459 baActivityInd = (tBaActivityInd *)vos_mem_malloc(allocSize) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16460 if(NULL == baActivityInd)
16461 {
16462 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16463 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16464 VOS_ASSERT(0) ;
16465 return;
16466 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16467 vos_mem_copy(baActivityInd->bssId, wdiTriggerBaRsp->macBSSID,
16468 sizeof(tSirMacAddr)) ;
16469 baActivityInd->baCandidateCnt = baCandidateCount ;
16470
16471 wdiBaCandidate = (WDI_TriggerBARspCandidateType*)(wdiTriggerBaRsp + 1) ;
16472 baCandidate = (tAddBaCandidate*)(baActivityInd + 1) ;
16473
16474 for(i = 0 ; i < baCandidateCount ; i++)
16475 {
16476 tANI_U8 tid = 0 ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16477 vos_mem_copy(baCandidate->staAddr, wdiBaCandidate->macSTA,
16478 sizeof(tSirMacAddr)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16479 for(tid = 0 ; tid < STACFG_MAX_TC; tid++)
16480 {
16481 baCandidate->baInfo[tid].fBaEnable =
16482 wdiBaCandidate->wdiBAInfo[tid].fBaEnable ;
16483 baCandidate->baInfo[tid].startingSeqNum =
16484 wdiBaCandidate->wdiBAInfo[tid].startingSeqNum ;
16485 }
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]16486 wdiBaCandidate++ ;
16487 baCandidate++ ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16488 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16489 WDA_SendMsg(pWDA, SIR_LIM_ADD_BA_IND, (void *)baActivityInd , 0) ;
16490 }
16491 else
16492 {
16493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16494 "BA Trigger RSP with Failure received ");
16495 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16496 return ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16497}
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16498
16499
16500/*
16501 * API to activate/deactivate Traffic Stats timer. Traffic stats timer is only needed
16502 * during MCC
16503 */
16504void WDA_TrafficStatsTimerActivate(wpt_boolean activate)
16505{
16506 wpt_uint32 enabled;
16507 v_VOID_t * pVosContext = vos_get_global_context(VOS_MODULE_ID_WDA, NULL);
16508 tWDA_CbContext *pWDA = vos_get_context(VOS_MODULE_ID_WDA, pVosContext);
16509 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pVosContext);
16510
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]16511 if (NULL == pMac )
16512 {
16513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16514 "%s: Invoked with invalid MAC context ", __func__ );
16515 VOS_ASSERT(0);
16516 return;
16517 }
16518
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16519 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
16520 != eSIR_SUCCESS)
16521 {
16522 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16523 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
16524 return;
16525 }
16526
16527 if(!enabled)
16528 {
16529 return;
16530 }
16531
16532 if(NULL == pWDA)
16533 {
16534 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16535 "%s:WDA context is NULL", __func__);
16536 VOS_ASSERT(0);
16537 return;
16538 }
16539
16540 if(activate)
16541 {
16542 if( VOS_STATUS_SUCCESS !=
16543 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
16544 {
16545 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16546 "Traffic Stats Timer Start Failed ");
16547 return;
16548 }
16549 WDI_DS_ActivateTrafficStats();
16550 }
16551 else
16552 {
16553 WDI_DS_DeactivateTrafficStats();
16554 WDI_DS_ClearTrafficStats();
16555
16556 if( VOS_STATUS_SUCCESS !=
16557 WDA_STOP_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
16558 {
16559 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16560 "Traffic Stats Timer Stop Failed ");
16561 return;
16562 }
16563 }
16564}
16565
16566/*
16567 * Traffic Stats Timer handler
16568 */
16569void WDA_TimerTrafficStatsInd(tWDA_CbContext *pWDA)
16570{
16571 WDI_Status wdiStatus;
16572 WDI_TrafficStatsType *pWdiTrafficStats = NULL;
16573 WDI_TrafficStatsIndType trafficStatsIndParams;
16574 wpt_uint32 length, enabled;
16575 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16576
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]16577 if (NULL == pMac )
16578 {
16579 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16580 "%s: Invoked with invalid MAC context ", __func__ );
16581 VOS_ASSERT(0);
16582 return;
16583 }
16584
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16585 if(wlan_cfgGetInt(pMac, WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED, &enabled)
16586 != eSIR_SUCCESS)
16587 {
16588 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16589 "Failed to get WNI_CFG_ENABLE_MCC_ADAPTIVE_SCHED");
16590 return;
16591 }
16592
16593 if(!enabled)
16594 {
16595 WDI_DS_DeactivateTrafficStats();
16596 return;
16597 }
16598
16599 WDI_DS_GetTrafficStats(&pWdiTrafficStats, &length);
16600
16601 if(pWdiTrafficStats != NULL)
16602 {
16603 trafficStatsIndParams.pTrafficStats = pWdiTrafficStats;
16604 trafficStatsIndParams.length = length;
16605 trafficStatsIndParams.duration =
Kumar Anand90ca3dd2013-01-18 15:24:47 -0800[diff] [blame]16606 pWDA->wdaTimers.trafficStatsTimer.initScheduleTimeInMsecs;
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16607 trafficStatsIndParams.wdiReqStatusCB = WDA_WdiIndicationCallback;
16608 trafficStatsIndParams.pUserData = pWDA;
16609
16610 wdiStatus = WDI_TrafficStatsInd(&trafficStatsIndParams);
16611
16612 if(WDI_STATUS_PENDING == wdiStatus)
16613 {
16614 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16615 "Pending received for %s:%d ",__func__,__LINE__ );
16616 }
16617 else if( WDI_STATUS_SUCCESS_SYNC != wdiStatus )
16618 {
16619 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16620 "Failure in %s:%d ",__func__,__LINE__ );
16621 }
16622
16623 WDI_DS_ClearTrafficStats();
16624 }
16625 else
16626 {
16627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
16628 "pWdiTrafficStats is Null");
16629 }
16630
16631 if( VOS_STATUS_SUCCESS !=
16632 WDA_START_TIMER(&pWDA->wdaTimers.trafficStatsTimer))
16633 {
16634 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_WARN,
16635 "Traffic Stats Timer Start Failed ");
16636 return;
16637 }
16638}
16639
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16640/*
16641 * BA Activity check timer handler
16642 */
16643void WDA_BaCheckActivity(tWDA_CbContext *pWDA)
16644{
16645 tANI_U8 curSta = 0 ;
16646 tANI_U8 tid = 0 ;
16647 tANI_U8 size = 0 ;
16648 tANI_U8 baCandidateCount = 0 ;
16649 tANI_U8 newBaCandidate = 0 ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16650 tANI_U32 val;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16651 WDI_TriggerBAReqCandidateType baCandidate[WDA_MAX_STA] = {{0}} ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16652 tpAniSirGlobal pMac;
16653
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]16654 if (NULL == pWDA)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16655 {
16656 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Deepthi Gowri2bbf56f2014-12-22 13:15:14 +0530[diff] [blame]16657 "%s:pWDA is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16658 VOS_ASSERT(0);
16659 return ;
16660 }
16661 if(WDA_MAX_STA < pWDA->wdaMaxSta)
16662 {
16663 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16664 "Inconsistent STA entries in WDA");
16665 VOS_ASSERT(0) ;
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16666 }
16667 if(NULL == pWDA->pVosContext)
16668 {
16669 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16670 "%s: pVosContext is NULL",__func__);
16671 VOS_ASSERT(0);
16672 return ;
16673 }
16674 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
Abhishek Singh68883952014-10-14 11:59:05 +0530[diff] [blame]16675 if(NULL == pMac)
16676 {
16677 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16678 "%s: pMac is NULL",__func__);
16679 VOS_ASSERT(0);
16680 return ;
16681 }
16682
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16683 if (wlan_cfgGetInt(pMac,
16684 WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC, &val) !=
16685 eSIR_SUCCESS)
16686 {
16687 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16688 "Unable to get WNI_CFG_DEL_ALL_RX_TX_BA_SESSIONS_2_4_G_BTC");
16689 val = 0;
16690 }
16691
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16692 /* walk through all STA entries and find out TX packet count */
16693 for(curSta = 0 ; curSta < pWDA->wdaMaxSta ; curSta++)
16694 {
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16695 tANI_U32 currentOperChan = pWDA->wdaStaInfo[curSta].currentOperChan;
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]16696#ifdef WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16697 // We can only do BA on "hard" STAs.
16698 if (!(IS_HWSTA_IDX(curSta)))
16699 {
16700 continue;
16701 }
Gopichand Nakkala976e3252013-01-03 15:45:56 -0800[diff] [blame]16702#endif //WLAN_SOFTAP_VSTA_FEATURE
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16703 for(tid = 0 ; tid < STACFG_MAX_TC ; tid++)
16704 {
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]16705 WLANTL_STAStateType tlSTAState ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16706 tANI_U32 txPktCount = 0 ;
16707 tANI_U8 validStaIndex = pWDA->wdaStaInfo[curSta].ucValidStaIndex ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16708 if((WDA_VALID_STA_INDEX == validStaIndex) &&
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]16709 (VOS_STATUS_SUCCESS == WDA_TL_GET_STA_STATE( pWDA->pVosContext,
16710 curSta, &tlSTAState)) &&
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16711 (VOS_STATUS_SUCCESS == WDA_TL_GET_TX_PKTCOUNT( pWDA->pVosContext,
16712 curSta, tid, &txPktCount)))
16713 {
16714#if 0
16715 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
16716 "************* %d:%d, %d ",curSta, txPktCount,
16717 pWDA->wdaStaInfo[curSta].framesTxed[tid]);
16718#endif
Abhishek Singh0644e482014-10-06 18:38:23 +0530[diff] [blame]16719 if(val && ( (currentOperChan >= SIR_11B_CHANNEL_BEGIN) &&
16720 (currentOperChan <= SIR_11B_CHANNEL_END)))
16721 {
16722 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16723 "%s: BTC disabled aggregation - dont start "
16724 "TX ADDBA req",__func__);
16725 }
16726 else if(!WDA_GET_BA_TXFLAG(pWDA, curSta, tid)
Madan Mohan Koyyalamudifc1d1fe2012-10-18 15:07:12 -0700[diff] [blame]16727 && (WLANTL_STA_AUTHENTICATED == tlSTAState)
Abhishek Singh424ae432014-12-05 11:54:54 +0530[diff] [blame]16728 && (((eSYSTEM_STA_IN_IBSS_ROLE ==
16729 pWDA->wdaGlobalSystemRole) && txPktCount )
16730 || (txPktCount >= WDA_LAST_POLLED_THRESHOLD(pWDA,
16731 curSta, tid))))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16732 {
16733 /* get prepare for sending message to HAL */
16734 //baCandidate[baCandidateCount].staIdx = curSta ;
16735 baCandidate[baCandidateCount].ucTidBitmap |= 1 << tid ;
16736 newBaCandidate = WDA_ENABLE_BA ;
16737 }
16738 pWDA->wdaStaInfo[curSta].framesTxed[tid] = txPktCount ;
16739 }
16740 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16741 /* fill the entry for all the sta with given TID's */
16742 if(WDA_ENABLE_BA == newBaCandidate)
16743 {
16744 /* move to next BA candidate */
16745 baCandidate[baCandidateCount].ucSTAIdx = curSta ;
16746 size += sizeof(WDI_TriggerBAReqCandidateType) ;
16747 baCandidateCount++ ;
16748 newBaCandidate = WDA_DISABLE_BA ;
16749 }
16750 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16751 /* prepare and send message to hal */
16752 if( 0 < baCandidateCount)
16753 {
16754 WDI_Status status = WDI_STATUS_SUCCESS ;
16755 WDI_TriggerBAReqParamsType *wdiTriggerBaReq;
16756 tWDA_ReqParams *pWdaParams =
16757 (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16758 if(NULL == pWdaParams)
16759 {
16760 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16761 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16762 VOS_ASSERT(0) ;
16763 return;
16764 }
16765 wdiTriggerBaReq = (WDI_TriggerBAReqParamsType *)
16766 vos_mem_malloc(sizeof(WDI_TriggerBAReqParamsType) + size) ;
16767 if(NULL == wdiTriggerBaReq)
16768 {
16769 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16770 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16771 VOS_ASSERT(0) ;
16772 vos_mem_free(pWdaParams);
16773 return;
16774 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16775 do
16776 {
16777 WDI_TriggerBAReqinfoType *triggerBaInfo =
16778 &wdiTriggerBaReq->wdiTriggerBAInfoType ;
16779 triggerBaInfo->usBACandidateCnt = baCandidateCount ;
16780 /* TEMP_FIX: Need to see if WDI need check for assoc session for
16781 * for each request */
16782 triggerBaInfo->ucSTAIdx = baCandidate[0].ucSTAIdx ;
16783 triggerBaInfo->ucBASessionID = 0;
16784 vos_mem_copy((wdiTriggerBaReq + 1), baCandidate, size) ;
16785 } while(0) ;
16786 wdiTriggerBaReq->wdiReqStatusCB = NULL ;
16787 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16788 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16789 pWdaParams->pWdaContext = pWDA;
16790 pWdaParams->wdaWdiApiMsgParam = wdiTriggerBaReq ;
16791 pWdaParams->wdaMsgParam = NULL;
16792 status = WDI_TriggerBAReq(wdiTriggerBaReq,
16793 WDA_TriggerBaReqCallback, pWdaParams) ;
16794 if(IS_WDI_STATUS_FAILURE(status))
16795 {
16796 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16797 "Failure in Trigger BA REQ Params WDI API, free all the memory " );
16798 vos_mem_free(pWdaParams->wdaMsgParam) ;
16799 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
16800 vos_mem_free(pWdaParams) ;
16801 }
16802 }
16803 else
16804 {
16805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO_LOW,
16806 "There is no TID for initiating BA");
16807 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16808 if( VOS_STATUS_SUCCESS !=
16809 WDA_STOP_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
16810 {
16811 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16812 "BA Activity Timer Stop Failed ");
16813 return ;
16814 }
16815 if( VOS_STATUS_SUCCESS !=
16816 WDA_START_TIMER(&pWDA->wdaTimers.baActivityChkTmr))
16817 {
16818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
16819 "BA Activity Timer Start Failed ");
16820 return;
16821 }
16822 return ;
16823}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16824/*
16825 * WDA common routine to create timer used by WDA.
16826 */
16827static VOS_STATUS wdaCreateTimers(tWDA_CbContext *pWDA)
16828{
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16829 VOS_STATUS status = VOS_STATUS_SUCCESS ;
16830 tANI_U32 val = 0 ;
16831 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
16832
16833 if(NULL == pMac)
16834 {
16835 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]16836 "%s:MAC context is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16837 VOS_ASSERT(0);
16838 return VOS_STATUS_E_FAILURE;
16839 }
16840 if(wlan_cfgGetInt(pMac, WNI_CFG_BA_ACTIVITY_CHECK_TIMEOUT, &val )
16841 != eSIR_SUCCESS)
16842 {
16843 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16844 "Failed to get value for WNI_CFG_CURRENT_TX_ANTENNA");
16845 return VOS_STATUS_E_FAILURE;
16846 }
16847 val = SYS_MS_TO_TICKS(val) ;
16848
16849 /* BA activity check timer */
16850 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.baActivityChkTmr,
16851 "BA Activity Check timer", WDA_TimerHandler,
16852 WDA_TIMER_BA_ACTIVITY_REQ, val, val, TX_NO_ACTIVATE) ;
16853 if(status != TX_SUCCESS)
16854 {
16855 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16856 "Unable to create BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16857 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16858 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16859 val = SYS_MS_TO_TICKS( WDA_TX_COMPLETE_TIME_OUT_VALUE ) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16860 /* Tx Complete Timeout timer */
16861 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.TxCompleteTimer,
16862 "Tx Complete Check timer", WDA_TimerHandler,
16863 WDA_TX_COMPLETE_TIMEOUT_IND, val, val, TX_NO_ACTIVATE) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16864 if(status != TX_SUCCESS)
16865 {
16866 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16867 "Unable to create Tx Complete Timeout timer");
16868 /* Destroy timer of BA activity check timer */
16869 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
16870 if(status != TX_SUCCESS)
16871 {
16872 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16873 "Unable to Destroy BA activity timer");
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16874 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16875 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16876 return VOS_STATUS_E_FAILURE ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16877 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16878
16879 val = SYS_MS_TO_TICKS( WDA_TRAFFIC_STATS_TIME_OUT_VALUE );
16880
16881 /* Traffic Stats timer */
16882 status = WDA_CREATE_TIMER(&pWDA->wdaTimers.trafficStatsTimer,
16883 "Traffic Stats timer", WDA_TimerHandler,
16884 WDA_TIMER_TRAFFIC_STATS_IND, val, val, TX_NO_ACTIVATE) ;
16885 if(status != TX_SUCCESS)
16886 {
16887 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16888 "Unable to create traffic stats timer");
16889 /* Destroy timer of BA activity check timer */
16890 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
16891 if(status != TX_SUCCESS)
16892 {
16893 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16894 "Unable to Destroy BA activity timer");
16895 }
16896 /* Destroy timer of tx complete timer */
16897 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
16898 if(status != TX_SUCCESS)
16899 {
16900 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16901 "Unable to Tx complete timer");
16902 }
16903 return VOS_STATUS_E_FAILURE ;
16904 }
Madan Mohan Koyyalamudid57ae632012-11-06 18:42:48 -0800[diff] [blame]16905 return VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16906}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16907/*
16908 * WDA common routine to destroy timer used by WDA.
16909 */
16910static VOS_STATUS wdaDestroyTimers(tWDA_CbContext *pWDA)
16911{
16912 VOS_STATUS status = VOS_STATUS_SUCCESS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16913 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.TxCompleteTimer);
16914 if(status != TX_SUCCESS)
16915 {
16916 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16917 "Unable to Destroy Tx Complete Timeout timer");
16918 return eSIR_FAILURE ;
16919 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16920 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.baActivityChkTmr);
16921 if(status != TX_SUCCESS)
16922 {
16923 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16924 "Unable to Destroy BA activity timer");
16925 return eSIR_FAILURE ;
16926 }
Madan Mohan Koyyalamudi01cba042013-01-10 21:56:05 -0800[diff] [blame]16927 status = WDA_DESTROY_TIMER(&pWDA->wdaTimers.trafficStatsTimer);
16928 if(status != TX_SUCCESS)
16929 {
16930 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
16931 "Unable to Destroy traffic stats timer");
16932 return eSIR_FAILURE ;
16933 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16934 return eSIR_SUCCESS ;
16935}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16936/*
16937 * WDA timer handler.
16938 */
16939void WDA_TimerHandler(v_VOID_t* pContext, tANI_U32 timerInfo)
16940{
16941 VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
16942 vos_msg_t wdaMsg = {0} ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16943 /*
16944 * trigger CFG download in WDA by sending WDA_CFG_DNLD message
16945 */
16946 wdaMsg.type = timerInfo ;
16947 wdaMsg.bodyptr = NULL;
16948 wdaMsg.bodyval = 0;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16949 /* post the message.. */
16950 vosStatus = vos_mq_post_message( VOS_MQ_ID_WDA, &wdaMsg );
16951 if ( !VOS_IS_STATUS_SUCCESS(vosStatus) )
16952 {
16953 vosStatus = VOS_STATUS_E_BADMSG;
16954 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16955}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16956/*
16957 * WDA Tx Complete timeout Indication.
16958 */
16959void WDA_ProcessTxCompleteTimeOutInd(tWDA_CbContext* pWDA)
16960{
16961 tpAniSirGlobal pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext) ;
Ganesh Kondabattini29d844f2015-06-15 17:17:16 +0530[diff] [blame]16962 tpSirTxBdStatus txBdStatus = {0};
16963
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16964 if( pWDA->pAckTxCbFunc )
16965 {
16966 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16967 "TxComplete timer expired");
Ganesh Kondabattini29d844f2015-06-15 17:17:16 +0530[diff] [blame]16968 /*Indicate failure*/
16969 pWDA->pAckTxCbFunc( pMac, &txBdStatus);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16970 pWDA->pAckTxCbFunc = NULL;
16971 }
16972 else
16973 {
16974 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]16975 "There is no request pending for TxComplete and wait timer expired");
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16976 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16977}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16978/*
16979 * WDA Set REG Domain to VOS NV
16980 */
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]16981eHalStatus WDA_SetRegDomain(void * clientCtxt, v_REGDOMAIN_t regId,
16982 tAniBool sendRegHint)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16983{
Abhishek Singha306a442013-11-07 18:39:01 +0530[diff] [blame]16984 if(VOS_STATUS_SUCCESS != vos_nv_setRegDomain(clientCtxt, regId, sendRegHint))
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16985 {
16986 return eHAL_STATUS_INVALID_PARAMETER;
16987 }
16988 return eHAL_STATUS_SUCCESS;
16989}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16990
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16991#ifdef FEATURE_WLAN_SCAN_PNO
16992/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16993 * FUNCTION: WDA_PNOScanRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16994 *
16995 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]16996void WDA_PNOScanRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]16997{
16998 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]16999 tSirPNOScanReq *pPNOScanReqParams;
17000
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17001 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]17002 "<------ %s, wdiStatus: %d",__func__, status);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17003 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17004 {
17005 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17006 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17007 VOS_ASSERT(0) ;
17008 return ;
17009 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17010
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]17011 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
17012 if(pPNOScanReqParams->statusCallback)
17013 {
17014 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
17015 (status == WDI_STATUS_SUCCESS) ?
17016 VOS_STATUS_SUCCESS : VOS_STATUS_E_FAILURE);
17017 }
17018
Hanumantha Reddy Pothulad769f3e2015-02-19 17:00:02 +0530[diff] [blame]17019 if (pPNOScanReqParams->enable == 1)
17020 {
17021 if (pPNOScanReqParams->aNetworks)
17022 vos_mem_free(pPNOScanReqParams->aNetworks);
17023 if (pPNOScanReqParams->p24GProbeTemplate)
17024 vos_mem_free(pPNOScanReqParams->p24GProbeTemplate);
17025 if (pPNOScanReqParams->p5GProbeTemplate)
17026 vos_mem_free(pPNOScanReqParams->p5GProbeTemplate);
17027 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17028 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17029 vos_mem_free(pWdaParams->wdaMsgParam);
17030 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17031
17032 return ;
17033}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17034/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17035 * FUNCTION: WDA_PNOScanReqCallback
17036 * Free memory.
17037 * Invoked when PNOScan REQ failed in WDI and no RSP callback is generated.
17038 */
17039void WDA_PNOScanReqCallback(WDI_Status wdiStatus, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17040{
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17041 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]17042 tSirPNOScanReq *pPNOScanReqParams;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17043
17044 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17045 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17046
17047 if(NULL == pWdaParams)
17048 {
17049 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17050 "%s: pWdaParams received NULL", __func__);
17051 VOS_ASSERT(0);
17052 return;
17053 }
17054
17055 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17056 {
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]17057 pPNOScanReqParams = (tSirPNOScanReq *)pWdaParams->wdaMsgParam;
17058 if(pPNOScanReqParams->statusCallback)
17059 {
17060 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
17061 VOS_STATUS_E_FAILURE);
17062 }
17063
Hanumantha Reddy Pothula06e87b22015-03-02 18:02:23 +0530[diff] [blame]17064 if (pPNOScanReqParams->enable == 1)
17065 {
17066 if (pPNOScanReqParams->aNetworks)
17067 vos_mem_free(pPNOScanReqParams->aNetworks);
17068 if (pPNOScanReqParams->p24GProbeTemplate)
17069 vos_mem_free(pPNOScanReqParams->p24GProbeTemplate);
17070 if (pPNOScanReqParams->p5GProbeTemplate)
17071 vos_mem_free(pPNOScanReqParams->p5GProbeTemplate);
17072 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17073 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17074 vos_mem_free(pWdaParams->wdaMsgParam);
17075 vos_mem_free(pWdaParams);
17076 }
17077
17078 return;
17079}
17080/*
17081 * FUNCTION: WDA_UpdateScanParamsRespCallback
17082 *
17083 */
17084void WDA_UpdateScanParamsRespCallback(WDI_Status status, void* pUserData)
17085{
17086 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17087 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17088 "<------ %s " ,__func__);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17089 if(NULL == pWdaParams)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17090 {
17091 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17092 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17093 VOS_ASSERT(0) ;
17094 return ;
17095 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17096
17097 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17098 vos_mem_free(pWdaParams->wdaMsgParam);
17099 vos_mem_free(pWdaParams);
17100
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17101 return ;
17102}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17103/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17104 * FUNCTION: WDA_UpdateScanParamsReqCallback
17105 * Free memory.
17106 * Invoked when UpdateScanParams REQ failed in WDI and no RSP callback is generated.
17107 */
17108void WDA_UpdateScanParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
17109{
17110 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17111
17112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17113 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17114
17115 if(NULL == pWdaParams)
17116 {
17117 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17118 "%s: pWdaParams received NULL", __func__);
17119 VOS_ASSERT(0);
17120 return;
17121 }
17122
17123 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17124 {
17125 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17126 vos_mem_free(pWdaParams->wdaMsgParam);
17127 vos_mem_free(pWdaParams);
17128 }
17129
17130 return;
17131}
17132/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17133 * FUNCTION: WDA_ProcessSetPreferredNetworkList
17134 * Request to WDI to set Preferred Network List.Offload
17135 */
17136VOS_STATUS WDA_ProcessSetPrefNetworkReq(tWDA_CbContext *pWDA,
17137 tSirPNOScanReq *pPNOScanReqParams)
17138{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17139 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17140 WDI_PNOScanReqParamsType *pwdiPNOScanReqInfo =
17141 (WDI_PNOScanReqParamsType *)vos_mem_malloc(sizeof(WDI_PNOScanReqParamsType)) ;
17142 tWDA_ReqParams *pWdaParams ;
17143 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17144 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17145 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17146 if(NULL == pwdiPNOScanReqInfo)
17147 {
17148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17149 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17150 VOS_ASSERT(0);
17151 return VOS_STATUS_E_NOMEM;
17152 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17153 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17154 if(NULL == pWdaParams)
17155 {
17156 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17157 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17158 VOS_ASSERT(0);
17159 vos_mem_free(pwdiPNOScanReqInfo);
17160 return VOS_STATUS_E_NOMEM;
17161 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17162 //
17163 // Fill wdiPNOScanReqInfo->wdiPNOScanInfo from pPNOScanReqParams
17164 //
17165 pwdiPNOScanReqInfo->wdiPNOScanInfo.bEnable = pPNOScanReqParams->enable;
17166 pwdiPNOScanReqInfo->wdiPNOScanInfo.wdiModePNO = pPNOScanReqParams->modePNO;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17167 pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount =
17168 ( pPNOScanReqParams->ucNetworksCount < WDI_PNO_MAX_SUPP_NETWORKS )?
17169 pPNOScanReqParams->ucNetworksCount : WDI_PNO_MAX_SUPP_NETWORKS ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17170 for ( i = 0; i < pwdiPNOScanReqInfo->wdiPNOScanInfo.ucNetworksCount ; i++)
17171 {
17172 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i],
17173 &pPNOScanReqParams->aNetworks[i],
17174 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.aNetworks[i]));
17175 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17176 /*Scan timer intervals*/
17177 vos_mem_copy(&pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers,
17178 &pPNOScanReqParams->scanTimers,
17179 sizeof(pwdiPNOScanReqInfo->wdiPNOScanInfo.scanTimers));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17180 /*Probe template for 2.4GHz band*/
17181 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize =
17182 (pPNOScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
17183 pPNOScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17184 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a24GProbeTemplate,
17185 pPNOScanReqParams->p24GProbeTemplate,
17186 pwdiPNOScanReqInfo->wdiPNOScanInfo.us24GProbeSize);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17187 /*Probe template for 5GHz band*/
17188 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize =
17189 (pPNOScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
17190 pPNOScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17191 vos_mem_copy( &pwdiPNOScanReqInfo->wdiPNOScanInfo.a5GProbeTemplate,
17192 pPNOScanReqParams->p5GProbeTemplate,
17193 pwdiPNOScanReqInfo->wdiPNOScanInfo.us5GProbeSize);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17194 pwdiPNOScanReqInfo->wdiReqStatusCB = WDA_PNOScanReqCallback;
17195 pwdiPNOScanReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17196
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17197 /* Store Params pass it to WDI */
17198 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiPNOScanReqInfo;
17199 pWdaParams->pWdaContext = pWDA;
17200 /* Store param pointer as passed in by caller */
17201 pWdaParams->wdaMsgParam = pPNOScanReqParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17202 status = WDI_SetPreferredNetworkReq(pwdiPNOScanReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17203 (WDI_PNOScanCb)WDA_PNOScanRespCallback, pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17204 if(IS_WDI_STATUS_FAILURE(status))
17205 {
17206 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17207 "Failure in Set PNO REQ WDI API, free all the memory " );
Vinay Krishna Erannaf0e523b2014-03-01 21:00:16 +0530[diff] [blame]17208 if(pPNOScanReqParams->statusCallback)
17209 {
17210 pPNOScanReqParams->statusCallback(pPNOScanReqParams->callbackContext,
17211 VOS_STATUS_E_FAILURE);
17212 }
Hanumantha Reddy Pothulad769f3e2015-02-19 17:00:02 +0530[diff] [blame]17213 if (pPNOScanReqParams->enable == 1)
17214 {
17215 if (pPNOScanReqParams->aNetworks)
17216 vos_mem_free(pPNOScanReqParams->aNetworks);
17217 if (pPNOScanReqParams->p24GProbeTemplate)
17218 vos_mem_free(pPNOScanReqParams->p24GProbeTemplate);
17219 if (pPNOScanReqParams->p5GProbeTemplate)
17220 vos_mem_free(pPNOScanReqParams->p5GProbeTemplate);
17221 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17222 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17223 vos_mem_free(pWdaParams->wdaMsgParam);
Hanumantha Reddy Pothulad769f3e2015-02-19 17:00:02 +0530[diff] [blame]17224
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17225 pWdaParams->wdaWdiApiMsgParam = NULL;
17226 pWdaParams->wdaMsgParam = NULL;
17227 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17228 return CONVERT_WDI2VOS_STATUS(status) ;
17229}
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17230
17231#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
17232
17233void WDA_ConvertSirAuthToWDIAuth(WDI_AuthType *AuthType, v_U8_t csrAuthType)
17234{
17235 /*Convert the CSR Auth types to WDI Auth types */
17236 switch (csrAuthType)
17237 {
17238 case eCSR_AUTH_TYPE_OPEN_SYSTEM:
17239 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
17240 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]17241#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17242 case eCSR_AUTH_TYPE_CCKM_WPA:
17243 *AuthType = eWDA_AUTH_TYPE_CCKM_WPA;
17244 break;
17245#endif
17246 case eCSR_AUTH_TYPE_WPA:
17247 *AuthType = eWDA_AUTH_TYPE_WPA;
17248 break;
17249 case eCSR_AUTH_TYPE_WPA_PSK:
17250 *AuthType = eWDA_AUTH_TYPE_WPA_PSK;
17251 break;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]17252#ifdef FEATURE_WLAN_ESE
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17253 case eCSR_AUTH_TYPE_CCKM_RSN:
17254 *AuthType = eWDA_AUTH_TYPE_CCKM_RSN;
17255 break;
17256#endif
17257 case eCSR_AUTH_TYPE_RSN:
17258 *AuthType = eWDA_AUTH_TYPE_RSN;
17259 break;
17260 case eCSR_AUTH_TYPE_RSN_PSK:
17261 *AuthType = eWDA_AUTH_TYPE_RSN_PSK;
17262 break;
17263#if defined WLAN_FEATURE_VOWIFI_11R
17264 case eCSR_AUTH_TYPE_FT_RSN:
17265 *AuthType = eWDA_AUTH_TYPE_FT_RSN;
17266 break;
17267 case eCSR_AUTH_TYPE_FT_RSN_PSK:
17268 *AuthType = eWDA_AUTH_TYPE_FT_RSN_PSK;
17269 break;
17270#endif
17271#ifdef FEATURE_WLAN_WAPI
17272 case eCSR_AUTH_TYPE_WAPI_WAI_CERTIFICATE:
17273 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_CERTIFICATE;
17274 break;
17275 case eCSR_AUTH_TYPE_WAPI_WAI_PSK:
17276 *AuthType = eWDA_AUTH_TYPE_WAPI_WAI_PSK;
17277 break;
17278#endif /* FEATURE_WLAN_WAPI */
17279 case eCSR_AUTH_TYPE_SHARED_KEY:
17280 case eCSR_AUTH_TYPE_AUTOSWITCH:
17281 *AuthType = eWDA_AUTH_TYPE_OPEN_SYSTEM;
17282 break;
Kanchanapally, Vidyullatha3355dd32015-06-09 14:56:56 +0530[diff] [blame]17283#ifdef WLAN_FEATURE_11W
17284 case eCSR_AUTH_TYPE_RSN_PSK_SHA256:
17285 *AuthType = eWDA_AUTH_TYPE_RSN_PSK_SHA256;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17286 break;
Kanchanapally, Vidyullatha3355dd32015-06-09 14:56:56 +0530[diff] [blame]17287 case eCSR_AUTH_TYPE_RSN_8021X_SHA256:
17288 *AuthType = eWDA_AUTH_TYPE_RSN_8021X_SHA256;
17289 break;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17290#endif
17291 default:
Deepthi Gowribfd17132014-11-14 17:59:04 +0530[diff] [blame]17292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17293 "%s: Unknown Auth Type", __func__);
17294 break;
17295 }
17296}
17297void WDA_ConvertSirEncToWDIEnc(WDI_EdType *EncrType, v_U8_t csrEncrType)
17298{
17299 switch (csrEncrType)
17300 {
17301 case eCSR_ENCRYPT_TYPE_NONE:
17302 *EncrType = WDI_ED_NONE;
17303 break;
17304 case eCSR_ENCRYPT_TYPE_WEP40_STATICKEY:
17305 case eCSR_ENCRYPT_TYPE_WEP40:
17306 *EncrType = WDI_ED_WEP40;
17307 break;
17308 case eCSR_ENCRYPT_TYPE_WEP104:
17309 case eCSR_ENCRYPT_TYPE_WEP104_STATICKEY:
17310 *EncrType = WDI_ED_WEP104;
17311 break;
17312 case eCSR_ENCRYPT_TYPE_TKIP:
17313 *EncrType = WDI_ED_TKIP;
17314 break;
17315 case eCSR_ENCRYPT_TYPE_AES:
17316 *EncrType = WDI_ED_CCMP;
17317 break;
17318#ifdef WLAN_FEATURE_11W
17319 case eCSR_ENCRYPT_TYPE_AES_CMAC:
17320 *EncrType = WDI_ED_AES_128_CMAC;
17321 break;
17322#endif
17323#ifdef FEATURE_WLAN_WAPI
17324 case eCSR_ENCRYPT_TYPE_WPI:
17325 *EncrType = WDI_ED_WPI;
17326 break;
17327#endif
17328 case eCSR_ENCRYPT_TYPE_ANY:
17329 *EncrType = WDI_ED_ANY;
17330 break;
17331
17332 default:
17333 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17334 "%s: Unknown Encryption Type", __func__);
17335 break;
17336 }
17337}
17338
17339/*
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17340 * FUNCTION: WDA_ProcessRoamScanOffloadReq
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17341 * Request to WDI to set Roam Offload Scan
17342 */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17343VOS_STATUS WDA_ProcessRoamScanOffloadReq(tWDA_CbContext *pWDA,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17344 tSirRoamOffloadScanReq *pRoamOffloadScanReqParams)
17345{
17346 WDI_Status status;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17347 WDI_RoamScanOffloadReqParamsType *pwdiRoamScanOffloadReqParams =
17348 (WDI_RoamScanOffloadReqParamsType *)vos_mem_malloc(sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17349 tWDA_ReqParams *pWdaParams ;
17350 v_U8_t csrAuthType;
17351 WDI_RoamNetworkType *pwdiRoamNetworkType;
17352 WDI_RoamOffloadScanInfo *pwdiRoamOffloadScanInfo;
17353 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17354 "------> %s " ,__func__);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17355 if (NULL == pwdiRoamScanOffloadReqParams)
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17356 {
17357 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17358 "%s: VOS MEM Alloc Failure", __func__);
17359 VOS_ASSERT(0);
17360 return VOS_STATUS_E_NOMEM;
17361 }
17362 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17363 if (NULL == pWdaParams)
17364 {
17365 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17366 "%s: VOS MEM Alloc Failure", __func__);
17367 VOS_ASSERT(0);
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17368 vos_mem_free(pwdiRoamScanOffloadReqParams);
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17369 return VOS_STATUS_E_NOMEM;
17370 }
17371
17372 pwdiRoamNetworkType =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17373 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo.ConnectedNetwork;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17374 pwdiRoamOffloadScanInfo =
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17375 &pwdiRoamScanOffloadReqParams->wdiRoamOffloadScanInfo;
17376 vos_mem_zero (pwdiRoamScanOffloadReqParams,sizeof(WDI_RoamScanOffloadReqParamsType));
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17377 csrAuthType = pRoamOffloadScanReqParams->ConnectedNetwork.authentication;
17378 pwdiRoamOffloadScanInfo->RoamScanOffloadEnabled =
17379 pRoamOffloadScanReqParams->RoamScanOffloadEnabled;
17380 vos_mem_copy(pwdiRoamNetworkType->currAPbssid,
17381 pRoamOffloadScanReqParams->ConnectedNetwork.currAPbssid,
17382 sizeof(pwdiRoamNetworkType->currAPbssid));
17383 WDA_ConvertSirAuthToWDIAuth(&pwdiRoamNetworkType->authentication,
17384 csrAuthType);
17385 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->encryption,
17386 pRoamOffloadScanReqParams->ConnectedNetwork.encryption);
17387 WDA_ConvertSirEncToWDIEnc(&pwdiRoamNetworkType->mcencryption,
17388 pRoamOffloadScanReqParams->ConnectedNetwork.mcencryption);
17389 pwdiRoamOffloadScanInfo->LookupThreshold =
17390 pRoamOffloadScanReqParams->LookupThreshold ;
Varun Reddy Yeturu6c5e25c2014-01-09 21:55:37 -0800[diff] [blame]17391 pwdiRoamOffloadScanInfo->RxSensitivityThreshold =
17392 pRoamOffloadScanReqParams->RxSensitivityThreshold;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17393 pwdiRoamOffloadScanInfo->RoamRssiDiff =
17394 pRoamOffloadScanReqParams->RoamRssiDiff ;
Sameer Thalappil4ae66ec2013-11-05 14:17:35 -0800[diff] [blame]17395 pwdiRoamOffloadScanInfo->MAWCEnabled =
17396 pRoamOffloadScanReqParams->MAWCEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17397 pwdiRoamOffloadScanInfo->Command =
17398 pRoamOffloadScanReqParams->Command ;
17399 pwdiRoamOffloadScanInfo->StartScanReason =
17400 pRoamOffloadScanReqParams->StartScanReason ;
17401 pwdiRoamOffloadScanInfo->NeighborScanTimerPeriod =
17402 pRoamOffloadScanReqParams->NeighborScanTimerPeriod ;
17403 pwdiRoamOffloadScanInfo->NeighborRoamScanRefreshPeriod =
17404 pRoamOffloadScanReqParams->NeighborRoamScanRefreshPeriod ;
17405 pwdiRoamOffloadScanInfo->NeighborScanChannelMinTime =
17406 pRoamOffloadScanReqParams->NeighborScanChannelMinTime ;
17407 pwdiRoamOffloadScanInfo->NeighborScanChannelMaxTime =
17408 pRoamOffloadScanReqParams->NeighborScanChannelMaxTime ;
17409 pwdiRoamOffloadScanInfo->EmptyRefreshScanPeriod =
17410 pRoamOffloadScanReqParams->EmptyRefreshScanPeriod ;
Varun Reddy Yeturu5d5e2c62014-02-27 13:31:29 -0800[diff] [blame]17411 pwdiRoamOffloadScanInfo->IsESEEnabled =
17412 pRoamOffloadScanReqParams->IsESEEnabled ;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17413 vos_mem_copy(&pwdiRoamNetworkType->ssId.sSSID,
17414 &pRoamOffloadScanReqParams->ConnectedNetwork.ssId.ssId,
17415 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length);
17416 pwdiRoamNetworkType->ssId.ucLength =
17417 pRoamOffloadScanReqParams->ConnectedNetwork.ssId.length;
17418 vos_mem_copy(pwdiRoamNetworkType->ChannelCache,
17419 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCache,
17420 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount);
17421 pwdiRoamNetworkType->ChannelCount =
17422 pRoamOffloadScanReqParams->ConnectedNetwork.ChannelCount;
17423 pwdiRoamOffloadScanInfo->ChannelCacheType =
17424 pRoamOffloadScanReqParams->ChannelCacheType;
17425 vos_mem_copy(pwdiRoamOffloadScanInfo->ValidChannelList,
17426 pRoamOffloadScanReqParams->ValidChannelList,
17427 pRoamOffloadScanReqParams->ValidChannelCount);
17428 pwdiRoamOffloadScanInfo->ValidChannelCount =
17429 pRoamOffloadScanReqParams->ValidChannelCount;
17430 pwdiRoamOffloadScanInfo->us24GProbeSize =
17431 (pRoamOffloadScanReqParams->us24GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
17432 pRoamOffloadScanReqParams->us24GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
17433 vos_mem_copy(&pwdiRoamOffloadScanInfo->a24GProbeTemplate,
17434 pRoamOffloadScanReqParams->p24GProbeTemplate,
17435 pwdiRoamOffloadScanInfo->us24GProbeSize);
17436 pwdiRoamOffloadScanInfo->us5GProbeSize =
17437 (pRoamOffloadScanReqParams->us5GProbeTemplateLen<WDI_PNO_MAX_PROBE_SIZE)?
17438 pRoamOffloadScanReqParams->us5GProbeTemplateLen:WDI_PNO_MAX_PROBE_SIZE;
17439 vos_mem_copy(&pwdiRoamOffloadScanInfo->a5GProbeTemplate,
17440 pRoamOffloadScanReqParams->p5GProbeTemplate,
17441 pwdiRoamOffloadScanInfo->us5GProbeSize);
17442 pwdiRoamOffloadScanInfo->MDID.mdiePresent =
17443 pRoamOffloadScanReqParams->MDID.mdiePresent;
17444 pwdiRoamOffloadScanInfo->MDID.mobilityDomain =
17445 pRoamOffloadScanReqParams->MDID.mobilityDomain;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17446 pwdiRoamOffloadScanInfo->nProbes =
17447 pRoamOffloadScanReqParams->nProbes;
17448 pwdiRoamOffloadScanInfo->HomeAwayTime =
17449 pRoamOffloadScanReqParams->HomeAwayTime;
17450 pwdiRoamScanOffloadReqParams->wdiReqStatusCB = NULL;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17451 /* Store Params pass it to WDI */
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17452 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRoamScanOffloadReqParams;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17453 pWdaParams->pWdaContext = pWDA;
17454 /* Store param pointer as passed in by caller */
17455 pWdaParams->wdaMsgParam = pRoamOffloadScanReqParams;
Varun Reddy Yeturu920df212013-05-22 08:07:23 -0700[diff] [blame]17456 status = WDI_RoamScanOffloadReq(pwdiRoamScanOffloadReqParams,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17457 (WDI_RoamOffloadScanCb)WDA_RoamOffloadScanReqCallback, pWdaParams);
17458 if(IS_WDI_STATUS_FAILURE(status))
17459 {
17460 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17461 "Failure in Start Roam Candidate Lookup Req WDI API, free all the memory " );
17462 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17463 vos_mem_free(pWdaParams->wdaMsgParam);
17464 pWdaParams->wdaWdiApiMsgParam = NULL;
17465 pWdaParams->wdaMsgParam = NULL;
17466 }
17467 return CONVERT_WDI2VOS_STATUS(status) ;
17468}
17469#endif
17470
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17471/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17472 * FUNCTION: WDA_RssiFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17473 *
17474 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17475void WDA_RssiFilterRespCallback(WDI_Status status, void* pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17476{
17477 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17478
17479 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17480 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17481
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]17482 if(NULL == pWdaParams)
17483 {
17484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17485 "%s: pWdaParams received NULL", __func__);
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]17486 VOS_ASSERT(0);
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17487 return;
Gopichand Nakkalac7077db2013-03-29 01:34:58 +0530[diff] [blame]17488 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17489
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17490 vos_mem_free(pWdaParams->wdaMsgParam) ;
17491 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17492 vos_mem_free(pWdaParams) ;
17493
17494 return ;
17495}
17496/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17497 * FUNCTION: WDA_RssiFilterReqCallback
17498 * Free memory.
17499 * Invoked when RSSIFilter REQ failed in WDI and no RSP callback is generated.
17500 */
17501void WDA_RssiFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
17502{
17503 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17504
17505 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17506 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17507
17508 if(NULL == pWdaParams)
17509 {
17510 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17511 "%s: pWdaParams received NULL", __func__);
17512 VOS_ASSERT(0);
17513 return;
17514 }
17515
17516 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17517 {
17518 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17519 vos_mem_free(pWdaParams->wdaMsgParam);
17520 vos_mem_free(pWdaParams);
17521 }
17522
17523 return;
17524}
17525/*
Hanumantha Reddy Pothula1e687da2015-03-31 13:44:31 +0530[diff] [blame]17526 * FUNCTION: WDA_ProcessSetRssiFilterReq
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17527 * Request to WDI to set Preferred Network List.Offload
17528 */
17529VOS_STATUS WDA_ProcessSetRssiFilterReq(tWDA_CbContext *pWDA,
17530 tSirSetRSSIFilterReq* pRssiFilterParams)
17531{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17532 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17533 WDI_SetRssiFilterReqParamsType *pwdiSetRssiFilterReqInfo =
17534 (WDI_SetRssiFilterReqParamsType *)vos_mem_malloc(sizeof(WDI_SetRssiFilterReqParamsType)) ;
17535 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17536 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17537 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17538 if(NULL == pwdiSetRssiFilterReqInfo)
17539 {
17540 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17541 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17542 VOS_ASSERT(0);
17543 return VOS_STATUS_E_NOMEM;
17544 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17545 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17546 if(NULL == pWdaParams)
17547 {
17548 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17549 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17550 VOS_ASSERT(0);
17551 vos_mem_free(pwdiSetRssiFilterReqInfo);
17552 return VOS_STATUS_E_NOMEM;
17553 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17554 pwdiSetRssiFilterReqInfo->rssiThreshold = pRssiFilterParams->rssiThreshold;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17555 pwdiSetRssiFilterReqInfo->wdiReqStatusCB = WDA_RssiFilterReqCallback;
17556 pwdiSetRssiFilterReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17557
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17558 /* Store Params pass it to WDI */
17559 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRssiFilterReqInfo;
17560 pWdaParams->pWdaContext = pWDA;
17561 /* Store param pointer as passed in by caller */
17562 pWdaParams->wdaMsgParam = pRssiFilterParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17563 status = WDI_SetRssiFilterReq( pwdiSetRssiFilterReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17564 (WDI_PNOScanCb)WDA_RssiFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17565 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17566 if(IS_WDI_STATUS_FAILURE(status))
17567 {
17568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17569 "Failure in Set RSSI Filter REQ WDI API, free all the memory " );
17570 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17571 vos_mem_free(pWdaParams->wdaMsgParam);
17572 pWdaParams->wdaWdiApiMsgParam = NULL;
17573 pWdaParams->wdaMsgParam = NULL;
17574 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17575 return CONVERT_WDI2VOS_STATUS(status) ;
17576}
17577
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17578/*
17579 * FUNCTION: WDA_ProcessUpdateScanParams
17580 * Request to WDI to update Scan Parameters
17581 */
17582VOS_STATUS WDA_ProcessUpdateScanParams(tWDA_CbContext *pWDA,
17583 tSirUpdateScanParams *pUpdateScanParams)
17584{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17585 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17586 WDI_UpdateScanParamsInfoType *wdiUpdateScanParamsInfoType =
17587 (WDI_UpdateScanParamsInfoType *)vos_mem_malloc(
17588 sizeof(WDI_UpdateScanParamsInfoType)) ;
17589 tWDA_ReqParams *pWdaParams ;
17590 v_U8_t i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17591 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17592 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17593 if(NULL == wdiUpdateScanParamsInfoType)
17594 {
17595 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17596 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17597 VOS_ASSERT(0);
17598 return VOS_STATUS_E_NOMEM;
17599 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17600 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17601 if ( NULL == pWdaParams )
17602 {
17603 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17604 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17605 VOS_ASSERT(0);
17606 vos_mem_free(wdiUpdateScanParamsInfoType);
17607 return VOS_STATUS_E_NOMEM;
17608 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17609 //
17610 // Fill wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo from pUpdateScanParams
17611 //
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17612 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17613 "Update Scan Parameters b11dEnabled %d b11dResolved %d "
17614 "ucChannelCount %d usPassiveMinChTime %d usPassiveMaxChTime"
17615 " %d usActiveMinChTime %d usActiveMaxChTime %d sizeof "
Jeff Johnson9a9ed0d2013-11-26 13:36:52 -0800[diff] [blame]17616 "sir struct %zu wdi struct %zu",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17617 pUpdateScanParams->b11dEnabled,
17618 pUpdateScanParams->b11dResolved,
17619 pUpdateScanParams->ucChannelCount,
17620 pUpdateScanParams->usPassiveMinChTime,
17621 pUpdateScanParams->usPassiveMaxChTime,
17622 pUpdateScanParams->usActiveMinChTime,
17623 pUpdateScanParams->usActiveMaxChTime,
17624 sizeof(tSirUpdateScanParams),
17625 sizeof(wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo) );
17626
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17627 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dEnabled =
17628 pUpdateScanParams->b11dEnabled;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17629 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.b11dResolved =
17630 pUpdateScanParams->b11dResolved;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17631 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.cbState =
17632 pUpdateScanParams->ucCBState;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17633 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMaxChTime =
17634 pUpdateScanParams->usActiveMaxChTime;
17635 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usActiveMinChTime =
17636 pUpdateScanParams->usActiveMinChTime;
17637 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMaxChTime =
17638 pUpdateScanParams->usPassiveMaxChTime;
17639 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.usPassiveMinChTime =
17640 pUpdateScanParams->usPassiveMinChTime;
17641
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17642 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount =
Pratik Bhalgatd4404592012-11-22 17:49:14 +0530[diff] [blame]17643 (pUpdateScanParams->ucChannelCount < WDI_PNO_MAX_NETW_CHANNELS_EX)?
17644 pUpdateScanParams->ucChannelCount:WDI_PNO_MAX_NETW_CHANNELS_EX;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17645
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17646 for ( i = 0; i <
17647 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.ucChannelCount ;
17648 i++)
17649 {
17650 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17651 "Update Scan Parameters channel: %d",
17652 pUpdateScanParams->aChannels[i]);
17653
17654 wdiUpdateScanParamsInfoType->wdiUpdateScanParamsInfo.aChannels[i] =
17655 pUpdateScanParams->aChannels[i];
17656 }
17657
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17658 wdiUpdateScanParamsInfoType->wdiReqStatusCB = WDA_UpdateScanParamsReqCallback;
17659 wdiUpdateScanParamsInfoType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17660
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17661 /* Store Params pass it to WDI */
17662 pWdaParams->wdaWdiApiMsgParam = wdiUpdateScanParamsInfoType;
17663 pWdaParams->pWdaContext = pWDA;
17664 /* Store param pointer as passed in by caller */
17665 pWdaParams->wdaMsgParam = pUpdateScanParams;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17666
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17667
17668
17669 status = WDI_UpdateScanParamsReq(wdiUpdateScanParamsInfoType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17670 (WDI_UpdateScanParamsCb)WDA_UpdateScanParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17671 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17672 if(IS_WDI_STATUS_FAILURE(status))
17673 {
17674 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17675 "Failure in Update Scan Params EQ WDI API, free all the memory " );
17676 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17677 vos_mem_free(pWdaParams->wdaMsgParam);
17678 vos_mem_free(pWdaParams);
17679 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17680 return CONVERT_WDI2VOS_STATUS(status) ;
17681}
17682#endif // FEATURE_WLAN_SCAN_PNO
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17683
17684#ifdef WLAN_FEATURE_ROAM_SCAN_OFFLOAD
17685/*
17686 * FUNCTION: WDA_RoamOffloadScanReqCallback
17687 *
17688 */
17689void WDA_RoamOffloadScanReqCallback(WDI_Status status, void* pUserData)
17690{
17691 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]17692 vos_msg_t vosMsg;
17693 wpt_uint8 reason = 0;
17694
Srinivas Girigowda6cf0b822013-06-27 14:00:20 -0700[diff] [blame]17695 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17696 "<------ %s " ,__func__);
17697 if (NULL == pWdaParams)
17698 {
17699 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17700 "%s: pWdaParams received NULL", __func__);
17701 VOS_ASSERT(0) ;
17702 return ;
17703 }
17704 if ( pWdaParams != NULL )
17705 {
17706 if ( pWdaParams->wdaWdiApiMsgParam != NULL )
17707 {
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]17708 reason = ((WDI_RoamScanOffloadReqParamsType *)pWdaParams->wdaWdiApiMsgParam)->wdiRoamOffloadScanInfo.StartScanReason;
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17709 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17710 }
17711 if ( pWdaParams->wdaMsgParam != NULL)
17712 {
17713 vos_mem_free(pWdaParams->wdaMsgParam);
17714 }
17715
17716 vos_mem_free(pWdaParams) ;
17717 }
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]17718 vosMsg.type = eWNI_SME_ROAM_SCAN_OFFLOAD_RSP;
17719 vosMsg.bodyptr = NULL;
17720 if (WDI_STATUS_SUCCESS != status)
17721 {
17722 reason = 0;
17723 }
17724 vosMsg.bodyval = reason;
17725 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
17726 {
17727 /* free the mem and return */
17728 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Jeff Johnsone384c822013-10-30 12:21:17 -0700[diff] [blame]17729 "%s: Failed to post the rsp to UMAC", __func__);
Varun Reddy Yeturucc661d22013-05-20 11:47:10 -0700[diff] [blame]17730 }
17731
Varun Reddy Yeturud0a3f252013-04-15 21:58:13 -0700[diff] [blame]17732 return ;
17733}
17734#endif
17735
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17736/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17737 * FUNCTION: WDA_SetPowerParamsRespCallback
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17738 *
17739 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17740void WDA_SetPowerParamsRespCallback(WDI_Status status, void* pUserData)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17741{
17742 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17743
17744 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17745 "<------ %s " ,__func__);
17746
17747 if(NULL == pWdaParams)
17748 {
17749 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17750 "%s: pWdaParams received NULL", __func__);
17751 VOS_ASSERT(0);
17752 return;
17753 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17754
17755 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17756 vos_mem_free(pWdaParams->wdaMsgParam);
17757 vos_mem_free(pWdaParams);
17758
17759 return;
17760}
17761/*
17762 * FUNCTION: WDA_SetPowerParamsReqCallback
17763 * Free memory.
17764 * Invoked when SetPowerParams REQ failed in WDI and no RSP callback is generated.
17765 */
17766void WDA_SetPowerParamsReqCallback(WDI_Status wdiStatus, void* pUserData)
17767{
17768 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17769
17770 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17771 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17772
17773 if(NULL == pWdaParams)
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17774 {
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17776 "%s: pWdaParams received NULL", __func__);
17777 VOS_ASSERT(0);
17778 return;
17779 }
17780
17781 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17782 {
17783 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17784 vos_mem_free(pWdaParams->wdaMsgParam);
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17785 vos_mem_free(pWdaParams);
17786 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17787
Mahesh Kumar Kalikot Veetil2aad8d82013-02-07 12:31:28 -0800[diff] [blame]17788 return;
17789}
17790
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17791#ifdef WLAN_FEATURE_PACKET_FILTERING
17792/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17793 * FUNCTION: WDA_8023MulticastListRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17794 *
17795 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17796void WDA_8023MulticastListRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17797 WDI_RcvFltPktSetMcListRspParamsType *pwdiRcvFltPktSetMcListRspInfo,
17798 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17799{
17800 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17801 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17802 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17803 if(NULL == pWdaParams)
17804 {
17805 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17806 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17807 VOS_ASSERT(0) ;
17808 return ;
17809 }
17810
17811 vos_mem_free(pWdaParams->wdaMsgParam) ;
17812 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17813 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17814 //print a msg, nothing else to do
17815 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17816 "WDA_8023MulticastListRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17817 return ;
17818}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17819/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17820 * FUNCTION: WDA_8023MulticastListReqCallback
17821 * Free memory.
17822 * Invoked when 8023MulticastList REQ failed in WDI and no RSP callback is generated.
17823 */
17824void WDA_8023MulticastListReqCallback(WDI_Status wdiStatus, void* pUserData)
17825{
17826 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17827
17828 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17829 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
17830
17831 if(NULL == pWdaParams)
17832 {
17833 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17834 "%s: pWdaParams received NULL", __func__);
17835 VOS_ASSERT(0);
17836 return;
17837 }
17838
17839 if(IS_WDI_STATUS_FAILURE(wdiStatus))
17840 {
17841 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17842 vos_mem_free(pWdaParams->wdaMsgParam);
17843 vos_mem_free(pWdaParams);
17844 }
17845
17846 return;
17847}
17848/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17849 * FUNCTION: WDA_Process8023MulticastListReq
17850 * Request to WDI to add 8023 Multicast List
17851 */
17852VOS_STATUS WDA_Process8023MulticastListReq (tWDA_CbContext *pWDA,
17853 tSirRcvFltMcAddrList *pRcvFltMcAddrList)
17854{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17855 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17856 WDI_RcvFltPktSetMcListReqParamsType *pwdiFltPktSetMcListReqParamsType = NULL;
17857 tWDA_ReqParams *pWdaParams ;
17858 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17860 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17861 pwdiFltPktSetMcListReqParamsType =
17862 (WDI_RcvFltPktSetMcListReqParamsType *)vos_mem_malloc(
17863 sizeof(WDI_RcvFltPktSetMcListReqParamsType)
17864 ) ;
17865 if(NULL == pwdiFltPktSetMcListReqParamsType)
17866 {
17867 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17868 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17869 return VOS_STATUS_E_NOMEM;
17870 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17871 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
17872 if(NULL == pWdaParams)
17873 {
17874 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17875 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17876 vos_mem_free(pwdiFltPktSetMcListReqParamsType);
17877 return VOS_STATUS_E_NOMEM;
17878 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17879
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17880 //
17881 // Fill pwdiFltPktSetMcListReqParamsType from pRcvFltMcAddrList
17882 //
17883 pwdiFltPktSetMcListReqParamsType->mcAddrList.ulMulticastAddrCnt =
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]17884 pRcvFltMcAddrList->ulMulticastAddrCnt;
17885
17886 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.selfMacAddr,
17887 pRcvFltMcAddrList->selfMacAddr, sizeof(tSirMacAddr));
17888 vos_mem_copy(pwdiFltPktSetMcListReqParamsType->mcAddrList.bssId,
17889 pRcvFltMcAddrList->bssId, sizeof(tSirMacAddr));
17890
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17891 for( i = 0; i < pRcvFltMcAddrList->ulMulticastAddrCnt; i++ )
17892 {
17893 vos_mem_copy(&(pwdiFltPktSetMcListReqParamsType->mcAddrList.multicastAddr[i]),
17894 &(pRcvFltMcAddrList->multicastAddr[i]),
17895 sizeof(tSirMacAddr));
17896 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17897 pwdiFltPktSetMcListReqParamsType->wdiReqStatusCB = WDA_8023MulticastListReqCallback;
17898 pwdiFltPktSetMcListReqParamsType->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]17899
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17900 /* Store Params pass it to WDI */
17901 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiFltPktSetMcListReqParamsType;
17902 pWdaParams->pWdaContext = pWDA;
17903 /* Store param pointer as passed in by caller */
17904 pWdaParams->wdaMsgParam = pRcvFltMcAddrList;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17905 status = WDI_8023MulticastListReq(
17906 pwdiFltPktSetMcListReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17907 (WDI_8023MulticastListCb)WDA_8023MulticastListRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17908 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17909 if(IS_WDI_STATUS_FAILURE(status))
17910 {
17911 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17912 "Failure in WDA_Process8023MulticastListReq(), free all the memory " );
17913 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
17914 vos_mem_free(pWdaParams->wdaMsgParam);
17915 vos_mem_free(pWdaParams);
17916 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17917 return CONVERT_WDI2VOS_STATUS(status) ;
17918}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17919/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17920 * FUNCTION: WDA_ReceiveFilterSetFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17921 *
17922 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17923void WDA_ReceiveFilterSetFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]17924 WDI_SetRcvPktFilterRspParamsType *pwdiSetRcvPktFilterRspInfo,
17925 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17926{
17927 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17929 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17930 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17931 if(NULL == pWdaParams)
17932 {
17933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17934 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17935 VOS_ASSERT(0) ;
17936 return ;
17937 }
17938
17939 vos_mem_free(pWdaParams->wdaMsgParam) ;
17940 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17941 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17942 //print a msg, nothing else to do
17943 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17944 "WDA_ReceiveFilterSetFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17945 return ;
17946}
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17947
17948/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17949 * FUNCTION: WDA_ReceiveFilterSetFilterReqCallback
17950 * Free memory.
17951 * Invoked when ReceiveFilterSetFilter REQ failed in WDI and no RSP callback is generated.
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17952 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]17953void WDA_ReceiveFilterSetFilterReqCallback(WDI_Status wdiStatus,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]17954 void* pUserData)
17955{
17956 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
17957
17958 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
17959 "<------ %s, wdiStatus: %d",
17960 __func__, wdiStatus);
17961
17962 if (NULL == pWdaParams)
17963 {
17964 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
17965 "%s: Invalid pWdaParams pointer", __func__);
17966 VOS_ASSERT(0);
17967 return;
17968 }
17969
17970 if (IS_WDI_STATUS_FAILURE(wdiStatus))
17971 {
17972 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
17973 vos_mem_free(pWdaParams->wdaMsgParam);
17974 vos_mem_free(pWdaParams);
17975 }
17976
17977 return;
17978}
17979
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17980/*
17981 * FUNCTION: WDA_ProcessReceiveFilterSetFilterReq
17982 * Request to WDI to set Receive Filters
17983 */
17984VOS_STATUS WDA_ProcessReceiveFilterSetFilterReq (tWDA_CbContext *pWDA,
17985 tSirRcvPktFilterCfgType *pRcvPktFilterCfg)
17986{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]17987 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17988 v_SIZE_t allocSize = sizeof(WDI_SetRcvPktFilterReqParamsType) +
17989 ((pRcvPktFilterCfg->numFieldParams - 1) * sizeof(tSirRcvPktFilterFieldParams));
17990 WDI_SetRcvPktFilterReqParamsType *pwdiSetRcvPktFilterReqParamsType =
17991 (WDI_SetRcvPktFilterReqParamsType *)vos_mem_malloc(allocSize) ;
17992 tWDA_ReqParams *pWdaParams ;
17993 tANI_U8 i;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17994 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17995 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]17996 if(NULL == pwdiSetRcvPktFilterReqParamsType)
17997 {
17998 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]17999 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18000 VOS_ASSERT(0);
18001 return VOS_STATUS_E_NOMEM;
18002 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18003 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18004 if(NULL == pWdaParams)
18005 {
18006 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18007 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18008 VOS_ASSERT(0);
18009 vos_mem_free(pwdiSetRcvPktFilterReqParamsType);
18010 return VOS_STATUS_E_NOMEM;
18011 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18012 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId = pRcvPktFilterCfg->filterId;
18013 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType = pRcvPktFilterCfg->filterType;
18014 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams = pRcvPktFilterCfg->numFieldParams;
18015 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime = pRcvPktFilterCfg->coalesceTime;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18016 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.selfMacAddr,
18017 pRcvPktFilterCfg->selfMacAddr, sizeof(wpt_macAddr));
18018
18019 vos_mem_copy(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.bssId,
18020 pRcvPktFilterCfg->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18021
18022 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18023 "FID %d FT %d NParams %d CT %d",
18024 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterId,
18025 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.filterType,
18026 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams,
18027 pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.coalesceTime);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18028 for ( i = 0; i < pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.numFieldParams; i++ )
18029 {
18030 wpalMemoryCopy(&pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i],
18031 &pRcvPktFilterCfg->paramsData[i],
18032 sizeof(pwdiSetRcvPktFilterReqParamsType->wdiPktFilterCfg.paramsData[i]));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18033 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18034 "Proto %d Comp Flag %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18035 pwdiSetRcvPktFilterReqParamsType->
18036 wdiPktFilterCfg.paramsData[i].protocolLayer,
18037 pwdiSetRcvPktFilterReqParamsType->
18038 wdiPktFilterCfg.paramsData[i].cmpFlag);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18039 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18040 "Data Offset %d Data Len %d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18041 pwdiSetRcvPktFilterReqParamsType->
18042 wdiPktFilterCfg.paramsData[i].dataOffset,
18043 pwdiSetRcvPktFilterReqParamsType->
18044 wdiPktFilterCfg.paramsData[i].dataLength);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18045 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18046 "CData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18047 pwdiSetRcvPktFilterReqParamsType->
18048 wdiPktFilterCfg.paramsData[i].compareData[0],
18049 pwdiSetRcvPktFilterReqParamsType->
18050 wdiPktFilterCfg.paramsData[i].compareData[1],
18051 pwdiSetRcvPktFilterReqParamsType->
18052 wdiPktFilterCfg.paramsData[i].compareData[2],
18053 pwdiSetRcvPktFilterReqParamsType->
18054 wdiPktFilterCfg.paramsData[i].compareData[3],
18055 pwdiSetRcvPktFilterReqParamsType->
18056 wdiPktFilterCfg.paramsData[i].compareData[4],
18057 pwdiSetRcvPktFilterReqParamsType->
18058 wdiPktFilterCfg.paramsData[i].compareData[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18059 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18060 "MData: %d:%d:%d:%d:%d:%d",
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18061 pwdiSetRcvPktFilterReqParamsType->
18062 wdiPktFilterCfg.paramsData[i].dataMask[0],
18063 pwdiSetRcvPktFilterReqParamsType->
18064 wdiPktFilterCfg.paramsData[i].dataMask[1],
18065 pwdiSetRcvPktFilterReqParamsType->
18066 wdiPktFilterCfg.paramsData[i].dataMask[2],
18067 pwdiSetRcvPktFilterReqParamsType->
18068 wdiPktFilterCfg.paramsData[i].dataMask[3],
18069 pwdiSetRcvPktFilterReqParamsType->
18070 wdiPktFilterCfg.paramsData[i].dataMask[4],
18071 pwdiSetRcvPktFilterReqParamsType->
18072 wdiPktFilterCfg.paramsData[i].dataMask[5]);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18073 }
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18074 pwdiSetRcvPktFilterReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterSetFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]18075 pwdiSetRcvPktFilterReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18076 /* Store Params pass it to WDI */
18077 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetRcvPktFilterReqParamsType;
18078 pWdaParams->pWdaContext = pWDA;
18079 /* Store param pointer as passed in by caller */
18080 pWdaParams->wdaMsgParam = pRcvPktFilterCfg;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18081 status = WDI_ReceiveFilterSetFilterReq(pwdiSetRcvPktFilterReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]18082 (WDI_ReceiveFilterSetFilterCb)WDA_ReceiveFilterSetFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18083 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18084 if(IS_WDI_STATUS_FAILURE(status))
18085 {
18086 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18087 "Failure in SetFilter(),free all the memory,status %d ",status);
18088 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
18089 vos_mem_free(pWdaParams->wdaMsgParam);
18090 vos_mem_free(pWdaParams);
18091 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18092 return CONVERT_WDI2VOS_STATUS(status) ;
18093}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18094/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18095 * FUNCTION: WDA_FilterMatchCountRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18096 *
18097 */
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18098void WDA_FilterMatchCountRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]18099 WDI_RcvFltPktMatchCntRspParamsType *pwdiRcvFltPktMatchRspParams,
18100 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18101{
18102 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18103 tWDA_CbContext *pWDA;
18104 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntReq;
18105 tpSirRcvFltPktMatchRsp pRcvFltPktMatchCntRsp =
18106 vos_mem_malloc(sizeof(tSirRcvFltPktMatchRsp));
18107 tANI_U8 i;
18108 vos_msg_t vosMsg;
18109
18110 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18111 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18112 /*WDA_VOS_ASSERT(NULL != pWdaParams);*/
18113
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18114 if(NULL == pRcvFltPktMatchCntRsp)
18115 {
18116 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18117 "%s: pRcvFltPktMatchCntRsp is NULL", __func__);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18118 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]18119 vos_mem_free(pWdaParams);
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18120 return ;
18121 }
18122
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18123 if(NULL == pWdaParams)
18124 {
18125 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18126 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18127 VOS_ASSERT(0) ;
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]18128 vos_mem_free(pRcvFltPktMatchCntRsp);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18129 return ;
18130 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18131 pWDA = (tWDA_CbContext *)pWdaParams->pWdaContext ;
18132 pRcvFltPktMatchCntReq = (tpSirRcvFltPktMatchRsp)pWdaParams->wdaMsgParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18133 // Fill pRcvFltPktMatchCntRsp from pRcvFltPktMatchCntReq
18134 vos_mem_zero(pRcvFltPktMatchCntRsp,sizeof(tSirRcvFltPktMatchRsp));
18135
18136 /* Message Header */
18137 pRcvFltPktMatchCntRsp->mesgType = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
18138 pRcvFltPktMatchCntRsp->mesgLen = sizeof(tSirRcvFltPktMatchRsp);
18139
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]18140 pRcvFltPktMatchCntRsp->status = pwdiRcvFltPktMatchRspParams->wdiStatus;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18141
18142 for (i = 0; i < SIR_MAX_NUM_FILTERS; i++)
18143 {
18144 pRcvFltPktMatchCntRsp->filterMatchCnt[i].filterId = pRcvFltPktMatchCntReq->filterMatchCnt[i].filterId;
18145 pRcvFltPktMatchCntRsp->filterMatchCnt[i].matchCnt = pRcvFltPktMatchCntReq->filterMatchCnt[i].matchCnt;
18146 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18147 /* VOS message wrapper */
18148 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
18149 vosMsg.bodyptr = (void *)pRcvFltPktMatchCntRsp;
18150 vosMsg.bodyval = 0;
18151 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
18152 {
18153 /* free the mem and return */
18154 vos_mem_free((v_VOID_t *)pRcvFltPktMatchCntRsp);
18155 }
18156
18157 vos_mem_free(pWdaParams->wdaMsgParam) ;
18158 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18159 vos_mem_free(pWdaParams) ;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18160
18161 return;
18162}
18163/*
18164 * FUNCTION: WDA_FilterMatchCountReqCallback
18165 * Free memory and send RSP back to SME.
18166 * Invoked when FilterMatchCount REQ failed in WDI and no RSP callback is generated.
18167 */
18168void WDA_FilterMatchCountReqCallback(WDI_Status wdiStatus, void * pUserData)
18169{
18170 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18171 vos_msg_t vosMsg;
18172
18173 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18174 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
18175
18176 if(NULL == pWdaParams)
18177 {
18178 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18179 "%s: pWdaParams received NULL", __func__);
18180 VOS_ASSERT(0);
18181 return;
18182 }
18183
18184 /* VOS message wrapper */
18185 vosMsg.type = eWNI_PMC_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP;
18186 vosMsg.bodyptr = NULL;
18187 vosMsg.bodyval = 0;
18188
18189 if(IS_WDI_STATUS_FAILURE(wdiStatus))
18190 {
18191 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18192 vos_mem_free(pWdaParams->wdaMsgParam);
18193 vos_mem_free(pWdaParams);
18194 vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg);
18195 }
18196
18197 return;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18198}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18199/*
18200 * FUNCTION: WDA_ProcessPacketFilterMatchCountReq
18201 * Request to WDI to get PC Filter Match Count
18202 */
18203VOS_STATUS WDA_ProcessPacketFilterMatchCountReq (tWDA_CbContext *pWDA, tpSirRcvFltPktMatchRsp pRcvFltPktMatchRsp)
18204{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]18205 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18206 WDI_RcvFltPktMatchCntReqParamsType *pwdiRcvFltPktMatchCntReqParamsType =
18207 (WDI_RcvFltPktMatchCntReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktMatchCntReqParamsType));
18208 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18209 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18210 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18211 if(NULL == pwdiRcvFltPktMatchCntReqParamsType)
18212 {
18213 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18214 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18215 VOS_ASSERT(0);
18216 return VOS_STATUS_E_NOMEM;
18217 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18218 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18219 if(NULL == pWdaParams)
18220 {
18221 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18222 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18223 VOS_ASSERT(0);
18224 vos_mem_free(pwdiRcvFltPktMatchCntReqParamsType);
18225 return VOS_STATUS_E_NOMEM;
18226 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]18227
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18228 pwdiRcvFltPktMatchCntReqParamsType->wdiReqStatusCB = WDA_FilterMatchCountReqCallback;
18229 pwdiRcvFltPktMatchCntReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18230
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]18231 vos_mem_copy( pwdiRcvFltPktMatchCntReqParamsType->bssId,
18232 pRcvFltPktMatchRsp->bssId,
18233 sizeof(wpt_macAddr));
18234
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18235 /* Store Params pass it to WDI */
18236 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktMatchCntReqParamsType;
18237 pWdaParams->pWdaContext = pWDA;
18238 /* Store param pointer as passed in by caller */
18239 pWdaParams->wdaMsgParam = pRcvFltPktMatchRsp;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18240 status = WDI_FilterMatchCountReq(pwdiRcvFltPktMatchCntReqParamsType,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18241 (WDI_FilterMatchCountCb)WDA_FilterMatchCountRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18242 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18243 if(IS_WDI_STATUS_FAILURE(status))
18244 {
18245 /* failure returned by WDI API */
18246 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18247 "Failure in WDI_FilterMatchCountReq(), free all the memory " );
18248 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18249 vos_mem_free(pWdaParams) ;
18250 pRcvFltPktMatchRsp->status = eSIR_FAILURE ;
18251 WDA_SendMsg(pWDA, WDA_PACKET_COALESCING_FILTER_MATCH_COUNT_RSP, (void *)pRcvFltPktMatchRsp, 0) ;
18252 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18253 return CONVERT_WDI2VOS_STATUS(status) ;
18254}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18255/*
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]18256 * FUNCTION: WDA_ReceiveFilterClearFilterRespCallback
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18257 *
18258 */
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]18259void WDA_ReceiveFilterClearFilterRespCallback(
Madan Mohan Koyyalamudi96dd30d2012-10-05 17:24:51 -0700[diff] [blame]18260 WDI_RcvFltPktClearRspParamsType *pwdiRcvFltPktClearRspParamsType,
18261 void * pUserData)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18262{
18263 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18264 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18265 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18266/* WDA_VOS_ASSERT(NULL != pWdaParams); */
18267 if(NULL == pWdaParams)
18268 {
18269 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18270 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18271 VOS_ASSERT(0) ;
18272 return ;
18273 }
18274
18275 vos_mem_free(pWdaParams->wdaMsgParam) ;
18276 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18277 vos_mem_free(pWdaParams) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18278 //print a msg, nothing else to do
18279 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]18280 "WDA_ReceiveFilterClearFilterRespCallback invoked " );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18281 return ;
18282}
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18283/*
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18284 * FUNCTION: WDA_ReceiveFilterClearFilterReqCallback
18285 * Free memory.
18286 * Invoked when ReceiveFilterClearFilter REQ failed in WDI and no RSP callback is generated.
18287 */
18288void WDA_ReceiveFilterClearFilterReqCallback(WDI_Status wdiStatus, void* pUserData)
18289{
18290 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18291
18292 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18293 "<------ %s, wdiStatus: %d", __func__, wdiStatus);
18294
18295 if(NULL == pWdaParams)
18296 {
18297 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18298 "%s: Invalid pWdaParams pointer", __func__);
18299 VOS_ASSERT(0);
18300 return;
18301 }
18302
18303 if(IS_WDI_STATUS_FAILURE(wdiStatus))
18304 {
18305 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18306 vos_mem_free(pWdaParams->wdaMsgParam);
18307 vos_mem_free(pWdaParams);
18308 }
18309
18310 return;
18311}
18312/*
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18313 * FUNCTION: WDA_ProcessReceiveFilterClearFilterReq
18314 * Request to WDI to clear Receive Filters
18315 */
18316VOS_STATUS WDA_ProcessReceiveFilterClearFilterReq (tWDA_CbContext *pWDA,
18317 tSirRcvFltPktClearParam *pRcvFltPktClearParam)
18318{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]18319 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18320 WDI_RcvFltPktClearReqParamsType *pwdiRcvFltPktClearReqParamsType =
18321 (WDI_RcvFltPktClearReqParamsType *)vos_mem_malloc(sizeof(WDI_RcvFltPktClearReqParamsType));
18322 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18323 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18324 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18325 if(NULL == pwdiRcvFltPktClearReqParamsType)
18326 {
18327 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18328 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18329 VOS_ASSERT(0);
18330 return VOS_STATUS_E_NOMEM;
18331 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18332 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18333 if(NULL == pWdaParams)
18334 {
18335 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18336 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18337 VOS_ASSERT(0);
18338 vos_mem_free(pwdiRcvFltPktClearReqParamsType);
18339 return VOS_STATUS_E_NOMEM;
18340 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18341 pwdiRcvFltPktClearReqParamsType->filterClearParam.status = pRcvFltPktClearParam->status;
18342 pwdiRcvFltPktClearReqParamsType->filterClearParam.filterId = pRcvFltPktClearParam->filterId;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18343 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.selfMacAddr,
18344 pRcvFltPktClearParam->selfMacAddr, sizeof(wpt_macAddr));
18345 vos_mem_copy(pwdiRcvFltPktClearReqParamsType->filterClearParam.bssId,
18346 pRcvFltPktClearParam->bssId, sizeof(wpt_macAddr));
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18347
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18348 pwdiRcvFltPktClearReqParamsType->wdiReqStatusCB = WDA_ReceiveFilterClearFilterReqCallback;
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]18349 pwdiRcvFltPktClearReqParamsType->pUserData = pWdaParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18350 /* Store Params pass it to WDI */
18351 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiRcvFltPktClearReqParamsType;
18352 pWdaParams->pWdaContext = pWDA;
18353 /* Store param pointer as passed in by caller */
18354 pWdaParams->wdaMsgParam = pRcvFltPktClearParam;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18355 status = WDI_ReceiveFilterClearFilterReq(pwdiRcvFltPktClearReqParamsType,
Tushnim Bhattacharyya4858ab62013-03-08 10:15:42 -0800[diff] [blame]18356 (WDI_ReceiveFilterClearFilterCb)WDA_ReceiveFilterClearFilterRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18357 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18358 if(IS_WDI_STATUS_FAILURE(status))
18359 {
18360 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18361 "Failure in WDA_ProcessReceiveFilterClearFilterReq(), free all the memory " );
18362 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
Venkata Prathyusha Kuntupalli17e75ce2013-02-05 11:39:32 -0800[diff] [blame]18363 vos_mem_free(pWdaParams->wdaMsgParam);
18364 vos_mem_free(pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18365 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18366 return CONVERT_WDI2VOS_STATUS(status) ;
18367}
18368#endif // WLAN_FEATURE_PACKET_FILTERING
18369
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18370/*
18371 * FUNCTION: WDA_ProcessSetPowerParamsReq
18372 * Request to WDI to set power params
18373 */
18374VOS_STATUS WDA_ProcessSetPowerParamsReq(tWDA_CbContext *pWDA,
18375 tSirSetPowerParamsReq *pPowerParams)
18376{
Jeff Johnson43971f52012-07-17 12:26:56 -0700[diff] [blame]18377 WDI_Status status;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18378 WDI_SetPowerParamsReqParamsType *pwdiSetPowerParamsReqInfo =
18379 (WDI_SetPowerParamsReqParamsType *)vos_mem_malloc(sizeof(WDI_SetPowerParamsReqParamsType)) ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18380 tWDA_ReqParams *pWdaParams ;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18381 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18382 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18383 if(NULL == pwdiSetPowerParamsReqInfo)
18384 {
18385 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18386 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18387 VOS_ASSERT(0);
18388 return VOS_STATUS_E_NOMEM;
18389 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18390 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18391 if(NULL == pWdaParams)
18392 {
18393 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18394 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18395 VOS_ASSERT(0);
18396 vos_mem_free(pwdiSetPowerParamsReqInfo);
18397 return VOS_STATUS_E_NOMEM;
18398 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18399
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18400
18401 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uIgnoreDTIM =
18402 pPowerParams->uIgnoreDTIM;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18403 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uDTIMPeriod =
18404 pPowerParams->uDTIMPeriod;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18405 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uListenInterval =
18406 pPowerParams->uListenInterval;
18407 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBcastMcastFilter =
18408 pPowerParams->uBcastMcastFilter;
18409 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uEnableBET =
18410 pPowerParams->uEnableBET;
18411 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uBETInterval =
18412 pPowerParams->uBETInterval;
Yue Mac24062f2013-05-13 17:01:29 -0700[diff] [blame]18413 pwdiSetPowerParamsReqInfo->wdiSetPowerParamsInfo.uMaxLIModulatedDTIM =
18414 pPowerParams->uMaxLIModulatedDTIM;
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18415 pwdiSetPowerParamsReqInfo->wdiReqStatusCB = WDA_SetPowerParamsReqCallback;
18416 pwdiSetPowerParamsReqInfo->pUserData = pWdaParams;
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]18417
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18418 /* Store Params pass it to WDI */
18419 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiSetPowerParamsReqInfo;
18420 pWdaParams->pWdaContext = pWDA;
18421 /* Store param pointer as passed in by caller */
18422 pWdaParams->wdaMsgParam = pPowerParams;
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18423 status = WDI_SetPowerParamsReq( pwdiSetPowerParamsReqInfo,
Yue Ma7f44bbe2013-04-12 11:47:39 -0700[diff] [blame]18424 (WDI_SetPowerParamsCb)WDA_SetPowerParamsRespCallback,
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18425 pWdaParams);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18426 if(IS_WDI_STATUS_FAILURE(status))
18427 {
18428 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18429 "Failure in Set power params REQ WDI API, free all the memory " );
18430 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
18431 vos_mem_free(pWdaParams->wdaMsgParam);
18432 pWdaParams->wdaWdiApiMsgParam = NULL;
18433 pWdaParams->wdaMsgParam = NULL;
18434 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18435 return CONVERT_WDI2VOS_STATUS(status) ;
18436}
18437
18438/*
18439 * FUNCTION: WDA_SetTmLevelRspCallback
18440 * Set TM Level response
18441 */
18442void WDA_SetTmLevelRspCallback(WDI_Status status, void* pUserData)
18443{
18444 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18445
18446 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18447 "<------ %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18448
18449 if(NULL == pWdaParams)
18450 {
18451 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18452 "%s: pWdaParams received NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18453 VOS_ASSERT(0) ;
18454 return ;
18455 }
18456
18457 /* Dose not need to send notification to upper layer
18458 * Just free allocated resources */
18459 if( pWdaParams != NULL )
18460 {
18461 if( pWdaParams->wdaWdiApiMsgParam != NULL )
18462 {
18463 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18464 }
18465 vos_mem_free(pWdaParams->wdaMsgParam) ;
18466 vos_mem_free(pWdaParams) ;
18467 }
18468}
18469
18470/*
18471 * FUNCTION: WDA_ProcessSetTmLevelReq
18472 * Set TM Level request
18473 */
18474VOS_STATUS WDA_ProcessSetTmLevelReq(tWDA_CbContext *pWDA,
18475 tAniSetTmLevelReq *setTmLevelReq)
18476{
18477 WDI_Status status = WDI_STATUS_SUCCESS ;
18478 tWDA_ReqParams *pWdaParams ;
18479 WDI_SetTmLevelReqType *wdiSetTmLevelReq =
18480 (WDI_SetTmLevelReqType *)vos_mem_malloc(
18481 sizeof(WDI_SetTmLevelReqType)) ;
18482 if(NULL == wdiSetTmLevelReq)
18483 {
18484 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18485 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18486 VOS_ASSERT(0);
18487 return VOS_STATUS_E_NOMEM;
18488 }
18489
18490 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18491 if(NULL == pWdaParams)
18492 {
18493 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18494 "%s: VOS MEM Alloc Failure", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18495 VOS_ASSERT(0);
18496 vos_mem_free(wdiSetTmLevelReq);
18497 return VOS_STATUS_E_NOMEM;
18498 }
18499
18500 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18501 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18502
18503 wdiSetTmLevelReq->tmMode = setTmLevelReq->tmMode;
18504 wdiSetTmLevelReq->tmLevel = setTmLevelReq->newTmLevel;
18505
18506 pWdaParams->pWdaContext = pWDA;
18507 pWdaParams->wdaMsgParam = setTmLevelReq;
18508 pWdaParams->wdaWdiApiMsgParam = wdiSetTmLevelReq;
18509
18510 status = WDI_SetTmLevelReq(wdiSetTmLevelReq,
18511 (WDI_SetTmLevelCb)WDA_SetTmLevelRspCallback, pWdaParams);
18512
18513 if(IS_WDI_STATUS_FAILURE(status))
18514 {
18515 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Jeff Johnson902c9832012-12-10 14:28:09 -0800[diff] [blame]18516 "Failure setting thermal mitigation level, freeing memory" );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18517 vos_mem_free(pWdaParams->wdaMsgParam) ;
18518 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18519 vos_mem_free(pWdaParams) ;
18520 }
18521
18522 return CONVERT_WDI2VOS_STATUS(status) ;
18523}
18524
18525VOS_STATUS WDA_ProcessTxControlInd(tWDA_CbContext *pWDA,
18526 tpTxControlParams pTxCtrlParam)
18527{
18528 VOS_STATUS wdaStatus;
18529
18530 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18531 "------> %s " ,__func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18532 if( pTxCtrlParam == NULL )
18533 {
18534 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18535 "%s: Input tpTxControlParams is NULL", __func__);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18536 return VOS_STATUS_E_FAILURE;
18537 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18538 if( pTxCtrlParam->stopTx == eANI_BOOLEAN_TRUE )
18539 {
18540 wdaStatus = WDA_SuspendDataTx(pWDA);
18541 }
18542 else /* pTxCtrlParam->stopTx == eANI_BOOLEAN_FALSE */
18543 {
18544 wdaStatus = WDA_ResumeDataTx(pWDA);
18545 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18546 return wdaStatus;
18547}
18548
Hanumantha Reddy Pothulae00a7e22015-09-15 20:11:30 +0530[diff] [blame]18549void WDA_FWLoggingDXEdoneInd(v_U32_t logType)
Mihir Shete5affadc2015-05-29 20:54:57 +0530[diff] [blame]18550{
Hanumantha Reddy Pothulae00a7e22015-09-15 20:11:30 +0530[diff] [blame]18551 WDI_Status status;
18552 status = WDI_FWLoggingDXEdoneInd(logType);
18553
Hanumantha Reddy Pothula5e509402015-09-23 09:45:57 +0530[diff] [blame]18554 if (!(WDI_STATUS_SUCCESS_SYNC == status || WDI_STATUS_PENDING == status))
Hanumantha Reddy Pothulae00a7e22015-09-15 20:11:30 +0530[diff] [blame]18555 {
18556 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18557 FL("Failure status %d"), status);
18558 }
Mihir Shete5affadc2015-05-29 20:54:57 +0530[diff] [blame]18559}
18560
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18561 /* FUNCTION WDA_featureCapsExchange
18562 * WDA API to invoke capability exchange between host and FW.
18563 */
18564void WDA_featureCapsExchange(v_PVOID_t pVosContext)
18565{
18566 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18567 "%s:enter", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18568 WDI_featureCapsExchangeReq( NULL, pVosContext);
18569}
18570
Yathish9f22e662012-12-10 14:21:35 -0800[diff] [blame]18571/* FUNCTION WDA_disableCapablityFeature
18572 * WDA API to diable Active mode offload in host.
18573 */
18574void WDA_disableCapablityFeature(tANI_U8 feature_index)
18575{
18576 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18577 "%s:enter", __func__ );
18578 WDI_disableCapablityFeature(feature_index);
18579}
18580
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18581 /* FUNCTION WDA_getHostWlanFeatCaps
18582 * Wrapper for WDI API, that will return if the feature (enum value).passed
18583 * to this API is supported or not in Host
18584 * return value
18585 * 0 - implies feature is NOT Supported
18586 * any non zero value - implies feature is SUPPORTED
18587 */
18588tANI_U8 WDA_getHostWlanFeatCaps(tANI_U8 featEnumValue)
18589{
18590 return WDI_getHostWlanFeatCaps(featEnumValue);
18591}
18592
18593 /* FUNCTION WDA_getFwWlanFeatCaps
18594 * Wrapper for WDI API, that will return if the feature (enum value).passed
18595 * to this API is supported or not in FW
18596 * return value
18597 * 0 - implies feature is NOT Supported
18598 * any non zero value - implies feature is SUPPORTED
18599 */
18600tANI_U8 WDA_getFwWlanFeatCaps(tANI_U8 featEnumValue)
18601{
18602 return WDI_getFwWlanFeatCaps(featEnumValue);
18603}
18604
Sundaresan Ramachandran76e48e82013-07-15 13:07:17 +0530[diff] [blame]18605
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18606/*
18607 * FUNCTION: WDA_shutdown
18608 * Shutdown WDA/WDI without handshaking with Riva.
18609 * Synchronous function.
18610 */
18611VOS_STATUS WDA_shutdown(v_PVOID_t pVosContext, wpt_boolean closeTransport)
18612{
18613 WDI_Status wdiStatus;
18614 //tANI_U8 eventIdx = 0;
18615 VOS_STATUS status = VOS_STATUS_SUCCESS;
18616 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18617 if (NULL == pWDA)
18618 {
18619 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18620 "%s: Invoked with invalid pWDA", __func__ );
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18621 VOS_ASSERT(0);
18622 return VOS_STATUS_E_FAILURE;
18623 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18624 /* FTM mode stay START_STATE */
18625 if( (WDA_READY_STATE != pWDA->wdaState) &&
18626 (WDA_INIT_STATE != pWDA->wdaState) &&
18627 (WDA_START_STATE != pWDA->wdaState) )
18628 {
18629 VOS_ASSERT(0);
18630 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]18631
Hanumantha Reddy Pothulab5c67c02015-07-14 21:27:50 +0530[diff] [blame]18632 if (eDRIVER_TYPE_MFG != pWDA->driverMode)
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18633 {
Hanumantha Reddy Pothulab5c67c02015-07-14 21:27:50 +0530[diff] [blame]18634 if(VOS_TRUE == pWDA->wdaTimersCreated)
18635 {
18636 wdaDestroyTimers(pWDA);
18637 pWDA->wdaTimersCreated = VOS_FALSE;
18638 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18639 }
Leo Chang9d76f622013-08-23 16:34:52 -0700[diff] [blame]18640 else
18641 {
18642 vos_event_destroy(&pWDA->ftmStopDoneEvent);
Hanumantha Reddy Pothulab5c67c02015-07-14 21:27:50 +0530[diff] [blame]18643 }
Madan Mohan Koyyalamudida61e7e2012-10-30 18:08:14 -0700[diff] [blame]18644
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18645 /* call WDI shutdown */
18646 wdiStatus = WDI_Shutdown(closeTransport);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18647 if (IS_WDI_STATUS_FAILURE(wdiStatus) )
18648 {
18649 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18650 "error in WDA Stop" );
18651 status = VOS_STATUS_E_FAILURE;
18652 }
18653 /* WDI stop is synchrnous, shutdown is complete when it returns */
18654 pWDA->wdaState = WDA_STOP_STATE;
18655
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18656 /* shutdown should perform the stop & close actions. */
18657 /* Destroy the event */
18658 status = vos_event_destroy(&pWDA->txFrameEvent);
18659 if(!VOS_IS_STATUS_SUCCESS(status))
18660 {
18661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18662 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18663 status = VOS_STATUS_E_FAILURE;
18664 }
18665 status = vos_event_destroy(&pWDA->suspendDataTxEvent);
18666 if(!VOS_IS_STATUS_SUCCESS(status))
18667 {
18668 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18669 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18670 status = VOS_STATUS_E_FAILURE;
18671 }
18672 status = vos_event_destroy(&pWDA->waitOnWdiIndicationCallBack);
18673 if(!VOS_IS_STATUS_SUCCESS(status))
18674 {
18675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Arif Hussainf9587ab2013-11-17 22:01:22 -0800[diff] [blame]18676 "VOS Event destroy failed - status = %d", status);
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18677 status = VOS_STATUS_E_FAILURE;
18678 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18679 /* free WDA context */
18680 status = vos_free_context(pVosContext,VOS_MODULE_ID_WDA,pWDA);
18681 if ( !VOS_IS_STATUS_SUCCESS(status) )
18682 {
18683 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18684 "error in WDA close " );
18685 status = VOS_STATUS_E_FAILURE;
18686 }
Jeff Johnson295189b2012-06-20 16:38:30 -0700[diff] [blame]18687 return status;
18688}
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]18689
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18690/*
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]18691 * FUNCTION: WDA_setNeedShutdown
18692 * WDA stop failed or WDA NVDownload failed
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18693 */
18694
Madan Mohan Koyyalamudi9d7a27f2012-11-28 15:55:25 -0800[diff] [blame]18695void WDA_setNeedShutdown(v_PVOID_t pVosContext)
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18696{
18697 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]18698 if(pWDA == NULL)
18699 {
18700 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18701 "Could not get the WDA Context pointer" );
18702 return;
18703 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18704 pWDA->needShutdown = TRUE;
18705}
18706/*
18707 * FUNCTION: WDA_needShutdown
18708 * WDA needs a shutdown
18709 */
18710
18711v_BOOL_t WDA_needShutdown(v_PVOID_t pVosContext)
18712{
18713 tWDA_CbContext *pWDA = (tWDA_CbContext *)VOS_GET_WDA_CTXT(pVosContext);
Madan Mohan Koyyalamudi33ef6a22012-10-30 17:44:43 -0700[diff] [blame]18714 if(pWDA == NULL)
18715 {
18716 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18717 "Could not get the WDA Context pointer" );
18718 return 0;
18719 }
18720 return pWDA->needShutdown;
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18721}
18722
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18723#ifdef WLAN_FEATURE_11AC
18724/*
18725 * FUNCTION: WDA_SetBeaconFilterReqCallback
18726 *
18727 */
18728void WDA_SetUpdateOpModeReqCallback(WDI_Status status, void* pUserData)
18729{
18730 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18731 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18732 "<------ %s " ,__func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18733 if(NULL == pWdaParams)
18734 {
18735 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18736 "%s: pWdaParams received NULL", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18737 VOS_ASSERT(0) ;
18738 return ;
18739 }
Jeff Johnsone7245742012-09-05 17:12:55 -0700[diff] [blame]18740
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18741 vos_mem_free(pWdaParams->wdaMsgParam) ;
18742 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18743 vos_mem_free(pWdaParams) ;
18744 /*
18745 * No respone required for SetBeaconFilter req so just free the request
18746 * param here
18747 */
18748
18749 return ;
18750}
18751
18752VOS_STATUS WDA_ProcessUpdateOpMode(tWDA_CbContext *pWDA,
18753 tUpdateVHTOpMode *pData)
18754{
18755 WDI_Status status = WDI_STATUS_SUCCESS ;
18756 tWDA_ReqParams *pWdaParams ;
18757 WDI_UpdateVHTOpMode *wdiTemp = (WDI_UpdateVHTOpMode *)vos_mem_malloc(
18758 sizeof(WDI_UpdateVHTOpMode)) ;
18759 if(NULL == wdiTemp)
18760 {
18761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18762 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18763 VOS_ASSERT(0);
18764 return VOS_STATUS_E_NOMEM;
18765 }
18766 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18767 if(NULL == pWdaParams)
18768 {
18769 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
Madan Mohan Koyyalamudi87054ba2012-11-02 13:24:12 -0700[diff] [blame]18770 "%s: VOS MEM Alloc Failure", __func__);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18771 VOS_ASSERT(0);
18772 vos_mem_free(wdiTemp);
18773 return VOS_STATUS_E_NOMEM;
18774 }
Abhishek Singhdf8eb312014-11-15 00:49:28 +0530[diff] [blame]18775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18776 "------> %s Opmode = %d and staid = %d" ,
18777 __func__, pData->opMode, pData->staId);
Mohit Khanna4a70d262012-09-11 16:30:12 -0700[diff] [blame]18778 wdiTemp->opMode = pData->opMode;
18779 wdiTemp->staId = pData->staId;
18780
18781 pWdaParams->pWdaContext = pWDA;
18782 /* Store Req pointer, as this will be used for response */
18783 pWdaParams->wdaMsgParam = (void *)pData;
18784 /* store Params pass it to WDI */
18785 pWdaParams->wdaWdiApiMsgParam = (void *)wdiTemp ;
18786
18787 status = WDI_UpdateVHTOpModeReq( wdiTemp, (WDI_UpdateVHTOpModeCb) WDA_SetUpdateOpModeReqCallback, pWdaParams);
18788
18789 if(IS_WDI_STATUS_FAILURE(status))
18790 {
18791 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18792 "Failure in UPDATE VHT OP_MODE REQ Params WDI API, free all the memory " );
18793 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
18794 vos_mem_free(pWdaParams->wdaMsgParam);
18795 vos_mem_free(pWdaParams);
18796 }
18797 return CONVERT_WDI2VOS_STATUS(status) ;
18798}
18799#endif
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18800
18801/*==========================================================================
18802 FUNCTION WDA_TransportChannelDebug
18803
Madan Mohan Koyyalamudid93f4942012-10-05 15:05:40 -0700[diff] [blame]18804 DESCRIPTION
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18805 Display Transport Channel debugging information
18806 User may request to display DXE channel snapshot
18807 Or if host driver detects any abnormal stcuk may display
18808
18809 PARAMETERS
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]18810 pMac : upper MAC context pointer
Jeff Johnsonb88db982012-12-10 13:34:59 -0800[diff] [blame]18811 displaySnapshot : Display DXE snapshot option
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]18812 debugFlags : Enable stall detect features
18813 defined by WPAL_DeviceDebugFlags
18814 These features may effect
18815 data performance.
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18816
18817 RETURN VALUE
18818 NONE
18819
18820===========================================================================*/
18821void WDA_TransportChannelDebug
18822(
schang6295e542013-03-12 15:31:23 -0700[diff] [blame]18823 tpAniSirGlobal pMac,
18824 v_BOOL_t displaySnapshot,
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]18825 v_U8_t debugFlags
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18826)
18827{
Mihir Shete40a55652014-03-02 14:14:47 +0530[diff] [blame]18828 WDI_TransportChannelDebug(displaySnapshot, debugFlags);
Madan Mohan Koyyalamudi8cb53982012-09-28 14:34:47 -0700[diff] [blame]18829 return;
Madan Mohan Koyyalamudi5eec74a2012-09-28 14:59:25 -0700[diff] [blame]18830}
Gopichand Nakkalae620d5a2013-04-26 05:45:57 -0700[diff] [blame]18831
18832/*==========================================================================
18833 FUNCTION WDA_SetEnableSSR
18834
18835 DESCRIPTION
18836 API to enable/disable SSR on WDI timeout
18837
18838 PARAMETERS
18839 enableSSR : enable/disable SSR
18840
18841 RETURN VALUE
18842 NONE
18843
18844===========================================================================*/
18845void WDA_SetEnableSSR(v_BOOL_t enableSSR)
18846{
18847 WDI_SetEnableSSR(enableSSR);
18848}
Leo Chang9056f462013-08-01 19:21:11 -0700[diff] [blame]18849
18850#ifdef FEATURE_WLAN_LPHB
18851/*
18852 * FUNCTION: WDA_LPHBconfRspCallback
18853 *
18854 */
18855void WDA_LPHBconfRspCallback(WDI_Status status, void* pUserData)
18856{
18857 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
18858
18859 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18860 "<------ %s " ,__func__);
18861 if (NULL == pWdaParams)
18862 {
18863 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18864 "%s: pWdaParams received NULL", __func__);
18865 VOS_ASSERT(0) ;
18866 return ;
18867 }
18868
18869 /* Do not need to send notification to upper layer
18870 * Just free allocated resources */
18871 if (pWdaParams != NULL)
18872 {
18873 if (pWdaParams->wdaWdiApiMsgParam != NULL)
18874 {
18875 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
18876 }
18877 vos_mem_free(pWdaParams->wdaMsgParam) ;
18878 vos_mem_free(pWdaParams) ;
18879 }
18880
18881 return;
18882}
18883
18884/*
18885 * FUNCTION: WDA_ProcessLPHBConfReq
18886 *
18887 */
18888VOS_STATUS WDA_ProcessLPHBConfReq(tWDA_CbContext *pWDA,
18889 tSirLPHBReq *pData)
18890{
18891 WDI_Status wdiStatus;
18892 tWDA_ReqParams *pWdaParams ;
18893
18894 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18895 "------> %s " , __func__);
18896
18897 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
18898 if (NULL == pWdaParams)
18899 {
18900 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18901 "%s: VOS MEM Alloc Failure", __func__);
18902 VOS_ASSERT(0);
18903 vos_mem_free(pData);
18904 return VOS_STATUS_E_NOMEM;
18905 }
18906
18907 pWdaParams->pWdaContext = pWDA;
18908 pWdaParams->wdaMsgParam = (void *)pData;
18909 pWdaParams->wdaWdiApiMsgParam = NULL;
18910
18911 wdiStatus = WDI_LPHBConfReq(pData, pWdaParams, WDA_LPHBconfRspCallback);
18912 if (WDI_STATUS_PENDING == wdiStatus)
18913 {
18914 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18915 "Pending received for %s:%d ", __func__, __LINE__);
18916 }
18917 else if (WDI_STATUS_SUCCESS != wdiStatus)
18918 {
18919 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18920 "Failure in %s:%d s %d", __func__, __LINE__, wdiStatus);
18921 vos_mem_free(pWdaParams->wdaMsgParam);
18922 vos_mem_free(pWdaParams);
18923 }
18924
18925 return CONVERT_WDI2VOS_STATUS(wdiStatus);
18926}
18927#endif /* FEATURE_WLAN_LPHB */
18928
c_hpothu92367912014-05-01 15:18:17 +0530[diff] [blame]18929void WDA_GetBcnMissRateCallback(tANI_U8 status, tANI_U32 bcnMissRate,
18930 void* pUserData)
18931{
18932 tSirBcnMissRateInfo *pBcnMissRateInfo = (tSirBcnMissRateInfo *)pUserData;
18933
18934 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18935 "<------ %s " ,__func__);
18936 if (NULL == pBcnMissRateInfo)
18937 {
18938 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18939 "%s: pWdaParams received NULL", __func__);
18940 VOS_ASSERT(0) ;
18941 return ;
18942 }
18943 if (pBcnMissRateInfo->callback)
18944 {
18945 pBcnMissRateInfo->callback(status, bcnMissRate,
18946 pBcnMissRateInfo->data);
18947 }
18948 vos_mem_free(pUserData);
18949
18950 return;
18951}
18952
18953v_VOID_t WDA_ProcessGetBcnMissRateReq(tWDA_CbContext *pWDA,
18954 tSirBcnMissRateReq *pData)
18955{
18956 WDI_Status wdiStatus;
18957 tSirBcnMissRateInfo *pBcnMissRateInfo;
18958
18959 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18960 "------> %s " , __func__);
18961
18962 pBcnMissRateInfo =
18963 (tSirBcnMissRateInfo *)vos_mem_malloc(sizeof(tSirBcnMissRateInfo));
18964 if (NULL == pBcnMissRateInfo)
18965 {
18966 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
18967 "%s: VOS MEM Alloc Failure", __func__);
18968 VOS_ASSERT(0);
18969 vos_mem_free(pData);
18970 return;
18971 }
18972
18973 pBcnMissRateInfo->callback = (pGetBcnMissRateCB)(pData->callback);
18974 pBcnMissRateInfo->data = pData->data;
18975
18976 wdiStatus = WDI_GetBcnMissRate(pBcnMissRateInfo,
18977 WDA_GetBcnMissRateCallback,
18978 pData->bssid);
18979 if (WDI_STATUS_PENDING == wdiStatus)
18980 {
18981 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
18982 "Pending received for %s:%d ", __func__, __LINE__);
18983 }
18984 else if (WDI_STATUS_SUCCESS != wdiStatus)
18985 {
18986 if (pBcnMissRateInfo->callback)
18987 {
18988 pBcnMissRateInfo->callback(VOS_STATUS_E_FAILURE,
18989 -1, pBcnMissRateInfo->data);
18990 }
18991 }
18992 vos_mem_free(pData);
18993}
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]18994
18995#ifdef WLAN_FEATURE_EXTSCAN
18996
18997/*==========================================================================
18998 FUNCTION WDA_EXTScanStartRspCallback
18999
19000 DESCRIPTION
19001 API to send EXTScan Start Response to HDD
19002
19003 PARAMETERS
19004 pEventData: Response from FW
19005 pUserData:
19006===========================================================================*/
19007void WDA_EXTScanStartRspCallback(void *pEventData, void* pUserData)
19008{
19009 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19010 tWDA_CbContext *pWDA = NULL;
19011 void *pCallbackContext;
19012 tpAniSirGlobal pMac;
19013
19014 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19015 "%s:", __func__);
19016 if (NULL == pWdaParams)
19017 {
19018 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19019 "%s: pWdaParams received NULL", __func__);
19020 VOS_ASSERT(0);
19021 return;
19022 }
19023
19024 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19025
19026 if (NULL == pWDA)
19027 {
19028 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19029 "%s: pWDA received NULL", __func__);
19030 VOS_ASSERT(0);
19031 goto error;
19032 }
19033
19034 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19035 if (NULL == pMac)
19036 {
19037 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19038 "%s:pMac is NULL", __func__);
19039 VOS_ASSERT(0);
19040 goto error;
19041 }
19042
19043 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19044
19045 if (pMac->sme.pEXTScanIndCb)
19046 {
19047 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_START_RSP,
19048 pEventData);
19049 }
19050 else
19051 {
19052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19053 "%s:HDD callback is null", __func__);
19054 VOS_ASSERT(0);
19055 }
19056
19057error:
19058
19059 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19060 {
19061 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19062 }
19063 if (pWdaParams->wdaMsgParam != NULL)
19064 {
19065 vos_mem_free(pWdaParams->wdaMsgParam);
19066 }
19067 vos_mem_free(pWdaParams) ;
19068
19069 return;
19070}
19071
19072/*==========================================================================
19073 FUNCTION WDA_EXTScanStopRspCallback
19074
19075 DESCRIPTION
19076 API to send EXTScan Stop Response to HDD
19077
19078 PARAMETERS
19079 pEventData: Response from FW
19080 pUserData:
19081===========================================================================*/
19082void WDA_EXTScanStopRspCallback(void *pEventData, void* pUserData)
19083{
19084 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19085 tWDA_CbContext *pWDA = NULL;
19086 void *pCallbackContext;
19087 tpAniSirGlobal pMac;
19088
19089 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19090 "%s:", __func__);
19091 if (NULL == pWdaParams)
19092 {
19093 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19094 "%s: pWdaParams received NULL", __func__);
19095 VOS_ASSERT(0);
19096 return;
19097 }
19098
19099 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19100
19101 if (NULL == pWDA)
19102 {
19103 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19104 "%s: pWDA received NULL", __func__);
19105 VOS_ASSERT(0);
19106 goto error;
19107 }
19108
19109 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19110 if (NULL == pMac)
19111 {
19112 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19113 "%s:pMac is NULL", __func__);
19114 VOS_ASSERT(0);
19115 goto error;
19116 }
19117 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19118
19119 if (pMac->sme.pEXTScanIndCb)
19120 {
19121 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19122 "%s:HDD call back function called", __func__);
19123 pMac->sme.pEXTScanIndCb(pCallbackContext, WDA_EXTSCAN_STOP_RSP,
19124 pEventData);
19125 }
19126 else
19127 {
19128 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19129 "%s:HDD callback is null", __func__);
19130 VOS_ASSERT(0);
19131 }
19132
19133error:
19134
19135 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19136 {
19137 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19138 }
19139 if (pWdaParams->wdaMsgParam != NULL)
19140 {
19141 vos_mem_free(pWdaParams->wdaMsgParam);
19142 }
19143 vos_mem_free(pWdaParams) ;
19144
19145
19146 return;
19147}
19148
19149/*==========================================================================
19150 FUNCTION WDA_EXTScanGetCachedResultsRspCallback
19151
19152 DESCRIPTION
19153 API to send EXTScan Get Cached Results Response to HDD
19154
19155 PARAMETERS
19156 pEventData: Response from FW
19157 pUserData:
19158===========================================================================*/
19159void WDA_EXTScanGetCachedResultsRspCallback(void *pEventData, void* pUserData)
19160{
19161 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19162 tWDA_CbContext *pWDA = NULL;
19163 void *pCallbackContext;
19164 tpAniSirGlobal pMac;
19165
19166 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19167 "%s: ", __func__);
19168 if (NULL == pWdaParams)
19169 {
19170 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19171 "%s: pWdaParams received NULL", __func__);
19172 VOS_ASSERT(0);
19173 return;
19174 }
19175
19176 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19177
19178 if (NULL == pWDA)
19179 {
19180 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19181 "%s: pWDA received NULL", __func__);
19182 VOS_ASSERT(0);
19183 goto error;
19184 }
19185
19186 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19187 if (NULL == pMac)
19188 {
19189 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19190 "%s:pMac is NULL", __func__);
19191 VOS_ASSERT(0);
19192 goto error;
19193 }
19194
19195 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19196
19197 if (pMac->sme.pEXTScanIndCb)
19198 {
19199 pMac->sme.pEXTScanIndCb(pCallbackContext,
19200 WDA_EXTSCAN_GET_CACHED_RESULTS_RSP,
19201 pEventData);
19202 }
19203 else
19204 {
19205 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19206 "%s:HDD callback is null", __func__);
19207 VOS_ASSERT(0);
19208 }
19209
19210
19211error:
19212
19213 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19214 {
19215 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19216 }
19217 if (pWdaParams->wdaMsgParam != NULL)
19218 {
19219 vos_mem_free(pWdaParams->wdaMsgParam);
19220 }
19221 vos_mem_free(pWdaParams) ;
19222
19223 return;
19224}
19225
19226/*==========================================================================
19227 FUNCTION WDA_EXTScanGetCapabilitiesRspCallback
19228
19229 DESCRIPTION
19230 API to send EXTScan Get Capabilities Response to HDD
19231
19232 PARAMETERS
19233 pEventData: Response from FW
19234 pUserData:
19235===========================================================================*/
19236void WDA_EXTScanGetCapabilitiesRspCallback(void *pEventData, void* pUserData)
19237{
19238 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19239 tWDA_CbContext *pWDA = NULL;
19240 void *pCallbackContext;
19241 tpAniSirGlobal pMac;
19242
19243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19244 "%s:", __func__);
19245 if (NULL == pWdaParams)
19246 {
19247 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19248 "%s: pWdaParams received NULL", __func__);
19249 VOS_ASSERT(0);
19250 return;
19251 }
19252
19253 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19254
19255 if (NULL == pWDA)
19256 {
19257 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19258 "%s: pWDA received NULL", __func__);
19259 VOS_ASSERT(0);
19260 goto error;
19261 }
19262
19263 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19264 if (NULL == pMac)
19265 {
19266 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19267 "%s:pMac is NULL", __func__);
19268 VOS_ASSERT(0);
19269 goto error;
19270 }
19271
19272 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19273
19274 if (pMac->sme.pEXTScanIndCb)
19275 {
19276 pMac->sme.pEXTScanIndCb(pCallbackContext,
19277 WDA_EXTSCAN_GET_CAPABILITIES_RSP,
19278 pEventData);
19279 }
19280 else
19281 {
19282 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19283 "%s:HDD callback is null", __func__);
19284 VOS_ASSERT(0);
19285 }
19286
19287
19288error:
19289
19290 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19291 {
19292 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19293 }
19294 if (pWdaParams->wdaMsgParam != NULL)
19295 {
19296 vos_mem_free(pWdaParams->wdaMsgParam);
19297 }
19298 vos_mem_free(pWdaParams) ;
19299
19300 return;
19301}
19302
19303/*==========================================================================
19304 FUNCTION WDA_EXTScanSetBSSIDHotlistRspCallback
19305
19306 DESCRIPTION
19307 API to send EXTScan Set BSSID Hotlist Response to HDD
19308
19309 PARAMETERS
19310 pEventData: Response from FW
19311 pUserData:
19312===========================================================================*/
19313void WDA_EXTScanSetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
19314{
19315 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19316 tWDA_CbContext *pWDA = NULL;
19317 void *pCallbackContext;
19318 tpAniSirGlobal pMac;
19319
19320 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19321 "%s: ", __func__);
19322 if (NULL == pWdaParams)
19323 {
19324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19325 "%s: pWdaParams received NULL", __func__);
19326 VOS_ASSERT(0) ;
19327 return;
19328 }
19329
19330 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19331
19332 if (NULL == pWDA)
19333 {
19334 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19335 "%s: pWDA received NULL", __func__);
19336 VOS_ASSERT(0);
19337 goto error;
19338 }
19339
19340 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19341 if (NULL == pMac)
19342 {
19343 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19344 "%s:pMac is NULL", __func__);
19345 VOS_ASSERT(0);
19346 goto error;
19347 }
19348
19349 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19350
19351 if (pMac->sme.pEXTScanIndCb)
19352 {
19353 pMac->sme.pEXTScanIndCb(pCallbackContext,
19354 WDA_EXTSCAN_SET_BSSID_HOTLIST_RSP,
19355 pEventData);
19356 }
19357 else
19358 {
19359 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19360 "%s:HDD callback is null", __func__);
19361 VOS_ASSERT(0);
19362 }
19363
19364
19365error:
19366
19367 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19368 {
19369 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19370 }
19371 if (pWdaParams->wdaMsgParam != NULL)
19372 {
19373 vos_mem_free(pWdaParams->wdaMsgParam);
19374 }
19375 vos_mem_free(pWdaParams) ;
19376
19377 return;
19378}
19379
19380/*==========================================================================
19381 FUNCTION WDA_EXTScanResetBSSIDHotlistRspCallback
19382
19383 DESCRIPTION
19384 API to send EXTScan ReSet BSSID Hotlist Response to HDD
19385
19386 PARAMETERS
19387 pEventData: Response from FW
19388 pUserData:
19389===========================================================================*/
19390void WDA_EXTScanResetBSSIDHotlistRspCallback(void *pEventData, void* pUserData)
19391{
19392 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19393 tWDA_CbContext *pWDA = NULL;
19394 void *pCallbackContext;
19395 tpAniSirGlobal pMac;
19396
19397 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19398 "%s:", __func__);
19399 if (NULL == pWdaParams)
19400 {
19401 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19402 "%s: pWdaParams received NULL", __func__);
19403 VOS_ASSERT(0) ;
19404 return;
19405 }
19406
19407 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19408
19409 if (NULL == pWDA)
19410 {
19411 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19412 "%s: pWDA received NULL", __func__);
19413 VOS_ASSERT(0);
19414 goto error;
19415 }
19416
19417 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19418 if (NULL == pMac)
19419 {
19420 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19421 "%s:pMac is NULL", __func__);
19422 VOS_ASSERT(0);
19423 goto error;
19424 }
19425
19426 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19427
19428 if (pMac->sme.pEXTScanIndCb)
19429 {
19430 pMac->sme.pEXTScanIndCb(pCallbackContext,
19431 WDA_EXTSCAN_RESET_BSSID_HOTLIST_RSP,
19432 pEventData);
19433 }
19434 else
19435 {
19436 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19437 "%s:HDD callback is null", __func__);
19438 VOS_ASSERT(0);
19439 }
19440
19441
19442error:
19443
19444 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19445 {
19446 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19447 }
19448 if (pWdaParams->wdaMsgParam != NULL)
19449 {
19450 vos_mem_free(pWdaParams->wdaMsgParam);
19451 }
19452 vos_mem_free(pWdaParams) ;
19453
19454 return;
19455}
19456
19457/*==========================================================================
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]19458 FUNCTION WDA_EXTScanSetSSIDHotlistRspCallback
19459
19460 DESCRIPTION
19461 API to send EXTScan Set SSID Hotlist Response to HDD
19462
19463 PARAMETERS
19464 pEventData: Response from FW
19465 pUserData:
19466===========================================================================*/
19467void WDA_EXTScanSetSSIDHotlistRspCallback(void *pEventData, void* pUserData)
19468{
19469 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19470 tWDA_CbContext *pWDA = NULL;
19471 void *pCallbackContext;
19472 tpAniSirGlobal pMac;
19473
19474 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19475 "%s: ", __func__);
19476 if (NULL == pWdaParams)
19477 {
19478 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19479 "%s: pWdaParams received NULL", __func__);
19480 VOS_ASSERT(0) ;
19481 return;
19482 }
19483
19484 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19485
19486 if (NULL == pWDA)
19487 {
19488 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19489 "%s: pWDA received NULL", __func__);
19490 VOS_ASSERT(0);
19491 goto error;
19492 }
19493
19494 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19495 if (NULL == pMac)
19496 {
19497 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19498 "%s:pMac is NULL", __func__);
19499 VOS_ASSERT(0);
19500 goto error;
19501 }
19502
19503 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19504
19505 if (pMac->sme.pEXTScanIndCb)
19506 {
19507 pMac->sme.pEXTScanIndCb(pCallbackContext,
19508 WDA_EXTSCAN_SET_SSID_HOTLIST_RSP,
19509 pEventData);
19510 }
19511 else
19512 {
19513 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19514 "%s:HDD callback is null", __func__);
19515 VOS_ASSERT(0);
19516 }
19517
19518
19519error:
19520
19521 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19522 {
19523 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19524 }
19525 if (pWdaParams->wdaMsgParam != NULL)
19526 {
19527 vos_mem_free(pWdaParams->wdaMsgParam);
19528 }
19529 vos_mem_free(pWdaParams) ;
19530
19531 return;
19532}
19533
19534/*==========================================================================
19535 FUNCTION WDA_EXTScanResetSSIDHotlistRspCallback
19536
19537 DESCRIPTION
19538 API to send EXTScan ReSet SSID Hotlist Response to HDD
19539
19540 PARAMETERS
19541 pEventData: Response from FW
19542 pUserData:
19543===========================================================================*/
19544void WDA_EXTScanResetSSIDHotlistRspCallback(void *pEventData, void* pUserData)
19545{
19546 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
19547 tWDA_CbContext *pWDA = NULL;
19548 void *pCallbackContext;
19549 tpAniSirGlobal pMac;
19550
19551 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19552 "%s:", __func__);
19553 if (NULL == pWdaParams)
19554 {
19555 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19556 "%s: pWdaParams received NULL", __func__);
19557 VOS_ASSERT(0) ;
19558 return;
19559 }
19560
19561 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
19562
19563 if (NULL == pWDA)
19564 {
19565 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19566 "%s: pWDA received NULL", __func__);
19567 VOS_ASSERT(0);
19568 goto error;
19569 }
19570
19571 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
19572 if (NULL == pMac)
19573 {
19574 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19575 "%s:pMac is NULL", __func__);
19576 VOS_ASSERT(0);
19577 goto error;
19578 }
19579
19580 pCallbackContext = pMac->sme.pEXTScanCallbackContext;
19581
19582 if (pMac->sme.pEXTScanIndCb)
19583 {
19584 pMac->sme.pEXTScanIndCb(pCallbackContext,
19585 WDA_EXTSCAN_RESET_SSID_HOTLIST_RSP,
19586 pEventData);
19587 }
19588 else
19589 {
19590 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19591 "%s:HDD callback is null", __func__);
19592 VOS_ASSERT(0);
19593 }
19594
19595
19596error:
19597
19598 if (pWdaParams->wdaWdiApiMsgParam != NULL)
19599 {
19600 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
19601 }
19602 if (pWdaParams->wdaMsgParam != NULL)
19603 {
19604 vos_mem_free(pWdaParams->wdaMsgParam);
19605 }
19606 vos_mem_free(pWdaParams) ;
19607
19608 return;
19609}
19610
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]19611/*==========================================================================
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]19612 FUNCTION WDA_ProcessEXTScanStartReq
19613
19614 DESCRIPTION
19615 API to send EXTScan Start Request to WDI
19616
19617 PARAMETERS
19618 pWDA: Pointer to WDA context
19619 wdaRequest: Pointer to EXTScan req parameters
19620===========================================================================*/
19621VOS_STATUS WDA_ProcessEXTScanStartReq(tWDA_CbContext *pWDA,
19622 tSirEXTScanStartReqParams *wdaRequest)
19623{
19624 WDI_Status status = WDI_STATUS_SUCCESS;
19625 tWDA_ReqParams *pWdaParams;
19626
19627 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19628 "%s: ", __func__);
19629 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19630 if (NULL == pWdaParams)
19631 {
19632 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19633 "%s: VOS MEM Alloc Failure", __func__);
19634 VOS_ASSERT(0);
19635 return VOS_STATUS_E_NOMEM;
19636 }
19637 pWdaParams->pWdaContext = pWDA;
19638 pWdaParams->wdaMsgParam = wdaRequest;
19639 pWdaParams->wdaWdiApiMsgParam = NULL;
19640
19641 status = WDI_EXTScanStartReq((void *)wdaRequest,
19642 (WDI_EXTScanStartRspCb)WDA_EXTScanStartRspCallback,
19643 (void *)pWdaParams);
19644 if (IS_WDI_STATUS_FAILURE(status))
19645 {
19646 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19647 "Failure to request. Free all the memory " );
19648 vos_mem_free(pWdaParams->wdaMsgParam);
19649 vos_mem_free(pWdaParams);
19650 }
19651 return CONVERT_WDI2VOS_STATUS(status);
19652}
19653
19654/*==========================================================================
19655 FUNCTION WDA_ProcessEXTScanStopReq
19656
19657 DESCRIPTION
19658 API to send EXTScan Start Request to WDI
19659
19660 PARAMETERS
19661 pWDA: Pointer to WDA context
19662 wdaRequest: Pointer to EXTScan req parameters
19663===========================================================================*/
19664VOS_STATUS WDA_ProcessEXTScanStopReq(tWDA_CbContext *pWDA,
19665 tSirEXTScanStopReqParams *wdaRequest)
19666{
19667 WDI_Status status = WDI_STATUS_SUCCESS;
19668 tWDA_ReqParams *pWdaParams;
19669
19670 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19671 "%s:", __func__);
19672 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19673 if (NULL == pWdaParams)
19674 {
19675 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19676 "%s: VOS MEM Alloc Failure", __func__);
19677 VOS_ASSERT(0);
19678 return VOS_STATUS_E_NOMEM;
19679 }
19680 pWdaParams->pWdaContext = pWDA;
19681 pWdaParams->wdaMsgParam = wdaRequest;
19682 pWdaParams->wdaWdiApiMsgParam = NULL;
19683
19684 status = WDI_EXTScanStopReq((void *)wdaRequest,
19685 (WDI_EXTScanStopRspCb)WDA_EXTScanStopRspCallback,
19686 (void *)pWdaParams);
19687 if (IS_WDI_STATUS_FAILURE(status))
19688 {
19689 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19690 "Failure to request. Free all the memory " );
19691 vos_mem_free(pWdaParams->wdaMsgParam);
19692 vos_mem_free(pWdaParams);
19693 }
19694 return CONVERT_WDI2VOS_STATUS(status);
19695}
19696
19697/*==========================================================================
19698 FUNCTION WDA_ProcessEXTScanGetCachedResultsReq
19699
19700 DESCRIPTION
19701 API to send EXTScan Get Cached Results Request to WDI
19702
19703 PARAMETERS
19704 pWDA: Pointer to WDA context
19705 wdaRequest: Pointer to EXTScan req parameters
19706===========================================================================*/
19707VOS_STATUS WDA_ProcessEXTScanGetCachedResultsReq(tWDA_CbContext *pWDA,
19708 tSirEXTScanGetCachedResultsReqParams *wdaRequest)
19709{
19710 WDI_Status status = WDI_STATUS_SUCCESS;
19711 tWDA_ReqParams *pWdaParams;
19712
19713 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19714 "%s: ", __func__);
19715 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19716 if (NULL == pWdaParams)
19717 {
19718 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19719 "%s: VOS MEM Alloc Failure", __func__);
19720 VOS_ASSERT(0);
19721 return VOS_STATUS_E_NOMEM;
19722 }
19723 pWdaParams->pWdaContext = pWDA;
19724 pWdaParams->wdaMsgParam = wdaRequest;
19725 pWdaParams->wdaWdiApiMsgParam = NULL;
19726
19727 status = WDI_EXTScanGetCachedResultsReq((void *)wdaRequest,
19728 (WDI_EXTScanGetCachedResultsRspCb)WDA_EXTScanGetCachedResultsRspCallback,
19729 (void *)pWdaParams);
19730 if (IS_WDI_STATUS_FAILURE(status))
19731 {
19732 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19733 "Failure to request. Free all the memory " );
19734 vos_mem_free(pWdaParams->wdaMsgParam);
19735 vos_mem_free(pWdaParams);
19736 }
19737 return CONVERT_WDI2VOS_STATUS(status);
19738}
19739
19740/*==========================================================================
19741 FUNCTION WDA_ProcessEXTScanGetCapabilitiesReq
19742
19743 DESCRIPTION
19744 API to send EXTScan Get Capabilities Request to WDI
19745
19746 PARAMETERS
19747 pWDA: Pointer to WDA context
19748 wdaRequest: Pointer to EXTScan req parameters
19749===========================================================================*/
19750VOS_STATUS WDA_ProcessEXTScanGetCapabilitiesReq(tWDA_CbContext *pWDA,
19751 tSirGetEXTScanCapabilitiesReqParams *wdaRequest)
19752{
19753 WDI_Status status = WDI_STATUS_SUCCESS;
19754 tWDA_ReqParams *pWdaParams;
19755
19756 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19757 "%s:", __func__);
19758 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19759 if (NULL == pWdaParams)
19760 {
19761 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19762 "%s: VOS MEM Alloc Failure", __func__);
19763 VOS_ASSERT(0);
19764 return VOS_STATUS_E_NOMEM;
19765 }
19766 pWdaParams->pWdaContext = pWDA;
19767 pWdaParams->wdaMsgParam = wdaRequest;
19768 pWdaParams->wdaWdiApiMsgParam = NULL;
19769
19770 status = WDI_EXTScanGetCapabilitiesReq((void *)wdaRequest,
19771 (WDI_EXTScanGetCapabilitiesRspCb)WDA_EXTScanGetCapabilitiesRspCallback,
19772 (void *)pWdaParams);
19773 if (IS_WDI_STATUS_FAILURE(status))
19774 {
19775 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19776 "Failure to request. Free all the memory " );
19777 vos_mem_free(pWdaParams->wdaMsgParam);
19778 vos_mem_free(pWdaParams);
19779 }
19780 return CONVERT_WDI2VOS_STATUS(status);
19781}
19782
19783/*==========================================================================
19784 FUNCTION WDA_ProcessEXTScanSetBSSIDHotlistReq
19785
19786 DESCRIPTION
19787 API to send Set BSSID Hotlist Request to WDI
19788
19789 PARAMETERS
19790 pWDA: Pointer to WDA context
19791 wdaRequest: Pointer to EXTScan req parameters
19792===========================================================================*/
19793VOS_STATUS WDA_ProcessEXTScanSetBSSIDHotlistReq(tWDA_CbContext *pWDA,
19794 tSirEXTScanSetBssidHotListReqParams *wdaRequest)
19795{
19796 WDI_Status status = WDI_STATUS_SUCCESS;
19797 tWDA_ReqParams *pWdaParams;
19798
19799 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19800 "%s: ", __func__);
19801 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19802 if (NULL == pWdaParams)
19803 {
19804 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19805 "%s: VOS MEM Alloc Failure", __func__);
19806 VOS_ASSERT(0);
19807 return VOS_STATUS_E_NOMEM;
19808 }
19809 pWdaParams->pWdaContext = pWDA;
19810 pWdaParams->wdaMsgParam = wdaRequest;
19811 pWdaParams->wdaWdiApiMsgParam = NULL;
19812
19813 status = WDI_EXTScanSetBSSIDHotlistReq((void *)wdaRequest,
19814 (WDI_EXTScanSetBSSIDHotlistRspCb)WDA_EXTScanSetBSSIDHotlistRspCallback,
19815 (void *)pWdaParams);
19816 if (IS_WDI_STATUS_FAILURE(status))
19817 {
19818 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19819 "Failure to request. Free all the memory " );
19820 vos_mem_free(pWdaParams->wdaMsgParam);
19821 vos_mem_free(pWdaParams);
19822 }
19823 return CONVERT_WDI2VOS_STATUS(status);
19824}
19825
19826/*==========================================================================
19827 FUNCTION WDA_ProcessEXTScanReSetBSSIDHotlistReq
19828
19829 DESCRIPTION
19830 API to send Reset BSSID Hotlist Request to WDI
19831
19832 PARAMETERS
19833 pWDA: Pointer to WDA context
19834 wdaRequest: Pointer to EXTScan req parameters
19835===========================================================================*/
19836VOS_STATUS WDA_ProcessEXTScanResetBSSIDHotlistReq(tWDA_CbContext *pWDA,
19837 tSirEXTScanResetBssidHotlistReqParams *wdaRequest)
19838{
19839 WDI_Status status = WDI_STATUS_SUCCESS;
19840 tWDA_ReqParams *pWdaParams;
19841
19842 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19843 "%s:", __func__);
19844 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19845 if (NULL == pWdaParams)
19846 {
19847 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19848 "%s: VOS MEM Alloc Failure", __func__);
19849 VOS_ASSERT(0);
19850 return VOS_STATUS_E_NOMEM;
19851 }
19852 pWdaParams->pWdaContext = pWDA;
19853 pWdaParams->wdaMsgParam = wdaRequest;
19854 pWdaParams->wdaWdiApiMsgParam = NULL;
19855
19856 status = WDI_EXTScanResetBSSIDHotlistReq((void *)wdaRequest,
19857 (WDI_EXTScanResetBSSIDHotlistRspCb)WDA_EXTScanResetBSSIDHotlistRspCallback,
19858 (void *)pWdaParams);
19859 if (IS_WDI_STATUS_FAILURE(status))
19860 {
19861 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19862 "Failure to request. Free all the memory " );
19863 vos_mem_free(pWdaParams->wdaMsgParam);
19864 vos_mem_free(pWdaParams);
19865 }
19866 return CONVERT_WDI2VOS_STATUS(status);
19867}
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]19868
19869/*==========================================================================
19870 FUNCTION WDA_ProcessEXTScanSetSSIDHotlistReq
19871
19872 DESCRIPTION
19873 API to send Set SSID Hotlist Request to WDI
19874
19875 PARAMETERS
19876 pWDA: Pointer to WDA context
19877 wdaRequest: Pointer to EXTScan req parameters
19878===========================================================================*/
19879VOS_STATUS WDA_ProcessEXTScanSetSSIDHotlistReq(tWDA_CbContext *pWDA,
19880 tSirEXTScanSetSsidHotListReqParams *wdaRequest)
19881{
19882 WDI_Status status = WDI_STATUS_SUCCESS;
19883 tWDA_ReqParams *pWdaParams;
19884
19885 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19886 "%s: ", __func__);
19887 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19888 if (NULL == pWdaParams)
19889 {
19890 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19891 "%s: VOS MEM Alloc Failure", __func__);
19892 VOS_ASSERT(0);
19893 return VOS_STATUS_E_NOMEM;
19894 }
19895 pWdaParams->pWdaContext = pWDA;
19896 pWdaParams->wdaMsgParam = wdaRequest;
19897 pWdaParams->wdaWdiApiMsgParam = NULL;
19898
19899 status = WDI_EXTScanSetSSIDHotlistReq((void *)wdaRequest,
19900 (WDI_EXTScanSetSSIDHotlistRspCb)WDA_EXTScanSetSSIDHotlistRspCallback,
19901 (void *)pWdaParams);
19902 if (IS_WDI_STATUS_FAILURE(status))
19903 {
19904 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19905 "Failure to request. Free all the memory " );
19906 vos_mem_free(pWdaParams->wdaMsgParam);
19907 vos_mem_free(pWdaParams);
19908 }
19909 return CONVERT_WDI2VOS_STATUS(status);
19910}
19911
19912/*==========================================================================
19913 FUNCTION WDA_ProcessEXTScanReSetSSIDHotlistReq
19914
19915 DESCRIPTION
19916 API to send Reset SSID Hotlist Request to WDI
19917
19918 PARAMETERS
19919 pWDA: Pointer to WDA context
19920 wdaRequest: Pointer to EXTScan req parameters
19921===========================================================================*/
19922VOS_STATUS WDA_ProcessEXTScanResetSSIDHotlistReq(tWDA_CbContext *pWDA,
19923 tSirEXTScanResetSsidHotlistReqParams *wdaRequest)
19924{
19925 WDI_Status status = WDI_STATUS_SUCCESS;
19926 tWDA_ReqParams *pWdaParams;
19927
19928 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19929 "%s:", __func__);
19930 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
19931 if (NULL == pWdaParams)
19932 {
19933 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19934 "%s: VOS MEM Alloc Failure", __func__);
19935 VOS_ASSERT(0);
19936 return VOS_STATUS_E_NOMEM;
19937 }
19938 pWdaParams->pWdaContext = pWDA;
19939 pWdaParams->wdaMsgParam = wdaRequest;
19940 pWdaParams->wdaWdiApiMsgParam = NULL;
19941
19942 status = WDI_EXTScanResetSSIDHotlistReq((void *)wdaRequest,
19943 (WDI_EXTScanResetSSIDHotlistRspCb)WDA_EXTScanResetSSIDHotlistRspCallback,
19944 (void *)pWdaParams);
19945 if (IS_WDI_STATUS_FAILURE(status))
19946 {
19947 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19948 "Failure to request. Free all the memory " );
19949 vos_mem_free(pWdaParams->wdaMsgParam);
19950 vos_mem_free(pWdaParams);
19951 }
19952 return CONVERT_WDI2VOS_STATUS(status);
19953}
19954
Padma, Santhosh Kumarc1f7f052015-08-26 12:29:01 +0530[diff] [blame]19955/*==========================================================================
19956 FUNCTION WDA_ProcessHighPriorityDataInfoInd
19957
19958 DESCRIPTION
19959 API to send Reset SSID Hotlist Request to WDI
19960
19961 PARAMETERS
19962 pWDA: Pointer to WDA context
19963 wdaRequest: Pointer to EXTScan req parameters
19964===========================================================================*/
19965VOS_STATUS WDA_ProcessHighPriorityDataInfoInd(tWDA_CbContext *pWDA,
19966 tSirHighPriorityDataInfoInd *wdaRequest)
19967{
19968 WDI_Status status = WDI_STATUS_SUCCESS;
19969
19970 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19971 "%s:", __func__);
19972
19973 status = WDI_HighPriorityDataInfoInd((void *)wdaRequest);
19974 if (WDI_STATUS_PENDING == status)
19975 {
19976 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
19977 FL("pending status received "));
19978 }
19979 else if (WDI_STATUS_SUCCESS_SYNC != status)
19980 {
19981 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
19982 FL("Failure status %d"), status);
19983 }
19984 return CONVERT_WDI2VOS_STATUS(status);
19985}
Padma, Santhosh Kumar9acee012015-08-21 19:58:01 +0530[diff] [blame]19986
Dino Mycle41bdc942014-06-10 11:30:24 +0530[diff] [blame]19987#endif /* WLAN_FEATURE_EXTSCAN */
19988
Sunil Duttbd736ed2014-05-26 21:19:41 +0530[diff] [blame]19989#ifdef WLAN_FEATURE_LINK_LAYER_STATS
19990
19991/*==========================================================================
19992 FUNCTION WDA_LLStatsSetRspCallback
19993
19994 DESCRIPTION
19995 API to process set link layer statistics response from FW
19996
19997 PARAMETERS
19998 pRsp: Pointer to set link layer statistics response
19999 pUserData: Pointer to user data
20000
20001 RETURN VALUE
20002 NONE
20003
20004===========================================================================*/
20005void WDA_LLStatsSetRspCallback(void *pEventData, void* pUserData)
20006{
20007 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
20008
20009
20010 if (NULL == pWdaParams)
20011 {
20012 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20013 "%s: pWdaParams received NULL", __func__);
20014 VOS_ASSERT(0) ;
20015 return ;
20016 }
20017
20018 /* Do not need to send notification to upper layer
20019 * Just free allocated resources */
20020 if (pWdaParams->wdaWdiApiMsgParam != NULL)
20021 {
20022 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
20023 }
20024 if (pWdaParams->wdaMsgParam != NULL)
20025 {
20026 vos_mem_free(pWdaParams->wdaMsgParam);
20027 }
20028 vos_mem_free(pWdaParams) ;
20029
20030 return;
20031}
20032
20033/*==========================================================================
20034 FUNCTION WDA_ProcessLLStatsSetReq
20035
20036 DESCRIPTION
20037 API to send Set Link Layer Stats request to WDI
20038
20039 PARAMETERS
20040 pWDA: Pointer to WDA context
20041 wdaRequest: Pointer to set Link Layer Stats req parameters
20042===========================================================================*/
20043VOS_STATUS WDA_ProcessLLStatsSetReq(tWDA_CbContext *pWDA,
20044 tSirLLStatsSetReq *wdaRequest)
20045{
20046 WDI_Status status = WDI_STATUS_SUCCESS;
20047 tWDA_ReqParams *pWdaParams;
20048
20049 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
20050 if (NULL == pWdaParams)
20051 {
20052 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20053 "%s: VOS MEM Alloc Failure", __func__);
20054 VOS_ASSERT(0);
20055 return VOS_STATUS_E_NOMEM;
20056 }
20057 pWdaParams->pWdaContext = pWDA;
20058 pWdaParams->wdaMsgParam = wdaRequest;
20059 pWdaParams->wdaWdiApiMsgParam = NULL;
20060
20061 status = WDI_LLStatsSetReq((void *)wdaRequest,
20062 (WDI_LLStatsSetRspCb)WDA_LLStatsSetRspCallback,
20063 (void *)pWdaParams);
20064 if (IS_WDI_STATUS_FAILURE(status))
20065 {
20066 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20067 "Failure to request. Free all the memory " );
20068 vos_mem_free(pWdaParams->wdaMsgParam);
20069 vos_mem_free(pWdaParams);
20070 }
20071 return CONVERT_WDI2VOS_STATUS(status);
20072}
20073
20074/*==========================================================================
20075 FUNCTION WDA_LLStatsGetRspCallback
20076
20077 DESCRIPTION
20078 API to process get link layer statistics response from FW
20079
20080 PARAMETERS
20081 pRsp: Pointer to get link layer statistics response
20082 pUserData: Pointer to user data
20083
20084 RETURN VALUE
20085 NONE
20086
20087===========================================================================*/
20088void WDA_LLStatsGetRspCallback(void *pEventData, void* pUserData)
20089{
20090 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
20091
20092 if (NULL == pWdaParams)
20093 {
20094 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20095 "%s: pWdaParams received NULL", __func__);
20096 VOS_ASSERT(0) ;
20097 return ;
20098 }
20099
20100 /* Do not need to send notification to upper layer
20101 * Just free allocated resources */
20102 if (pWdaParams->wdaWdiApiMsgParam != NULL)
20103 {
20104 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
20105 }
20106 if (pWdaParams->wdaMsgParam != NULL)
20107 {
20108 vos_mem_free(pWdaParams->wdaMsgParam);
20109 }
20110 vos_mem_free(pWdaParams) ;
20111
20112 return;
20113}
20114
20115/*==========================================================================
20116 FUNCTION WDA_ProcessLLStatsGetReq
20117
20118 DESCRIPTION
20119 API to send Get Link Layer Stats request to WDI
20120
20121 PARAMETERS
20122 pWDA: Pointer to WDA context
20123 wdaRequest: Pointer to get Link Layer Stats req parameters
20124===========================================================================*/
20125VOS_STATUS WDA_ProcessLLStatsGetReq(tWDA_CbContext *pWDA,
20126 tSirLLStatsGetReq *wdaRequest)
20127{
20128 WDI_Status status = WDI_STATUS_SUCCESS;
20129 tWDA_ReqParams *pWdaParams;
20130
20131 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
20132 if (NULL == pWdaParams)
20133 {
20134 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20135 "%s: VOS MEM Alloc Failure", __func__);
20136 VOS_ASSERT(0);
20137 return VOS_STATUS_E_NOMEM;
20138 }
20139 pWdaParams->pWdaContext = pWDA;
20140 pWdaParams->wdaMsgParam = wdaRequest;
20141 pWdaParams->wdaWdiApiMsgParam = NULL;
20142
20143 status = WDI_LLStatsGetReq((void *) wdaRequest,
20144 (WDI_LLStatsGetRspCb)WDA_LLStatsGetRspCallback,
20145 (void *)pWdaParams);
20146 if (IS_WDI_STATUS_FAILURE(status))
20147 {
20148 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20149 "Failure to request. Free all the memory " );
20150 vos_mem_free(pWdaParams->wdaMsgParam);
20151 vos_mem_free(pWdaParams);
20152 }
20153 return CONVERT_WDI2VOS_STATUS(status);
20154}
20155
20156/*==========================================================================
20157 FUNCTION WDA_LLStatsClearRspCallback
20158
20159 DESCRIPTION
20160 API to process clear link layer statistics response from FW
20161
20162 PARAMETERS
20163 pRsp: Pointer to clear link layer statistics response
20164 pUserData: Pointer to user data
20165
20166 RETURN VALUE
20167 NONE
20168
20169===========================================================================*/
20170void WDA_LLStatsClearRspCallback(void *pEventData, void* pUserData)
20171{
20172 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
20173
20174
20175 if (NULL == pWdaParams)
20176 {
20177 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20178 "%s: pWdaParams received NULL", __func__);
20179 VOS_ASSERT(0) ;
20180 return ;
20181 }
20182 /* Do not need to send notification to upper layer
20183 * Just free allocated resources */
20184 if (pWdaParams->wdaWdiApiMsgParam != NULL)
20185 {
20186 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
20187 }
20188 if (pWdaParams->wdaMsgParam != NULL)
20189 {
20190 vos_mem_free(pWdaParams->wdaMsgParam);
20191 }
20192 vos_mem_free(pWdaParams) ;
20193 return;
20194}
20195
20196/*==========================================================================
20197 FUNCTION WDA_ProcessLLStatsClearReq
20198
20199 DESCRIPTION
20200 API to send Clear Link Layer Stats request to WDI
20201
20202 PARAMETERS
20203 pWDA: Pointer to WDA context
20204 wdaRequest: Pointer to earLink Layer Stats req
20205===========================================================================*/
20206VOS_STATUS WDA_ProcessLLStatsClearReq(tWDA_CbContext *pWDA,
20207 tSirLLStatsClearReq *wdaRequest)
20208{
20209 WDI_Status status = WDI_STATUS_SUCCESS;
20210 tWDA_ReqParams *pWdaParams;
20211
20212 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
20213 if (NULL == pWdaParams)
20214 {
20215 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20216 "%s: VOS MEM Alloc Failure", __func__);
20217 VOS_ASSERT(0);
20218 return VOS_STATUS_E_NOMEM;
20219 }
20220 pWdaParams->pWdaContext = pWDA;
20221 pWdaParams->wdaMsgParam = wdaRequest;
20222 pWdaParams->wdaWdiApiMsgParam = NULL;
20223
20224 status = WDI_LLStatsClearReq((void *) wdaRequest,
20225 (WDI_LLStatsClearRspCb)WDA_LLStatsClearRspCallback,
20226 (void *)pWdaParams);
20227 if (IS_WDI_STATUS_FAILURE(status))
20228 {
20229 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20230 "Failure to request. Free all the memory " );
20231 vos_mem_free(pWdaParams->wdaMsgParam);
20232 vos_mem_free(pWdaParams);
20233 }
20234 return CONVERT_WDI2VOS_STATUS(status);
20235}
20236
20237#endif /* WLAN_FEATURE_LINK_LAYER_STATS */
Abhishek Singh85b74712014-10-08 11:38:19 +0530[diff] [blame]20238
Abhishek Singh85b74712014-10-08 11:38:19 +0530[diff] [blame]20239void WDA_FWStatsGetRspCallback(WDI_Status status,void *fwStatsResp,void *pUserData)
20240{
20241 tSirFWStatsInfo *fwStatsinfo = (tSirFWStatsInfo *)pUserData;
20242
20243 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20244 "<------ %s " ,__func__);
20245 if (NULL == fwStatsinfo)
20246 {
20247 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20248 "%s: pWdaParams received NULL", __func__);
20249 VOS_ASSERT(0);
20250 return;
20251 }
20252
20253 if(fwStatsinfo->callback)
20254 fwStatsinfo->callback(status, fwStatsResp, fwStatsinfo->data);
20255
20256 vos_mem_free(pUserData);
20257 return;
20258}
20259
20260
20261v_VOID_t WDA_ProcessFWStatsGetReq(tWDA_CbContext *pWDA,
20262 tSirFWStatsGetReq *pData)
20263{
20264
20265 WDI_Status wdiStatus;
20266 tSirFWStatsInfo *fwStatsinfo;
20267
20268 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20269 "------> %s" , __func__);
20270
20271 fwStatsinfo =
20272 (tSirFWStatsInfo *)vos_mem_malloc(sizeof(tSirFWStatsInfo));
20273 if (NULL == fwStatsinfo)
20274 {
20275 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20276 "%s: VOS MEM Alloc Failure", __func__);
20277 VOS_ASSERT(0);
20278 vos_mem_free(pData);
20279 return;
20280 }
20281
20282 fwStatsinfo->callback = (tSirFWStatsCallback)(pData->callback);
20283 fwStatsinfo->data = pData->data;
20284
20285 wdiStatus = WDI_FWStatsGetReq(fwStatsinfo,
20286 WDA_FWStatsGetRspCallback,
20287 pData->stats);
20288 if (WDI_STATUS_PENDING == wdiStatus)
20289 {
20290 VOS_TRACE(VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20291 "Pending received for %s:%d ", __func__, __LINE__);
20292 }
20293 else if (WDI_STATUS_SUCCESS != wdiStatus)
20294 {
20295 if (fwStatsinfo->callback)
20296 {
20297 fwStatsinfo->callback(WDI_STATUS_E_FAILURE, NULL ,fwStatsinfo->data);
20298 }
20299 vos_mem_free(fwStatsinfo);
20300 }
20301 vos_mem_free(pData);
20302}
20303
Srinivas Dasari4dae48f2014-11-26 21:14:16 +0530[diff] [blame]20304/*==========================================================================
20305 FUNCTION WDA_EncryptMsgRspCallback
20306
20307 DESCRIPTION
20308 API to send Encrypt message response to HDD
20309
20310 PARAMETERS
20311 pEventData: Response from FW
20312 pUserData: Data sent to firmware as part of request
20313===========================================================================*/
20314void WDA_EncryptMsgRspCallback(WDI_Status status, void *pEventData,
20315 void* pUserData)
20316{
20317 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
20318 tWDA_CbContext *pWDA = NULL;
20319 tpAniSirGlobal pMac;
20320 vos_msg_t vosMsg;
20321 tpSirEncryptedDataRspParams pEncRspParams;
20322 tpSetEncryptedDataRspParams pEncryptedDataRsp;
20323
20324 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20325 FL("%s:"), __func__);
20326 if (NULL == pWdaParams)
20327 {
20328 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20329 FL("%s: pWdaParams received NULL"), __func__);
20330 VOS_ASSERT(0);
20331 return;
20332 }
20333
20334 pWDA = (tWDA_CbContext *) pWdaParams->pWdaContext;
20335
20336 if (NULL == pWDA)
20337 {
20338 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20339 FL("%s: pWDA received NULL"), __func__);
20340 VOS_ASSERT(0);
20341 goto error;
20342 }
20343
20344 pMac = (tpAniSirGlobal )VOS_GET_MAC_CTXT(pWDA->pVosContext);
20345 if (NULL == pMac)
20346 {
20347 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20348 FL("%s:pMac is NULL"), __func__);
20349 VOS_ASSERT(0);
20350 goto error;
20351 }
20352
20353 pEncryptedDataRsp = (tpSetEncryptedDataRspParams) pEventData;
20354
20355 pEncRspParams = vos_mem_malloc(sizeof(tSirEncryptedDataRspParams));
20356 if (NULL == pEncRspParams)
20357 {
20358 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20359 FL("%s: VOS MEM Alloc Failure"), __func__);
20360 VOS_ASSERT(0);
20361 goto error;
20362 }
20363
20364 /* Message Header */
20365 pEncRspParams->mesgType = eWNI_SME_ENCRYPT_MSG_RSP;
20366 pEncRspParams->mesgLen = sizeof(tSirEncryptedDataRspParams);
20367 pEncRspParams->encryptedDataRsp.encryptedPayload.length =
20368 pEncryptedDataRsp->encryptedPayload.length;
20369 vos_mem_copy(pEncRspParams->encryptedDataRsp.encryptedPayload.data,
20370 pEncryptedDataRsp->encryptedPayload.data,
20371 pEncryptedDataRsp->encryptedPayload.length);
20372
20373 /* VOS message wrapper */
20374 vosMsg.type = eWNI_SME_ENCRYPT_MSG_RSP;
20375 vosMsg.bodyptr = (void *)pEncRspParams;
20376 vosMsg.bodyval = 0;
20377
20378 if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MQ_ID_SME, (vos_msg_t*)&vosMsg))
20379 {
20380 /* free the mem */
20381 vos_mem_free((v_VOID_t *) pEncRspParams);
20382 }
20383
20384error:
20385
20386 if (pWdaParams->wdaWdiApiMsgParam != NULL)
20387 {
20388 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
20389 }
20390 if (pWdaParams->wdaMsgParam != NULL)
20391 {
20392 vos_mem_free(pWdaParams->wdaMsgParam);
20393 }
20394 vos_mem_free(pWdaParams) ;
20395
20396 return;
20397}
20398/*==========================================================================
20399 FUNCTION WDA_ProcessEncryptMsgReq
20400
20401 DESCRIPTION
20402 API to send Encrypt message Request to WDI
20403
20404 PARAMETERS
20405 pWDA: Pointer to WDA context
20406 wdaRequest: Pointer to Encrypt_msg req parameters
20407===========================================================================*/
20408VOS_STATUS WDA_ProcessEncryptMsgReq(tWDA_CbContext *pWDA,
20409 u8 *wdaRequest)
20410{
20411 WDI_Status status = WDI_STATUS_SUCCESS;
20412 tWDA_ReqParams *pWdaParams;
20413
20414 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20415 FL("%s: "), __func__);
20416 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
20417 if (NULL == pWdaParams)
20418 {
20419 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20420 FL("%s: VOS MEM Alloc Failure"), __func__);
20421 VOS_ASSERT(0);
20422 return VOS_STATUS_E_NOMEM;
20423 }
20424 pWdaParams->pWdaContext = pWDA;
20425 pWdaParams->wdaMsgParam = wdaRequest;
20426 pWdaParams->wdaWdiApiMsgParam = NULL;
20427
20428 status = WDI_EncryptMsgReq((void *)wdaRequest,
20429 (WDI_EncryptMsgRspCb)WDA_EncryptMsgRspCallback,
20430 (void *)pWdaParams);
20431 if (IS_WDI_STATUS_FAILURE(status))
20432 {
20433 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20434 FL("Failure to request. Free all the memory " ));
20435 vos_mem_free(pWdaParams->wdaMsgParam);
20436 vos_mem_free(pWdaParams);
20437 }
20438 return CONVERT_WDI2VOS_STATUS(status);
20439}
Abhishek Singh41988ba2015-05-25 19:42:29 +0530[diff] [blame]20440/*==========================================================================
20441 FUNCTION WDA_ProcessSetRtsCtsHTVhtInd
20442
20443 DESCRIPTION
20444 API to enable/disable RTS/CTS for different modes.
20445
20446 PARAMETERS
20447 pWDA: Pointer to WDA context
20448 rtsCtsVal : Bit mask value to enable RTS/CTS for different modes
20449===========================================================================*/
20450
20451VOS_STATUS
20452WDA_ProcessSetRtsCtsHTVhtInd(tWDA_CbContext *pWDA,
20453 tANI_U32 rtsCtsVal)
20454{
20455 WDI_Status status;
20456 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20457 FL("---> %s"), __func__);
20458 status = WDI_SetRtsCtsHTVhtInd(rtsCtsVal);
20459 if (WDI_STATUS_PENDING == status)
20460 {
20461 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20462 FL("pending status received "));
20463 }
20464 else if (WDI_STATUS_SUCCESS_SYNC != status)
20465 {
20466 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20467 FL("Failure status %d"), status);
20468 }
20469 return CONVERT_WDI2VOS_STATUS(status) ;
20470}
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]20471
20472void WDA_MonModeRspCallback(void *pEventData, void* pUserData)
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20473{
20474 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]20475 tSirMonModeReq *pData;
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20476
20477 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20478 "<------ %s " ,__func__);
20479 if (NULL == pWdaParams)
20480 {
20481 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20482 "%s: pWdaParams received NULL", __func__);
20483 VOS_ASSERT(0) ;
20484 return ;
20485 }
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]20486 pData = (tSirMonModeReq *)pWdaParams->wdaMsgParam;
20487 if (pData != NULL) {
20488 pData->callback(pData->magic, pData->cmpVar);
20489 vos_mem_free(pWdaParams->wdaMsgParam);
20490 }
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20491 vos_mem_free(pWdaParams) ;
20492
20493 return;
20494}
20495
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]20496VOS_STATUS WDA_ProcessMonStartReq( tWDA_CbContext *pWDA, void *wdaRequest)
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20497{
20498
20499 WDI_Status status = WDI_STATUS_SUCCESS;
20500 tWDA_ReqParams *pWdaParams;
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]20501 tSirMonModeReq *pMonModeData = (tSirMonModeReq *)wdaRequest;
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20502
20503 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20504 FL("%s: "), __func__);
20505 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
20506 if (NULL == pWdaParams)
20507 {
20508 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20509 FL("%s: VOS MEM Alloc Failure"), __func__);
20510 VOS_ASSERT(0);
20511 return VOS_STATUS_E_NOMEM;
20512 }
20513 pWdaParams->pWdaContext = pWDA;
20514 pWdaParams->wdaMsgParam = wdaRequest;
20515 pWdaParams->wdaWdiApiMsgParam = NULL;
20516
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]20517 status = WDI_MonStartReq(pMonModeData->data,
20518 (WDI_MonModeRspCb)WDA_MonModeRspCallback,
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20519 (void *)pWdaParams);
20520 if (IS_WDI_STATUS_FAILURE(status))
20521 {
20522 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20523 "Failure to request. Free all the memory " );
20524 vos_mem_free(pWdaParams->wdaMsgParam);
20525 vos_mem_free(pWdaParams);
20526 }
20527 return CONVERT_WDI2VOS_STATUS(status);
20528}
20529
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20530VOS_STATUS WDA_ProcessMonStopReq( tWDA_CbContext *pWDA, void* wdaRequest)
20531{
20532
20533 WDI_Status status = WDI_STATUS_SUCCESS;
20534 tWDA_ReqParams *pWdaParams;
20535
20536 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20537 FL("%s: "), __func__);
20538 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams));
20539 if (NULL == pWdaParams)
20540 {
20541 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20542 FL("%s: VOS MEM Alloc Failure"), __func__);
20543 VOS_ASSERT(0);
20544 return VOS_STATUS_E_NOMEM;
20545 }
20546 pWdaParams->pWdaContext = pWDA;
20547 pWdaParams->wdaMsgParam = wdaRequest;
20548 pWdaParams->wdaWdiApiMsgParam = NULL;
20549
Bhargav Shah1ae5de02015-07-20 13:32:31 +0530[diff] [blame]20550 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20551 "%s: Processing Mon stop request", __func__);
Hanumantha Reddy Pothula91cdd7f2015-09-03 21:25:16 +0530[diff] [blame]20552 status = WDI_MonStopReq((WDI_MonModeRspCb)WDA_MonModeRspCallback,
Katya Nigamf0511f62015-05-05 16:40:57 +0530[diff] [blame]20553 (void *)pWdaParams);
20554
20555 if (IS_WDI_STATUS_FAILURE(status))
20556 {
20557 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20558 "Failure to request. Free all the memory " );
20559 vos_mem_free(pWdaParams->wdaMsgParam);
20560 vos_mem_free(pWdaParams);
20561 }
20562 return CONVERT_WDI2VOS_STATUS(status);
20563}
Mahesh A Saptasagarbeca12c2015-09-07 16:21:06 +0530[diff] [blame]20564
20565VOS_STATUS WDA_ProcessEnableDisableCAEventInd(tWDA_CbContext *pWDA, tANI_U8 val)
20566{
20567 WDI_Status status;
20568 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20569 FL("---> %s"), __func__);
20570 status = WDI_EnableDisableCAEventInd(val);
20571 if (WDI_STATUS_PENDING == status)
20572 {
20573 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20574 FL("pending status received "));
20575 }
20576 else if (WDI_STATUS_SUCCESS_SYNC != status)
20577 {
20578 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20579 FL("Failure status %d"), status);
20580 }
20581 return CONVERT_WDI2VOS_STATUS(status) ;
20582}
Arun Khandavalli7eeb1592015-10-19 21:36:57 +0530[diff] [blame]20583
20584/*==========================================================================
20585 FUNCTION WDA_WifiConfigSetRspCallback
20586
20587 DESCRIPTION
20588 API to process set WifiConfig response from FW
20589
20590 PARAMETERS
20591 pRsp: Pointer to set WifiConfig response
20592 pUserData: Pointer to user data
20593
20594 RETURN VALUE
20595 NONE
20596
20597===========================================================================*/
20598void WDA_WifiConfigSetRspCallback(void *pEventData, void* pUserData)
20599{
20600 tWDA_ReqParams *pWdaParams = (tWDA_ReqParams *)pUserData;
20601
20602 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20603 "<------ %s " ,__func__);
20604
20605 if(NULL == pWdaParams)
20606 {
20607 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20608 "%s: pWdaParams received NULL", __func__);
20609 VOS_ASSERT(0);
20610 return ;
20611 }
20612
20613 if(NULL == pWdaParams->wdaMsgParam)
20614 {
20615 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20616 "%s: pWdaParams->wdaMsgParam is NULL", __func__);
20617 VOS_ASSERT(0);
20618 vos_mem_free(pWdaParams);
20619 return ;
20620 }
20621
20622 vos_mem_free(pWdaParams->wdaWdiApiMsgParam);
20623 vos_mem_free(pWdaParams->wdaMsgParam);
20624 vos_mem_free(pWdaParams);
20625
20626 return;
20627}
20628
20629/*==========================================================================
20630 FUNCTION WDA_ProcessWifiConfigReq
20631
20632 DESCRIPTION
20633 API to send Set WifiConfig params request to WDI
20634
20635 PARAMETERS
20636 pWDA: Pointer to WDA context
20637 wdaRequest: Pointer to set WifiConfig req parameters
20638===========================================================================*/
20639
20640VOS_STATUS WDA_ProcessWifiConfigReq(tWDA_CbContext *pWDA,
20641 tSetWifiConfigParams *pwdaWificonfig)
20642{
20643 WDI_Status status = WDI_STATUS_SUCCESS;
20644 WDI_WifiConfigSetReqType *pwdiWifConfigSetReqParams;
20645 tWDA_ReqParams *pWdaParams ;
20646 WDI_Status wstatus;
20647
20648 /* Sanity Check*/
20649 if(NULL == pwdaWificonfig)
20650 {
20651 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20652 "%s: tSetWifiConfigParams received NULL", __func__);
20653 VOS_ASSERT(0) ;
20654 return VOS_STATUS_E_FAULT;
20655 }
20656
20657 pwdiWifConfigSetReqParams = (WDI_WifiConfigSetReqType *)vos_mem_malloc(
20658 sizeof(WDI_WifiConfigSetReqType));
20659 if(NULL == pwdiWifConfigSetReqParams)
20660 {
20661 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20662 "%s: VOS MEM Alloc Failure", __func__);
20663 VOS_ASSERT(0);
20664 vos_mem_free(pwdaWificonfig);
20665 return VOS_STATUS_E_NOMEM;
20666 }
20667
20668 pWdaParams = (tWDA_ReqParams *)vos_mem_malloc(sizeof(tWDA_ReqParams)) ;
20669 if(NULL == pWdaParams)
20670 {
20671 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20672 "%s: VOS MEM Alloc Failure", __func__);
20673 VOS_ASSERT(0);
20674 vos_mem_free(pwdiWifConfigSetReqParams);
20675 vos_mem_free(pwdaWificonfig);
20676 return VOS_STATUS_E_NOMEM;
20677 }
20678 pwdiWifConfigSetReqParams->paramType = pwdaWificonfig->paramType;
20679 pwdiWifConfigSetReqParams->paramValue = pwdaWificonfig->paramValue;
20680 vos_mem_copy(pwdiWifConfigSetReqParams->bssId,
20681 &(pwdaWificonfig->bssId), sizeof(tSirMacAddr));
20682
20683 pWdaParams->pWdaContext = pWDA;
Arun Khandavallic7ca4172015-10-21 10:42:42 +0530[diff] [blame]20684 pWdaParams->wdaMsgParam = pwdaWificonfig;
Arun Khandavalli7eeb1592015-10-19 21:36:57 +0530[diff] [blame]20685 pWdaParams->wdaWdiApiMsgParam = (void *)pwdiWifConfigSetReqParams;
20686
20687 wstatus = WDI_WifiConfigSetReq(pwdiWifConfigSetReqParams,
20688 (WDI_WifiConfigSetRspCb)WDA_WifiConfigSetRspCallback,
20689 pWdaParams);
20690 if(IS_WDI_STATUS_FAILURE(wstatus))
20691 {
20692 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20693 "Failure in sendind WifiConfigReq, free all the memory" );
20694 status = CONVERT_WDI2VOS_STATUS(wstatus);
20695 vos_mem_free(pWdaParams->wdaWdiApiMsgParam) ;
20696 vos_mem_free(pWdaParams->wdaMsgParam);
20697 vos_mem_free(pWdaParams);
20698 }
20699
20700 return status;
20701
20702}
Padma, Santhosh Kumar2ccac212015-10-20 17:27:27 +0530[diff] [blame]20703
20704#ifdef FEATURE_OEM_DATA_SUPPORT
20705/*
20706 * FUNCTION: WDA_ProcessStartOemDataReqIndNew
20707 * Request to WDI.
20708 */
20709VOS_STATUS WDA_ProcessStartOemDataReqIndNew(tWDA_CbContext *pWDA,
20710 tOemDataReqNewConfig *pOemDataReqNewConfig)
20711{
20712 VOS_STATUS status = VOS_STATUS_SUCCESS;
20713 WDI_Status wstatus;
20714 WDI_OemDataReqNewConfig *wdiOemDataReqNewConfig;
20715
20716 /* Sanity Check*/
20717 if(NULL == pOemDataReqNewConfig)
20718 {
20719 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20720 "%s: pOemDataReqNewConfig received NULL", __func__);
20721 VOS_ASSERT(0) ;
20722 return VOS_STATUS_E_FAULT;
20723 }
20724
20725 wdiOemDataReqNewConfig = (WDI_OemDataReqNewConfig *)vos_mem_malloc(
20726 sizeof(WDI_OemDataReqNewConfig));
20727 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20728 "------> %s " ,__func__);
20729
20730 if(NULL == wdiOemDataReqNewConfig)
20731 {
20732 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20733 "%s: VOS MEM Alloc Failure", __func__);
20734 VOS_ASSERT(0);
20735 vos_mem_free(pOemDataReqNewConfig);
20736 return VOS_STATUS_E_NOMEM;
20737 }
20738
20739 vos_mem_copy(wdiOemDataReqNewConfig, pOemDataReqNewConfig,
20740 sizeof(WDI_OemDataReqNewConfig));
20741
20742 wstatus = WDI_StartOemDataReqIndNew(wdiOemDataReqNewConfig);
20743
20744 if (WDI_STATUS_PENDING == wstatus)
20745 {
20746 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_INFO,
20747 FL("pending status received "));
20748 }
20749 else if ((WDI_STATUS_SUCCESS_SYNC != wstatus) && (WDI_STATUS_SUCCESS != wstatus))
20750 {
20751 VOS_TRACE( VOS_MODULE_ID_WDA, VOS_TRACE_LEVEL_ERROR,
20752 FL("Failure in OemDataReqIndNew WDI API, free all memory %d"), wstatus);
20753 vos_mem_free(wdiOemDataReqNewConfig);
20754 }
20755
20756 // Free the memory allocated in sme_OemDataReqNew
20757 vos_mem_free(pOemDataReqNewConfig);
20758
20759 return status;
20760}
20761#endif
20762