static char *
dump_pmc_test_Wowl( tpAniSirGlobal pMac, tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3, tANI_U32 arg4, char *p)
{
tSirSmeRsp smeRsp;
tSirWowlAddBcastPtrn addPattern;
tSirWowlDelBcastPtrn delPattern;
tSirSmeWowlEnterParams wowlEnterParams;
tANI_U8 sessionId = 0;
smeRsp.statusCode = eSIR_SME_SUCCESS;
palZeroMemory(pMac->hHdd, &addPattern, sizeof(tSirWowlAddBcastPtrn));
palZeroMemory(pMac->hHdd, &delPattern, sizeof(tSirWowlDelBcastPtrn));
palZeroMemory(pMac->hHdd, &wowlEnterParams, sizeof(tSirSmeWowlEnterParams));
(void) arg2; (void) arg3; (void) arg4;
if(arg1 == CSR_ROAM_SESSION_MAX)
{
pmcLog(pMac, LOGE, "dump_pmc_test_Wowl: Invalid sessionId\n");
return p;
}
sessionId = (tANI_U8 ) arg1;
sme_WowlAddBcastPattern(pMac, &addPattern, sessionId);
sme_WowlDelBcastPattern(pMac, &delPattern, sessionId);
pMac->pmc.pmcState = BMPS;
#ifdef WLAN_WAKEUP_EVENTS
sme_EnterWowl(pMac, dump_pmc_callbackRoutine, pMac, dump_pmc_callbackRoutine2, pMac,
&wowlEnterParams, sessionId);
#else
sme_EnterWowl(pMac, dump_pmc_callbackRoutine, pMac, &wowlEnterParams, sessionId);
#endif
smeRsp.messageType = eWNI_PMC_ENTER_WOWL_RSP;
pmcMessageProcessor(pMac, &smeRsp);
sme_ExitWowl(pMac);
smeRsp.messageType = eWNI_PMC_EXIT_WOWL_RSP;
pmcMessageProcessor(pMac, &smeRsp);
return p;
}
/**
* limExtractApCapability()
*
*FUNCTION:
* This function is called to extract AP's HCF/WME/WSM capability
* from the IEs received from it in Beacon/Probe Response frames
*
*LOGIC:
*
*ASSUMPTIONS:
* NA
*
*NOTE:
*
* @param pMac Pointer to Global MAC structure
* @param pIE Pointer to starting IE in Beacon/Probe Response
* @param ieLen Length of all IEs combined
* @param qosCap Bits are set according to capabilities
* @return 0 - If AP does not assert HCF capability & 1 - otherwise
*/
void
limExtractApCapability(tpAniSirGlobal pMac, tANI_U8 *pIE, tANI_U16 ieLen,
tANI_U8 *qosCap, tANI_U16 *propCap, tANI_U8 *uapsd,
tPowerdBm *localConstraint,
tpPESession psessionEntry
)
{
tSirProbeRespBeacon *pBeaconStruct;
#if !defined WLAN_FEATURE_VOWIFI
tANI_U32 localPowerConstraints = 0;
#endif
if(eHAL_STATUS_SUCCESS != palAllocateMemory(pMac->hHdd,
(void **)&pBeaconStruct, sizeof(tSirProbeRespBeacon)))
{
limLog(pMac, LOGE, FL("Unable to PAL allocate memory in limExtractApCapability") );
return;
}
palZeroMemory( pMac->hHdd, (tANI_U8 *) pBeaconStruct, sizeof(tSirProbeRespBeacon));
*qosCap = 0;
*propCap = 0;
*uapsd = 0;
PELOG3(limLog( pMac, LOG3,
FL("In limExtractApCapability: The IE's being received are:"));
sirDumpBuf( pMac, SIR_LIM_MODULE_ID, LOG3, pIE, ieLen );)
if (sirParseBeaconIE(pMac, pBeaconStruct, pIE, (tANI_U32)ieLen) == eSIR_SUCCESS)
/* ---------------------------------------------------------------------------
\fn oemData_SendMBOemDataReq
\brief Request an OEM DATA REQ to be passed down to PE
\param pMac:
\param pOemDataReq: Pointer to the oem data request
\return eHalStatus
-------------------------------------------------------------------------------*/
eHalStatus oemData_SendMBOemDataReq(tpAniSirGlobal pMac, tOemDataReq *pOemDataReq)
{
eHalStatus status = eHAL_STATUS_SUCCESS;
tSirOemDataReq* pMsg;
tANI_U16 msgLen;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, pOemDataReq->sessionId );
smsLog(pMac, LOGW, "OEM_DATA: entering Function %s", __func__);
msgLen = (tANI_U16)(sizeof(tSirOemDataReq));
status = palAllocateMemory(pMac->hHdd, (void**)&pMsg, msgLen);
if(HAL_STATUS_SUCCESS(status))
{
palZeroMemory(pMac->hHdd, pMsg, msgLen);
pMsg->messageType = pal_cpu_to_be16((tANI_U16)eWNI_SME_OEM_DATA_REQ);
palCopyMemory(pMac->hHdd, pMsg->selfMacAddr, pSession->selfMacAddr, sizeof(tSirMacAddr) );
status = palCopyMemory(pMac->hHdd, pMsg->oemDataReq, pOemDataReq->oemDataReq, OEM_DATA_REQ_SIZE);
if(HAL_STATUS_SUCCESS(status))
{
smsLog(pMac, LOGW, "OEM_DATA: sending message to pe%s", __func__);
status = palSendMBMessage(pMac->hHdd, pMsg);
}
else
{
palFreeMemory(pMac->hHdd, pMsg);
}
}
smsLog(pMac, LOGW, "OEM_DATA: exiting Function %s", __func__);
return status;
}
static eHalStatus tdlsSaveTdlsPeerInfo(tpAniSirGlobal pMac,
tSirTdlsPeerInfo *disPeerInfo)
{
tCsrTdlsPeerLinkinfo *peerInfo = NULL ;
tCsrTdlsCtxStruct *disInfo = &pMac->tdlsCtx ;
eHalStatus status = eHAL_STATUS_FAILURE ;
status = palAllocateMemory( pMac->hHdd, (void **)&peerInfo,
sizeof(tCsrTdlsPeerLinkinfo));
if (HAL_STATUS_SUCCESS(status))
{
palZeroMemory(pMac->hHdd, &peerInfo->tdlsDisPeerInfo,
sizeof(tSirTdlsPeerInfo));
palCopyMemory(pMac->hHdd, &peerInfo->tdlsDisPeerInfo, disPeerInfo,
sizeof(tSirTdlsPeerInfo));
disInfo->tdlsPeerCount++ ;
csrLLInsertTail( &disInfo->tdlsPotentialPeerList,
&peerInfo->tdlsPeerStaLink, LL_ACCESS_LOCK );
}
return status ;
}
tSirRetStatus
sysInitGlobals(tpAniSirGlobal pMac)
{
palZeroMemory(pMac->hHdd, (tANI_U8 *) &pMac->sys, sizeof(pMac->sys));
#if defined(ANI_DEBUG)
//FIXME : right now we want the reset to happen even in diag debug build.
// later on we need to set this to true.
//pMac->sys.debugOnReset = true;
pMac->sys.debugOnReset = false;
#else
pMac->sys.debugOnReset = false;
#endif
pMac->sys.gSysEnableScanMode = 1;
pMac->sys.gSysEnableLinkMonitorMode = 0;
pMac->sys.fTestRadar = false;
pMac->sys.radarDetected = false;
pMac->sys.gSysdropLimPkts = false;
#ifdef FEATURE_WLAN_NON_INTEGRATED_SOC
if(eHAL_STATUS_SUCCESS != halGlobalInit(pMac))
return eSIR_FAILURE;
#endif
schInitGlobals(pMac);
return eSIR_SUCCESS;
}
eHalStatus ccmOpen(tHalHandle hHal)
{
tHddHandle hHdd = halHandle2HddHandle(hHal);
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
(void)palZeroMemory(hHdd, &pMac->ccm, sizeof(tCcm)) ;
return palSpinLockAlloc(hHdd, &pMac->ccm.lock);
}
static char *
dump_pmc_enter_wowl( tpAniSirGlobal pMac, tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3, tANI_U32 arg4, char *p)
{
tSirSmeWowlEnterParams wowlEnterParams;
tSirRetStatus status;
tANI_U32 length;
tANI_U8 sessionId = 0;
(void) arg4;
palZeroMemory(pMac->hHdd, &wowlEnterParams, sizeof(tSirSmeWowlEnterParams));
if (arg1 == 0 && arg2 == 0)
{
pmcLog(pMac, LOGE,
"Requesting WoWL but neither magic pkt and ptrn byte matching is being enabled\n");
return p;
}
if(arg1 == 1)
{
wowlEnterParams.ucMagicPktEnable = 1;
length = SIR_MAC_ADDR_LENGTH;
status = wlan_cfgGetStr(pMac, WNI_CFG_STA_ID, (tANI_U8 *)wowlEnterParams.magicPtrn, &length);
if (eSIR_SUCCESS != status)
{
pmcLog(pMac, LOGE,
"Reading of WNI_CFG_STA_ID from CFG failed. Using hardcoded STA MAC Addr\n");
wowlEnterParams.magicPtrn[0] = 0x00;
wowlEnterParams.magicPtrn[1] = 0x0a;
wowlEnterParams.magicPtrn[2] = 0xf5;
wowlEnterParams.magicPtrn[3] = 0x04;
wowlEnterParams.magicPtrn[4] = 0x05;
wowlEnterParams.magicPtrn[5] = 0x06;
}
}
if(arg2 == 1)
{
wowlEnterParams.ucPatternFilteringEnable = 1;
}
if(arg3 == CSR_ROAM_SESSION_MAX )
{
pmcLog(pMac, LOGE, "Enter valid sessionId\n");
return p;
}
pMac->pmc.bmpsEnabled = TRUE;
pMac->pmc.wowlEnabled = TRUE;
sessionId = (tANI_U8 ) arg3;
#ifdef WLAN_WAKEUP_EVENTS
(void)sme_EnterWowl(pMac, dump_pmc_callbackRoutine, pMac, dump_pmc_callbackRoutine2, pMac,
&wowlEnterParams, sessionId);
#else
(void)sme_EnterWowl(pMac, dump_pmc_callbackRoutine, pMac, &wowlEnterParams, sessionId);
#endif
return p;
}
tSirRetStatus macOpen(tHalHandle *pHalHandle, tHddHandle hHdd, tMacOpenParameters *pMacOpenParms)
{
tpAniSirGlobal pMac = NULL;
if(pHalHandle == NULL)
return eSIR_FAILURE;
/*
* Make sure this adapter is not already opened. (Compare pAdapter pointer in already
* allocated pMac structures.)
* If it is opened just return pointer to previously allocated pMac pointer.
* Or should this result in error?
*/
/* Allocate pMac */
if (palAllocateMemory(hHdd, ((void **)&pMac), sizeof(tAniSirGlobal)) != eHAL_STATUS_SUCCESS)
return eSIR_FAILURE;
/* Initialize the pMac structure */
palZeroMemory(hHdd, pMac, sizeof(tAniSirGlobal));
/** Store the Driver type in pMac Global.*/
//pMac->gDriverType = pMacOpenParms->driverType;
/*
* Set various global fields of pMac here
* (Could be platform dependant as some variables in pMac are platform
* dependant)
*/
pMac->hHdd = hHdd;
pMac->pAdapter = hHdd; //This line wil be removed
*pHalHandle = (tHalHandle)pMac;
{
/* Call various PE (and other layer init here) */
if( eSIR_SUCCESS != logInit(pMac))
return eSIR_FAILURE;
/* Call routine to initialize CFG data structures */
if( eSIR_SUCCESS != cfgInit(pMac) )
return eSIR_FAILURE;
sysInitGlobals(pMac);
}
return peOpen(pMac, pMacOpenParms);
}
tSirRetStatus macStart(tHalHandle hHal, void* pHalMacStartParams)
{
tSirRetStatus status = eSIR_SUCCESS;
tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;
if (NULL == pMac)
{
VOS_ASSERT(0);
status = eSIR_FAILURE;
return status;
}
pMac->gDriverType = ((tHalMacStartParameters*)pHalMacStartParams)->driverType;
sysLog(pMac, LOG2, FL("called\n"));
do
{
#if defined(TRACE_RECORD)
//Enable Tracing
macTraceInit(pMac);
#endif
if (!HAL_STATUS_SUCCESS(palAllocateMemory(pMac->hHdd, ((void *)&pMac->pResetMsg), sizeof(tSirMbMsg))))
{
sysLog(pMac, LOGE, FL("pMac->pResetMsg is NULL\n"));
status = eSIR_FAILURE;
break;
}
else
{
palZeroMemory(pMac->hHdd, pMac->pResetMsg, sizeof(tSirMbMsg));
}
if (pMac->gDriverType != eDRIVER_TYPE_MFG)
{
status = peStart(pMac);
}
} while(0);
pMac->sys.abort = false;
return status;
}
/*
* save TDLS peer info, this will be called after successfull completion
* of TDLS discovery procedure.
*/
static eHalStatus tdlsSaveTdlsPeerInfo(tpAniSirGlobal pMac,
tSirTdlsPeerInfo *disPeerInfo)
{
tCsrTdlsPeerLinkinfo *peerInfo = NULL ;
tCsrTdlsCtxStruct *disInfo = &pMac->tdlsCtx ;
eHalStatus status = eHAL_STATUS_FAILURE ;
/*
* Ok, allocate memory for peer info here
* we allocate memory for each peer here and free his memory
* at the time the peer node is getting deleted, possible case is
* teardown
*/
status = palAllocateMemory( pMac->hHdd, (void **)&peerInfo,
sizeof(tCsrTdlsPeerLinkinfo));
/*
* go ahead and copy peerInfo and insert this node info discovery rsp
* database.
*/
if (HAL_STATUS_SUCCESS(status))
{
palZeroMemory(pMac->hHdd, &peerInfo->tdlsDisPeerInfo,
sizeof(tSirTdlsPeerInfo));
palCopyMemory(pMac->hHdd, &peerInfo->tdlsDisPeerInfo, disPeerInfo,
sizeof(tSirTdlsPeerInfo));
/*
* update TDLS client count to indicate there is tdls client
* in tdls potential peer list.
*/
disInfo->tdlsPeerCount++ ;
/*
* finally insert this tdls peer info into tdls potential peer list
*/
csrLLInsertTail( &disInfo->tdlsPotentialPeerList,
&peerInfo->tdlsPeerStaLink, LL_ACCESS_LOCK );
}
return status ;
}
tSirRetStatus macPreStart(tHalHandle hHal)
{
tSirRetStatus status = eSIR_SUCCESS;
tANI_BOOLEAN memAllocFailed = eANI_BOOLEAN_FALSE;
tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;
tANI_U8 i;
for(i=0; i<MAX_DUMP_TABLE_ENTRY; i++)
{
if(palAllocateMemory(pMac->hHdd, ((void *)&pMac->dumpTableEntry[i]), sizeof(tDumpModuleEntry))
!= eHAL_STATUS_SUCCESS)
{
memAllocFailed = eANI_BOOLEAN_TRUE;
break;
}
else
{
palZeroMemory(pMac->hHdd, pMac->dumpTableEntry[i], sizeof(tSirMbMsg));
}
}
if( memAllocFailed )
{
while(i>0)
{
i--;
palFreeMemory(pMac, pMac->dumpTableEntry[i]);
}
sysLog(pMac, LOGE, FL("pMac->dumpTableEntry is NULL\n"));
status = eSIR_FAILURE;
}
#if defined(ANI_LOGDUMP)
//logDumpInit must be called before any module starts
logDumpInit(pMac);
#endif //#if defined(ANI_LOGDUMP)
return status;
}
static char *
dump_pmc_remove_ptrn( tpAniSirGlobal pMac, tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3, tANI_U32 arg4, char *p)
{
tSirWowlDelBcastPtrn delPattern;
tANI_U8 sessionId = 0;
(void) arg3; (void) arg4;
palZeroMemory(pMac->hHdd, &delPattern, sizeof(tSirWowlDelBcastPtrn));
if((arg1 <= 7) || (arg2 == CSR_ROAM_SESSION_MAX))
{
delPattern.ucPatternId = (tANI_U8)arg1;
}
else
{
pmcLog(pMac, LOGE, "dump_pmc_remove_ptrn: Invalid pattern Id %d\n",arg1);
return p;
}
sessionId = (tANI_U8 ) arg2;
(void)pmcWowlDelBcastPattern(pMac, &delPattern, sessionId);
return p;
}
/**
* limSendCFParams()
*
*FUNCTION:
* This function is called to send CFP Parameters to WDA, when they are changed.
*
*LOGIC:
*
*ASSUMPTIONS:
* NA
*
*NOTE:
* NA
*
* @param pMac pointer to Global Mac structure.
* @param bssIdx Bss Index of the BSS to which STA is associated.
* @param cfpCount CFP Count, if that is changed.
* @param cfpPeriod CFP Period if that is changed.
*
* @return success if message send is ok, else false.
*/
tSirRetStatus limSendCFParams(tpAniSirGlobal pMac, tANI_U8 bssIdx, tANI_U8 cfpCount, tANI_U8 cfpPeriod)
{
tpUpdateCFParams pCFParams = NULL;
tSirRetStatus retCode = eSIR_SUCCESS;
tSirMsgQ msgQ;
if( eHAL_STATUS_SUCCESS != palAllocateMemory( pMac->hHdd,
(void **) &pCFParams,
sizeof( tUpdateCFParams )))
{
limLog( pMac, LOGP,
FL( "Unable to PAL allocate memory during Update CF Params\n" ));
retCode = eSIR_MEM_ALLOC_FAILED;
goto returnFailure;
}
palZeroMemory( pMac->hHdd, (tANI_U8 *) pCFParams, sizeof(tUpdateCFParams));
pCFParams->cfpCount = cfpCount;
pCFParams->cfpPeriod = cfpPeriod;
pCFParams->bssIdx = bssIdx;
msgQ.type = WDA_UPDATE_CF_IND;
msgQ.reserved = 0;
msgQ.bodyptr = pCFParams;
msgQ.bodyval = 0;
limLog( pMac, LOG3,
FL( "Sending WDA_UPDATE_CF_IND..." ));
MTRACE(macTraceMsgTx(pMac, NO_SESSION, msgQ.type));
if( eSIR_SUCCESS != (retCode = wdaPostCtrlMsg( pMac, &msgQ )))
{
palFreeMemory(pMac->hHdd, pCFParams);
limLog( pMac, LOGP,
FL("Posting WDA_UPDATE_CF_IND to WDA failed, reason=%X\n"),
retCode );
}
returnFailure:
return retCode;
}
void peInitBeaconParams(tpAniSirGlobal pMac, tpPESession psessionEntry)
{
psessionEntry->beaconParams.beaconInterval = 0;
psessionEntry->beaconParams.fShortPreamble = 0;
psessionEntry->beaconParams.llaCoexist = 0;
psessionEntry->beaconParams.llbCoexist = 0;
psessionEntry->beaconParams.llgCoexist = 0;
psessionEntry->beaconParams.ht20Coexist = 0;
psessionEntry->beaconParams.llnNonGFCoexist = 0;
psessionEntry->beaconParams.fRIFSMode = 0;
psessionEntry->beaconParams.fLsigTXOPProtectionFullSupport = 0;
psessionEntry->beaconParams.gHTObssMode = 0;
// Number of legacy STAs associated
palZeroMemory(pMac->hHdd, (void*)&psessionEntry->gLim11bParams, sizeof(tLimProtStaParams));
palZeroMemory(pMac->hHdd, (void*)&psessionEntry->gLim11aParams, sizeof(tLimProtStaParams));
palZeroMemory(pMac->hHdd, (void*)&psessionEntry->gLim11gParams, sizeof(tLimProtStaParams));
palZeroMemory(pMac->hHdd, (void*)&psessionEntry->gLimNonGfParams, sizeof(tLimProtStaParams));
palZeroMemory(pMac->hHdd, (void*)&psessionEntry->gLimHt20Params, sizeof(tLimProtStaParams));
palZeroMemory(pMac->hHdd, (void*)&psessionEntry->gLimLsigTxopParams, sizeof(tLimProtStaParams));
palZeroMemory(pMac->hHdd, (void*)&psessionEntry->gLimOlbcParams, sizeof(tLimProtStaParams));
}
tSirRetStatus macOpen(tHalHandle *pHalHandle, tHddHandle hHdd, tMacOpenParameters *pMacOpenParms)
{
tpAniSirGlobal pMac = NULL;
if(pHalHandle == NULL)
return eSIR_FAILURE;
/*
* Make sure this adapter is not already opened. (Compare pAdaptor pointer in already
* allocated pMac structures.)
* If it is opened just return pointer to previously allocated pMac pointer.
* Or should this result in error?
*/
/* Allocate pMac */
if (palAllocateMemory(hHdd, ((void **)&pMac), sizeof(tAniSirGlobal)) != eHAL_STATUS_SUCCESS)
return eSIR_FAILURE;
/* Initialize the pMac structure */
palZeroMemory(hHdd, pMac, sizeof(tAniSirGlobal));
/** Store the Driver type in pMac Global.*/
//pMac->gDriverType = pMacOpenParms->driverType;
#ifndef GEN6_ONWARDS
#ifdef RTL8652
{
//Leverage 8651c's on-chip data scratchpad memory to lock all HAL DxE data there
extern void * rtlglue_alloc_data_scratchpad_memory(unsigned int size, char *);
pMac->hal.pHalDxe = (tpAniHalDxe) rtlglue_alloc_data_scratchpad_memory(sizeof(tAniHalDxe), "halDxe");
}
if(pMac->hal.pHalDxe){
;
}else
#endif
/* Allocate HalDxe */
if (palAllocateMemory(hHdd, ((void **)&pMac->hal.pHalDxe), sizeof(tAniHalDxe)) != eHAL_STATUS_SUCCESS){
palFreeMemory(hHdd, pMac);
return eSIR_FAILURE;
}
/* Initialize the HalDxe structure */
palZeroMemory(hHdd, pMac->hal.pHalDxe, sizeof(tAniHalDxe));
#endif //GEN6_ONWARDS
/*
* Set various global fields of pMac here
* (Could be platform dependant as some variables in pMac are platform
* dependant)
*/
pMac->hHdd = hHdd;
pMac->pAdapter = hHdd; //This line wil be removed
*pHalHandle = (tHalHandle)pMac;
{
/* Call various PE (and other layer init here) */
if( eSIR_SUCCESS != logInit(pMac))
return eSIR_FAILURE;
/* Call routine to initialize CFG data structures */
if( eSIR_SUCCESS != cfgInit(pMac) )
return eSIR_FAILURE;
sysInitGlobals(pMac);
#ifdef FEATURE_WLAN_NON_INTEGRATED_SOC
// This decides whether HW needs to translate the 802.3 frames
// from the host OS to the 802.11 frames. When set HW does the
// translation from 802.3 to 802.11 and vice versa
if(pMacOpenParms->frameTransRequired) {
pMac->hal.halMac.frameTransEnabled = 1;
} else {
pMac->hal.halMac.frameTransEnabled = 0;
}
#endif
//Need to do it here in case halOpen fails later on.
#if defined( VOSS_ENABLED )
tx_voss_wrapper_init(pMac, hHdd);
#endif
}
#ifdef FEATURE_WLAN_NON_INTEGRATED_SOC
if (eHAL_STATUS_SUCCESS != halOpen(pMac, pHalHandle, hHdd, pMacOpenParms))
return eSIR_FAILURE;
#endif
return peOpen(pMac, pMacOpenParms);
}
/* Application Specific include files */
#include "halInternal.h"
#include "halHddApis.h"
#include "halDebug.h"
#include "halMTU.h"
#include "halRxp.h"
#include "halPhyApi.h"
//#ifdef ANI_OS_TYPE_LINUX
#include "halCommonApi.h" // halCleanup
#endif
#include "cfgApi.h" // cfgCleanup
#include "limApi.h" // limCleanup
#include "sirTypes.h"
#include "sysDebug.h"
#include "sysEntryFunc.h"
#include "macInitApi.h"
#if defined(ANI_LOGDUMP)
#include "logDump.h"
#endif //#if defined(ANI_LOGDUMP)
#ifdef TRACE_RECORD
#include "macTrace.h"
#endif
extern tSirRetStatus halDoCfgInit(tpAniSirGlobal pMac);
extern tSirRetStatus halProcessStartEvent(tpAniSirGlobal pMac);
tSirRetStatus macReset(tpAniSirGlobal pMac, tANI_U32 rc);
#ifdef FEATURE_WLAN_INTEGRATED_SOC
tSirRetStatus macPreStart(tHalHandle hHal)
{
tSirRetStatus status = eSIR_SUCCESS;
tANI_BOOLEAN memAllocFailed = eANI_BOOLEAN_FALSE;
tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;
tANI_U8 i;
for(i=0; i<MAX_DUMP_TABLE_ENTRY; i++)
{
if(palAllocateMemory(pMac->hHdd, ((void *)&pMac->dumpTableEntry[i]), sizeof(tDumpModuleEntry))
!= eHAL_STATUS_SUCCESS)
{
memAllocFailed = eANI_BOOLEAN_TRUE;
break;
}
else
{
palZeroMemory(pMac->hHdd, pMac->dumpTableEntry[i], sizeof(tSirMbMsg));
}
}
if( memAllocFailed )
{
while(i>0)
{
i--;
palFreeMemory(pMac, pMac->dumpTableEntry[i]);
}
sysLog(pMac, LOGE, FL("pMac->dumpTableEntry is NULL\n"));
status = eSIR_FAILURE;
}
#if defined(ANI_LOGDUMP)
//logDumpInit must be called before any module starts
logDumpInit(pMac);
#endif //#if defined(ANI_LOGDUMP)
return status;
}
tSirRetStatus macStart(tHalHandle hHal, void* pHalMacStartParams)
{
tSirRetStatus status = eSIR_SUCCESS;
tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;
if (NULL == pMac)
{
VOS_ASSERT(0);
status = eSIR_FAILURE;
return status;
}
pMac->gDriverType = ((tHalMacStartParameters*)pHalMacStartParams)->driverType;
sysLog(pMac, LOG2, FL("called\n"));
do
{
#if defined(TRACE_RECORD)
//Enable Tracing
macTraceInit(pMac);
#endif
if (!HAL_STATUS_SUCCESS(palAllocateMemory(pMac->hHdd, ((void *)&pMac->pResetMsg), sizeof(tSirMbMsg))))
{
sysLog(pMac, LOGE, FL("pMac->pResetMsg is NULL\n"));
status = eSIR_FAILURE;
break;
}
else
{
palZeroMemory(pMac->hHdd, pMac->pResetMsg, sizeof(tSirMbMsg));
}
if (pMac->gDriverType != eDRIVER_TYPE_MFG)
{
status = peStart(pMac);
}
} while(0);
pMac->sys.abort = false;
return status;
}
#else /* FEATURE_WLAN_INTEGRATED_SOC */
tSirRetStatus macStart(tHalHandle hHal, void* pHalMacStartParams)
{
tANI_U8 i;
tSirRetStatus status = eSIR_SUCCESS;
eHalStatus halStatus;
tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;
tANI_BOOLEAN memAllocFailed = eANI_BOOLEAN_FALSE;
if(NULL == pMac)
{
VOS_ASSERT(0);
status = eSIR_FAILURE;
return status;
}
pMac->gDriverType = ((tHalMacStartParameters *)pHalMacStartParams)->driverType;
sysLog(pMac, LOG2, FL("called\n"));
do
{
for(i=0; i<MAX_DUMP_TABLE_ENTRY; i++)
{
if(palAllocateMemory(pMac->hHdd, ((void **)&pMac->dumpTableEntry[i]), sizeof(tDumpModuleEntry))
!= eHAL_STATUS_SUCCESS)
{
memAllocFailed = eANI_BOOLEAN_TRUE;
break;
}
else
{
palZeroMemory(pMac->hHdd, pMac->dumpTableEntry[i], sizeof(tSirMbMsg));
}
}
if( memAllocFailed )
{
while(i>0)
{
i--;
palFreeMemory(pMac, pMac->dumpTableEntry[i]);
}
sysLog(pMac, LOGE, FL("pMac->dumpTableEntry is NULL\n"));
status = eSIR_FAILURE;
break;
}
else
{
#if defined(ANI_LOGDUMP)
logDumpInit(pMac);
#endif //#if defined(ANI_LOGDUMP)
}
#if defined(TRACE_RECORD)
//Enable Tracing
macTraceInit(pMac);
#endif
if (!HAL_STATUS_SUCCESS(palAllocateMemory(pMac->hHdd, ((void **)&pMac->pResetMsg), sizeof(tSirMbMsg))))
{
sysLog(pMac, LOGE, FL("pMac->pResetMsg is NULL\n"));
status = eSIR_FAILURE;
break;
}
else
{
palZeroMemory(pMac->hHdd, pMac->pResetMsg, sizeof(tSirMbMsg));
}
halStatus = halStart(hHal, (tHalMacStartParameters*)pHalMacStartParams );
if ( !HAL_STATUS_SUCCESS(halStatus) )
{
sysLog(pMac,LOGE, FL("halStart failed with error code = %d\n"), halStatus);
status = eSIR_FAILURE;
}
else if(pMac->gDriverType != eDRIVER_TYPE_MFG)
{
peStart(pMac);
}
}while(0);
pMac->sys.abort = false;
return status;
}
eHalStatus sme_FTSendUpdateKeyInd(tHalHandle hHal, tCsrRoamSetKey * pFTKeyInfo)
{
tSirFTUpdateKeyInfo *pMsg;
tANI_U16 msgLen;
eHalStatus status = eHAL_STATUS_FAILURE;
tAniEdType tmpEdType;
tSirKeyMaterial *keymaterial = NULL;
tAniEdType edType;
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
int i = 0;
smsLog(pMac, LOG1, FL("keyLength %d"), pFTKeyInfo->keyLength);
for (i=0; i<pFTKeyInfo->keyLength; i++)
smsLog(pMac, LOG1, FL("%02x"), pFTKeyInfo->Key[i]);
#endif
msgLen = sizeof( tANI_U16) + sizeof( tANI_U16 ) +
sizeof( pMsg->keyMaterial.length ) + sizeof( pMsg->keyMaterial.edType ) +
sizeof( pMsg->keyMaterial.numKeys ) + sizeof( pMsg->keyMaterial.key );
status = palAllocateMemory(pMac->hHdd, (void **)&pMsg, msgLen);
if ( !HAL_STATUS_SUCCESS(status) )
{
return eHAL_STATUS_FAILURE;
}
palZeroMemory(pMac->hHdd, pMsg, msgLen);
pMsg->messageType = pal_cpu_to_be16((tANI_U16)eWNI_SME_FT_UPDATE_KEY);
pMsg->length = pal_cpu_to_be16(msgLen);
keymaterial = &pMsg->keyMaterial;
keymaterial->length = pFTKeyInfo->keyLength;
edType = csrTranslateEncryptTypeToEdType( pFTKeyInfo->encType );
tmpEdType = pal_cpu_to_be32(edType);
keymaterial->edType = tmpEdType;
// Set the pMsg->keyMaterial.length field (this length is defined as all
// data that follows the edType field
// in the tSirKeyMaterial keyMaterial; field).
//
// !!NOTE: This keyMaterial.length contains the length of a MAX size key,
// though the keyLength can be
// shorter than this max size. Is LIM interpreting this ok ?
keymaterial->numKeys = 1;
keymaterial->key[ 0 ].keyId = pFTKeyInfo->keyId;
keymaterial->key[ 0 ].unicast = (tANI_U8)eANI_BOOLEAN_TRUE;
keymaterial->key[ 0 ].keyDirection = pFTKeyInfo->keyDirection;
palCopyMemory( pMac->hHdd, &keymaterial->key[ 0 ].keyRsc,
pFTKeyInfo->keyRsc, CSR_MAX_RSC_LEN );
keymaterial->key[ 0 ].paeRole = pFTKeyInfo->paeRole;
keymaterial->key[ 0 ].keyLength = pFTKeyInfo->keyLength;
if ( pFTKeyInfo->keyLength && pFTKeyInfo->Key )
{
palCopyMemory( pMac->hHdd, &keymaterial->key[ 0 ].key,
pFTKeyInfo->Key, pFTKeyInfo->keyLength );
if(pFTKeyInfo->keyLength == 16)
{
smsLog(pMac, LOG1, "SME Set Update Ind keyIdx (%d) encType(%d) key = "
"%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X",
pMsg->keyMaterial.key[0].keyId, (tAniEdType)pMsg->keyMaterial.edType,
pMsg->keyMaterial.key[0].key[0], pMsg->keyMaterial.key[0].key[1],
pMsg->keyMaterial.key[0].key[2], pMsg->keyMaterial.key[0].key[3],
pMsg->keyMaterial.key[0].key[4], pMsg->keyMaterial.key[0].key[5],
pMsg->keyMaterial.key[0].key[6], pMsg->keyMaterial.key[0].key[7],
pMsg->keyMaterial.key[0].key[8], pMsg->keyMaterial.key[0].key[9],
pMsg->keyMaterial.key[0].key[10], pMsg->keyMaterial.key[0].key[11],
pMsg->keyMaterial.key[0].key[12], pMsg->keyMaterial.key[0].key[13],
pMsg->keyMaterial.key[0].key[14], pMsg->keyMaterial.key[0].key[15]);
}
}
vos_mem_copy( &pMsg->bssId[ 0 ],
&pFTKeyInfo->peerMac[ 0 ],
sizeof(tCsrBssid) );
smsLog(pMac, LOG1, "BSSID = "MAC_ADDRESS_STR,
MAC_ADDR_ARRAY(pMsg->bssId));
status = palSendMBMessage(pMac->hHdd, pMsg);
return( status );
}
eHalStatus sme_FTSendUpdateKeyInd(tHalHandle hHal, tCsrRoamSetKey * pFTKeyInfo)
{
tSirFTUpdateKeyInfo *pMsg;
tANI_U16 msgLen;
eHalStatus status = eHAL_STATUS_FAILURE;
tAniEdType tmpEdType;
tAniKeyDirection tmpDirection;
//tANI_U8 *pBuf;
tANI_U8 *p = NULL;
tAniEdType edType;
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
int i = 0;
smsLog(pMac, LOGE, FL("keyLength %d\n"), pFTKeyInfo->keyLength);
for(i=0; i<pFTKeyInfo->keyLength; i++)
smsLog(pMac, LOGE, FL("%02x"), pFTKeyInfo->Key[i]);
msgLen = sizeof( tANI_U16) + sizeof( tANI_U16 ) +
sizeof( pMsg->keyMaterial.length ) + sizeof( pMsg->keyMaterial.edType ) +
sizeof( pMsg->keyMaterial.numKeys ) + sizeof( pMsg->keyMaterial.key );
status = palAllocateMemory(pMac->hHdd, (void **)&pMsg, msgLen);
if ( !HAL_STATUS_SUCCESS(status) )
{
return eHAL_STATUS_FAILURE;
}
palZeroMemory(pMac->hHdd, pMsg, msgLen);
pMsg->messageType = pal_cpu_to_be16((tANI_U16)eWNI_SME_FT_UPDATE_KEY);
pMsg->length = pal_cpu_to_be16(msgLen);
p = (tANI_U8 *)&pMsg->keyMaterial;
// Set the pMsg->keyMaterial.length field (this length is defined as all data that follows the edType field
// in the tSirKeyMaterial keyMaterial; field).
//
// !!NOTE: This keyMaterial.length contains the length of a MAX size key, though the keyLength can be
// shorter than this max size. Is LIM interpreting this ok ?
p = pal_set_U16( p, pal_cpu_to_be16((tANI_U16)( sizeof( pMsg->keyMaterial.numKeys ) +
( pMsg->keyMaterial.numKeys * sizeof( pMsg->keyMaterial.key ) ) )) );
// set pMsg->keyMaterial.edType
edType = csrTranslateEncryptTypeToEdType( pFTKeyInfo->encType );
tmpEdType = pal_cpu_to_be32(edType);
palCopyMemory( pMac->hHdd, p, (tANI_U8 *)&tmpEdType, sizeof(tAniEdType) );
p += sizeof( pMsg->keyMaterial.edType );
// set the pMsg->keyMaterial.numKeys field
*p = pMsg->keyMaterial.numKeys;
p += sizeof( pMsg->keyMaterial.numKeys );
// set pSirKey->keyId = keyId;
*p = pMsg->keyMaterial.key[ 0 ].keyId;
p += sizeof( pMsg->keyMaterial.key[ 0 ].keyId );
// set pSirKey->unicast = (tANI_U8)fUnicast;
*p = (tANI_U8)eANI_BOOLEAN_TRUE;
p += sizeof( pMsg->keyMaterial.key[ 0 ].unicast );
// set pSirKey->keyDirection = aniKeyDirection;
tmpDirection = pal_cpu_to_be32(pFTKeyInfo->keyDirection);
palCopyMemory( pMac->hHdd, p, (tANI_U8 *)&tmpDirection, sizeof(tAniKeyDirection) );
p += sizeof(tAniKeyDirection);
// pSirKey->keyRsc = ;;
palCopyMemory( pMac->hHdd, p, pFTKeyInfo->keyRsc, CSR_MAX_RSC_LEN );
p += sizeof( pMsg->keyMaterial.key[ 0 ].keyRsc );
// set pSirKey->paeRole
*p = pFTKeyInfo->paeRole; // 0 is Supplicant
p++;
// set pSirKey->keyLength = keyLength;
p = pal_set_U16( p, pal_cpu_to_be16(pFTKeyInfo->keyLength) );
if ( pFTKeyInfo->keyLength && pFTKeyInfo->Key )
{
palCopyMemory( pMac->hHdd, p, pFTKeyInfo->Key, pFTKeyInfo->keyLength );
if(pFTKeyInfo->keyLength == 16)
{
smsLog(pMac, LOGE, " SME Set keyIdx (%d) encType(%d) key = %02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X-%02X\n",
pFTKeyInfo->keyId, edType, pFTKeyInfo->Key[0], pFTKeyInfo->Key[1], pFTKeyInfo->Key[2], pFTKeyInfo->Key[3], pFTKeyInfo->Key[4],
pFTKeyInfo->Key[5], pFTKeyInfo->Key[6], pFTKeyInfo->Key[7], pFTKeyInfo->Key[8],
pFTKeyInfo->Key[9], pFTKeyInfo->Key[10], pFTKeyInfo->Key[11], pFTKeyInfo->Key[12], pFTKeyInfo->Key[13], pFTKeyInfo->Key[14], pFTKeyInfo->Key[15]);
}
}
status = palSendMBMessage(pMac->hHdd, pMsg);
return( status );
}
/*
* TDLS request API, called from HDD to add a TDLS peer
*/
eHalStatus csrTdlsChangePeerSta(tHalHandle hHal, tANI_U8 sessionId, tSirMacAddr peerMac,
tCsrStaParams *pstaParams)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tSmeCmd *tdlsAddStaCmd ;
eHalStatus status = eHAL_STATUS_FAILURE ;
//If connected and in Infra. Only then allow this
if (CSR_IS_SESSION_VALID( pMac, sessionId ) &&
csrIsConnStateConnectedInfra( pMac, sessionId ) &&
(NULL != peerMac)){
tdlsAddStaCmd = csrGetCommandBuffer(pMac) ;
if (tdlsAddStaCmd)
{
tTdlsAddStaCmdInfo *tdlsAddStaCmdInfo =
&tdlsAddStaCmd->u.tdlsCmd.u.tdlsAddStaCmdInfo ;
vos_mem_zero(&tdlsAddStaCmd->u.tdlsCmd, sizeof(tTdlsCmd));
tdlsAddStaCmdInfo->tdlsAddOper = TDLS_OPER_UPDATE;
tdlsAddStaCmd->sessionId = sessionId;
palCopyMemory(pMac->hHdd, tdlsAddStaCmdInfo->peerMac,
peerMac, sizeof(tSirMacAddr)) ;
tdlsAddStaCmdInfo->capability = pstaParams->capability;
tdlsAddStaCmdInfo->uapsdQueues = pstaParams->uapsd_queues;
tdlsAddStaCmdInfo->maxSp = pstaParams->max_sp;
palCopyMemory(pMac->hHdd, tdlsAddStaCmdInfo->extnCapability,
pstaParams->extn_capability,
sizeof(pstaParams->extn_capability));
tdlsAddStaCmdInfo->htcap_present = pstaParams->htcap_present;
if(pstaParams->htcap_present)
palCopyMemory(pMac->hHdd, &tdlsAddStaCmdInfo->HTCap,
&pstaParams->HTCap, sizeof(pstaParams->HTCap));
else
palZeroMemory(pMac->hHdd, &tdlsAddStaCmdInfo->HTCap, sizeof(pstaParams->HTCap));
tdlsAddStaCmdInfo->vhtcap_present = pstaParams->vhtcap_present;
if(pstaParams->vhtcap_present)
palCopyMemory(pMac->hHdd, &tdlsAddStaCmdInfo->VHTCap,
&pstaParams->VHTCap, sizeof(pstaParams->VHTCap));
else
palZeroMemory(pMac->hHdd, &tdlsAddStaCmdInfo->VHTCap, sizeof(pstaParams->VHTCap));
tdlsAddStaCmdInfo->supportedRatesLen = pstaParams->supported_rates_len;
if (0 != pstaParams->supported_rates_len)
palCopyMemory(pMac->hHdd, &tdlsAddStaCmdInfo->supportedRates,
pstaParams->supported_rates,
pstaParams->supported_rates_len);
tdlsAddStaCmd->command = eSmeCommandTdlsAddPeer;
tdlsAddStaCmd->u.tdlsCmd.size = sizeof(tTdlsAddStaCmdInfo) ;
smePushCommand(pMac, tdlsAddStaCmd, FALSE) ;
status = eHAL_STATUS_SUCCESS ;
}
}
return status ;
}
/*--------------------------------------------------------------------------
\brief peCreateSession() - creates a new PE session given the BSSID
This function returns the session context and the session ID if the session
corresponding to the passed BSSID is found in the PE session table.
\param pMac - pointer to global adapter context
\param bssid - BSSID of the new session
\param sessionId -session ID is returned here, if session is created.
\return tpPESession - pointer to the session context or NULL if session can not be created.
\sa
--------------------------------------------------------------------------*/
tpPESession peCreateSession(tpAniSirGlobal pMac, tANI_U8 *bssid , tANI_U8* sessionId, tANI_U16 numSta)
{
tANI_U8 i;
for(i =0; i < pMac->lim.maxBssId; i++)
{
/* Find first free room in session table */
if(pMac->lim.gpSession[i].valid == FALSE)
{
palZeroMemory(pMac, (void*)&pMac->lim.gpSession[i], sizeof(tPESession));
//Allocate space for Station Table for this session.
if (eHAL_STATUS_SUCCESS != palAllocateMemory(pMac->hHdd,
(void **) &pMac->lim.gpSession[i].dph.dphHashTable.pHashTable, sizeof(tpDphHashNode)*numSta))
{
limLog(pMac, LOGE, FL("memory allocate failed!\n"));
return NULL;
}
if (eHAL_STATUS_SUCCESS != palAllocateMemory(pMac->hHdd,
(void **) &pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray, sizeof(tDphHashNode)*numSta))
{
limLog(pMac, LOGE, FL("memory allocate failed!\n"));
palFreeMemory(pMac->hHdd,pMac->lim.gpSession[i].dph.dphHashTable.pHashTable);
return NULL;
}
pMac->lim.gpSession[i].dph.dphHashTable.size = numSta;
dphHashTableClassInit(pMac,
&pMac->lim.gpSession[i].dph.dphHashTable);
/* Copy the BSSID to the session table */
sirCopyMacAddr(pMac->lim.gpSession[i].bssId, bssid);
pMac->lim.gpSession[i].valid = TRUE;
/* Intialize the SME and MLM states to IDLE */
pMac->lim.gpSession[i].limMlmState = eLIM_MLM_IDLE_STATE;
pMac->lim.gpSession[i].limSmeState = eLIM_SME_IDLE_STATE;
pMac->lim.gpSession[i].limCurrentAuthType = eSIR_OPEN_SYSTEM;
peInitBeaconParams(pMac, &pMac->lim.gpSession[i]);
#ifdef WLAN_FEATURE_VOWIFI_11R
pMac->lim.gpSession[i].is11Rconnection = FALSE;
#endif
#ifdef FEATURE_WLAN_CCX
pMac->lim.gpSession[i].isCCXconnection = FALSE;
#endif
#if defined WLAN_FEATURE_VOWIFI_11R || defined FEATURE_WLAN_CCX || defined(FEATURE_WLAN_LFR)
pMac->lim.gpSession[i].isFastTransitionEnabled = FALSE;
#endif
#ifdef FEATURE_WLAN_LFR
pMac->lim.gpSession[i].isFastRoamIniFeatureEnabled = FALSE;
#endif
*sessionId = i;
pMac->lim.gpSession[i].gLimPhyMode = WNI_CFG_PHY_MODE_11G; //TODO :Check with the team what should be default mode
return(&pMac->lim.gpSession[i]);
}
}
limLog(pMac, LOGE, FL("Session can not be created.. Reached Max permitted sessions \n "));
return NULL;
}