/**
* 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
pBeaconStruct = vos_mem_malloc(sizeof(tSirProbeRespBeacon));
if ( NULL == pBeaconStruct )
{
limLog(pMac, LOGE, FL("Unable to allocate memory in limExtractApCapability") );
return;
}
vos_mem_set( (tANI_U8 *) pBeaconStruct, sizeof(tSirProbeRespBeacon), 0);
*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)
void
limDeletePreAuthNode(tpAniSirGlobal pMac, tSirMacAddr macAddr)
{
struct tLimPreAuthNode *pPrevNode, *pTempNode;
pTempNode = pPrevNode = pMac->lim.pLimPreAuthList;
if (pTempNode == NULL)
return;
if (vos_mem_compare( (tANI_U8 *) macAddr,
(tANI_U8 *) &pTempNode->peerMacAddr,
sizeof(tSirMacAddr)) )
{
// First node to be deleted
pMac->lim.pLimPreAuthList = pTempNode->next;
limLog(pMac, LOG1, FL(" first node to delete"));
limLog(pMac, LOG1,
FL(" Release data entry:%p idx %d peer: " MAC_ADDRESS_STR),
pTempNode, pTempNode->authNodeIdx,
MAC_ADDR_ARRAY(macAddr));
limReleasePreAuthNode(pMac, pTempNode);
return;
}
pTempNode = pTempNode->next;
while (pTempNode != NULL)
{
if (vos_mem_compare( (tANI_U8 *) macAddr,
(tANI_U8 *) &pTempNode->peerMacAddr,
sizeof(tSirMacAddr)) )
{
// Found node to be deleted
pPrevNode->next = pTempNode->next;
limLog(pMac, LOG1, FL(" subsequent node to delete"));
limLog(pMac, LOG1,
FL("Release data entry: %p id %d peer: "MAC_ADDRESS_STR),
pTempNode, pTempNode->authNodeIdx, MAC_ADDR_ARRAY(macAddr));
limReleasePreAuthNode(pMac, pTempNode);
return;
}
pPrevNode = pTempNode;
pTempNode = pTempNode->next;
}
// Should not be here
// Log error
limLog(pMac, LOGP, FL("peer not found in pre-auth list, addr= "));
limPrintMacAddr(pMac, macAddr, LOGP);
} /*** end limDeletePreAuthNode() ***/
inline static tSirRetStatus
limInitMeasResources(tpAniSirGlobal pMac)
{
tANI_U32 val;
tANI_U32 beaconInterval;
// Create Meas related timers only when
// periodic measurements are enabled
if (pMac->lim.gpLimMeasReq->measControl.periodicMeasEnabled)
{
val = SYS_MS_TO_TICKS(pMac->lim.gpLimMeasReq->measIndPeriod);
if (tx_timer_create(
&pMac->lim.gLimMeasParams.measurementIndTimer,
"Meas Ind TIMEOUT",
limTimerHandler,
SIR_LIM_MEASUREMENT_IND_TIMEOUT,
val,
val,
TX_NO_ACTIVATE) != TX_SUCCESS)
{
/// Could not create MeasInd timer.
// Log error
limLog(pMac, LOGP, FL("call to create MeasInd timer failed\n"));
return eSIR_SYS_TX_TIMER_CREATE_FAILED;
}
pMac->lim.gLimMeasParams.isMeasIndTimerActive = 0;
PELOG3(limLog(pMac, LOG3, FL("MeasurementIndication timer initialized, period = %d\n"),
pMac->lim.gpLimMeasReq->measIndPeriod);)
void
limProcessProbeRspFrame(tpAniSirGlobal pMac, tANI_U8 *pRxPacketInfo,tpPESession psessionEntry)
{
tANI_U8 *pBody;
tANI_U32 frameLen = 0;
tSirMacAddr currentBssId;
tpSirMacMgmtHdr pHdr;
tSirProbeRespBeacon *pProbeRsp;
tANI_U8 qosEnabled = false;
tANI_U8 wmeEnabled = false;
if(eHAL_STATUS_SUCCESS != palAllocateMemory(pMac->hHdd,
(void **)&pProbeRsp, sizeof(tSirProbeRespBeacon)))
{
limLog(pMac, LOGE, FL("Unable to PAL allocate memory in limProcessProbeRspFrame") );
return;
}
pProbeRsp->ssId.length = 0;
pProbeRsp->wpa.length = 0;
pProbeRsp->propIEinfo.apName.length = 0;
pHdr = WDA_GET_RX_MAC_HEADER(pRxPacketInfo);
PELOG2(limLog(pMac, LOG2,
FL("Received Probe Response frame with length=%d from "),
WDA_GET_RX_MPDU_LEN(pRxPacketInfo));
limPrintMacAddr(pMac, pHdr->sa, LOG2);)
if (limDeactivateMinChannelTimerDuringScan(pMac) != eSIR_SUCCESS)
/*----------------------------------------------------------------------------
*
* This function forms message for cancel of remain on channel. This message
* is added as data of Vendor Specific information element of debug marker
* frame.Message will be in form "CANCEL-REMAIN-ON-CHANNEL<first/second-frame>"
* "-SEQ=<sequence-num>"
*
*----------------------------------------------------------------------------*/
eHalStatus limPrepareAndSendCancelRemainOnChannelMsg(tpAniSirGlobal pMac,
tANI_U8 id)
{
tANI_U8 *cancelRemainOnChannelMsg;
eHalStatus status = eHAL_STATUS_SUCCESS;
cancelRemainOnChannelMsg = vos_mem_malloc( REMAIN_ON_CHANNEL_MSG_SIZE );
if( NULL == cancelRemainOnChannelMsg )
{
limLog( pMac, LOGE,
FL( "Unable to allocate memory for end of"
" remain on channel message" ));
return eHAL_STATUS_FAILURE;
}
snprintf(cancelRemainOnChannelMsg, REMAIN_ON_CHANNEL_MSG_SIZE,
"CANCEL-REMAIN-ON-CHANNEL%d-SEQ=%d",
id, pMac->lim.remOnChnSeqNum);
if( eSIR_FAILURE == limSendRemainOnChannelDebugMarkerFrame(pMac,
cancelRemainOnChannelMsg) )
{
limLog( pMac, LOGE,
"%s: Could not send %d marker frame to debug cancel"
" remain on channel", __func__, id);
status = eHAL_STATUS_FAILURE;
}
vos_mem_free( cancelRemainOnChannelMsg );
return status;
}
/*-------------------------------------------------------------------------
*
* This function forms message for start of remain on channel with channel
* number, duration and sequence number. This message is added as data of
* vendor specific information element of Debug Marker Frame. Message will
* be in form "START-REMAIN-ON-CHANNEL<first/second-frame>-CHN=<channel>"
* "-FOR-DUR=<duraion>-SEQ=<sequence-num>"
*
*-------------------------------------------------------------------------*/
eHalStatus limPrepareAndSendStartRemainOnChannelMsg(tpAniSirGlobal pMac,
tSirRemainOnChnReq *MsgRemainonChannel, tANI_U8 id)
{
tANI_U8 *startRemainOnChannelMsg;
eHalStatus status = eHAL_STATUS_SUCCESS;
startRemainOnChannelMsg = vos_mem_malloc( REMAIN_ON_CHANNEL_MSG_SIZE );
if( NULL == startRemainOnChannelMsg )
{
limLog(pMac, LOGE,
FL("Unable to allocate memory for remain on channel message"));
return eHAL_STATUS_FAILURE;
}
snprintf(startRemainOnChannelMsg, REMAIN_ON_CHANNEL_MSG_SIZE,
"START-REMAIN-ON-CHANNEL%d-CHN=%d-FOR-DUR=%d-SEQ=%d",
id, MsgRemainonChannel->chnNum, MsgRemainonChannel->duration,
pMac->lim.remOnChnSeqNum);
if( eSIR_FAILURE == limSendRemainOnChannelDebugMarkerFrame(pMac,
startRemainOnChannelMsg) )
{
limLog( pMac, LOGE,
"%s: Could not send %d debug marker frame at start"
" of remain on channel", __func__, id);
status = eHAL_STATUS_FAILURE;
}
vos_mem_free( startRemainOnChannelMsg );
return status;
}
/*------------------------------------------------------------------
*
* Below function is callback function, it is called when
* WDA_SET_LINK_STATE_RSP is received from WDI. callback function for
* P2P of limSetLinkState
*
*------------------------------------------------------------------*/
void limSetLinkStateP2PCallback(tpAniSirGlobal pMac, void *callbackArg)
{
tSirRemainOnChnReq *MsgRemainonChannel = pMac->lim.gpLimRemainOnChanReq;
//Send Ready on channel indication to SME
if(pMac->lim.gpLimRemainOnChanReq)
{
limSendSmeRsp(pMac, eWNI_SME_REMAIN_ON_CHN_RDY_IND, eHAL_STATUS_SUCCESS,
pMac->lim.gpLimRemainOnChanReq->sessionId, 0);
if(pMac->lim.gDebugP2pRemainOnChannel)
{
if( eHAL_STATUS_SUCCESS == limPrepareAndSendStartRemainOnChannelMsg(
pMac,
MsgRemainonChannel,
REMAIN_ON_CHANNEL_SECOND_MARKER_FRAME) )
{
limLog( pMac, LOGE,
"%s: Successfully sent 2nd Marker frame "
"seq num = %d on start ROC", __func__,
pMac->lim.remOnChnSeqNum);
}
}
}
else
{
//This is possible in case remain on channel is aborted
limLog( pMac, LOGE, FL(" NULL pointer of gpLimRemainOnChanReq") );
}
}
/** ----------------------------------------------------------------------
\fn limSelectsBackgroundScanMode()
\brief This function is called by limIsBackgroundScanAllowed().
\ Here LIM decides whether we shall enforce this background
\ scan or let HAL decide whether to proceed with the background
\ scan as HAL sees fits. LIM shall enforce background scan if:
\ 1) station is not in link established state
\ 2) station is in link established state, but there has been
\ max number of consecutive background scan failure.
\
\param tpAniSirGlobal pMac
\return none
\ ------------------------------------------------------------------------- */
tSirBackgroundScanMode limSelectsBackgroundScanMode(tpAniSirGlobal pMac)
{
tANI_U32 cfgVal;
if (wlan_cfgGetInt(pMac, WNI_CFG_MAX_CONSECUTIVE_BACKGROUND_SCAN_FAILURE, &cfgVal) != eSIR_SUCCESS)
{
limLog(pMac, LOGP, FL("Fail to get WNI_CFG_MAX_CONSECUTIVE_BACKGROUND_SCAN_FAILURE value\n"));
return eSIR_NORMAL_BACKGROUND_SCAN;
}
if (cfgVal == 0)
return eSIR_NORMAL_BACKGROUND_SCAN;
/* If the "number of consecutive background scan failure"
* exceeds the maximum allowed, then LIM shall trigger an
* aggressive background scan.
*/
if (pMac->lim.gLimNumOfConsecutiveBkgndScanFailure >= cfgVal)
{
pMac->lim.gLimNumOfForcedBkgndScan += 1;
limLog(pMac, LOGE,
FL("Had %d consec scan fail(when expect < %d). Trigger AGGRESSIVE bkgnd scan.\n"),
pMac->lim.gLimNumOfConsecutiveBkgndScanFailure, cfgVal);
return eSIR_AGGRESSIVE_BACKGROUND_SCAN;
}
return eSIR_NORMAL_BACKGROUND_SCAN;
}
static tANI_U8
limIsRSNieValidInSmeReqMessage(tpAniSirGlobal pMac, tpSirRSNie pRSNie)
{
tANI_U8 startPos = 0;
tANI_U32 privacy, val;
int len;
if (wlan_cfgGetInt(pMac, WNI_CFG_PRIVACY_ENABLED,
&privacy) != eSIR_SUCCESS)
{
limLog(pMac, LOGP,
FL("Unable to retrieve POI from CFG"));
}
if (wlan_cfgGetInt(pMac, WNI_CFG_RSN_ENABLED,
&val) != eSIR_SUCCESS)
{
limLog(pMac, LOGP,
FL("Unable to retrieve RSN_ENABLED from CFG"));
}
if (pRSNie->length && (!privacy || !val))
{
// Privacy & RSN not enabled in CFG.
/**
* In order to allow mixed mode for Guest access
* allow BSS creation/join with no Privacy capability
* yet advertising WPA IE
*/
PELOG1(limLog(pMac, LOG1, FL("RSN ie len %d but PRIVACY %d RSN %d"),
pRSNie->length, privacy, val);)
}
/*------------------------------------------------------------------
*
* Below function is called if pMac->fP2pListenOffload enabled and hdd
* requests a remain on channel.
*
*------------------------------------------------------------------*/
static eHalStatus limSendHalReqRemainOnChanOffload(tpAniSirGlobal pMac,
tSirRemainOnChnReq *pRemOnChnReq)
{
tSirScanOffloadReq *pScanOffloadReq;
tSirMsgQ msg;
tSirRetStatus rc = eSIR_SUCCESS;
tANI_U8 bssid[SIR_MAC_ADDR_LENGTH] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
pScanOffloadReq = vos_mem_malloc(sizeof(tSirScanOffloadReq));
if (NULL == pScanOffloadReq)
{
limLog(pMac, LOGE,
FL("Memory allocation failed for pScanOffloadReq"));
return eHAL_STATUS_FAILURE;
}
vos_mem_zero(pScanOffloadReq, sizeof(tSirScanOffloadReq));
msg.type = WDA_START_SCAN_OFFLOAD_REQ;
msg.bodyptr = pScanOffloadReq;
msg.bodyval = 0;
vos_mem_copy((tANI_U8 *) pScanOffloadReq->selfMacAddr,
(tANI_U8 *) pRemOnChnReq->selfMacAddr,
sizeof(tSirMacAddr));
vos_mem_copy((tANI_U8 *) pScanOffloadReq->bssId,
(tANI_U8 *) bssid,
sizeof(tSirMacAddr));
pScanOffloadReq->scanType = eSIR_PASSIVE_SCAN;
pScanOffloadReq->p2pScanType = P2P_SCAN_TYPE_LISTEN;
pScanOffloadReq->minChannelTime = pRemOnChnReq->duration;
pScanOffloadReq->maxChannelTime = pRemOnChnReq->duration;
pScanOffloadReq->sessionId = pRemOnChnReq->sessionId;
pScanOffloadReq->channelList.numChannels = 1;
pScanOffloadReq->channelList.channelNumber[0] = pRemOnChnReq->chnNum;
limLog(pMac, LOG1,
FL("Req-rem-on-channel: duration %u, session %hu, chan %hu"),
pRemOnChnReq->duration, pRemOnChnReq->sessionId,
pRemOnChnReq->chnNum);
rc = wdaPostCtrlMsg(pMac, &msg);
if (rc != eSIR_SUCCESS)
{
limLog(pMac, LOGE, FL("wdaPostCtrlMsg() return failure %u"),
rc);
vos_mem_free(pScanOffloadReq);
return eHAL_STATUS_FAILURE;
}
pMac->lim.fOffloadScanPending = 1;
pMac->lim.fOffloadScanP2PListen = 1;
return eHAL_STATUS_SUCCESS;
}
/**
* rrmCacheMgmtTxPower
**
* FUNCTION: Store Tx power for management frames.
*
* LOGIC:
*
* ASSUMPTIONS:
*
* NOTE:
*
* @param pSessionEntry session entry.
* @return None
*/
void
rrmCacheMgmtTxPower ( tpAniSirGlobal pMac, tPowerdBm txPower, tpPESession pSessionEntry )
{
limLog( pMac, LOG3, "Cache Mgmt Tx Power = %d", txPower );
if( pSessionEntry == NULL )
{
limLog( pMac, LOG3, "%s: pSessionEntry is NULL", __func__);
pMac->rrm.rrmPEContext.txMgmtPower = txPower;
}
else
pSessionEntry->txMgmtPower = txPower;
}
/**
* rrmGetMgmtTxPower
*
* FUNCTION: Get the Tx power for management frames.
*
* LOGIC:
*
* ASSUMPTIONS:
*
* NOTE:
*
* @param pSessionEntry session entry.
* @return txPower
*/
tPowerdBm
rrmGetMgmtTxPower ( tpAniSirGlobal pMac, tpPESession pSessionEntry )
{
limLog( pMac, LOG3, "RrmGetMgmtTxPower called" );
if( pSessionEntry == NULL )
{
limLog( pMac, LOG3, "%s: txpower from rrmPEContext: %d",
__func__, pMac->rrm.rrmPEContext.txMgmtPower);
return pMac->rrm.rrmPEContext.txMgmtPower;
}
return pSessionEntry->txMgmtPower;
}
/*--------------------------------------------------------------------------
\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.
\param bssType - station or a
\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,
tSirBssType bssType)
{
VOS_STATUS status;
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)
{
vos_mem_set((void*)&pMac->lim.gpSession[i], sizeof(tPESession), 0);
//Allocate space for Station Table for this session.
pMac->lim.gpSession[i].dph.dphHashTable.pHashTable = vos_mem_malloc(
sizeof(tpDphHashNode)* (numSta + 1));
if ( NULL == pMac->lim.gpSession[i].dph.dphHashTable.pHashTable )
{
limLog(pMac, LOGE, FL("memory allocate failed!"));
return NULL;
}
pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray = vos_mem_malloc(
sizeof(tDphHashNode) * (numSta + 1));
if ( NULL == pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray )
{
limLog(pMac, LOGE, FL("memory allocate failed!"));
vos_mem_free(pMac->lim.gpSession[i].dph.dphHashTable.pHashTable);
pMac->lim.gpSession[i].dph.dphHashTable.pHashTable = NULL;
return NULL;
}
pMac->lim.gpSession[i].dph.dphHashTable.size = numSta + 1;
dphHashTableClassInit(pMac,
&pMac->lim.gpSession[i].dph.dphHashTable);
pMac->lim.gpSession[i].gpLimPeerIdxpool = vos_mem_malloc(sizeof(
*pMac->lim.gpSession[i].gpLimPeerIdxpool) * (numSta+1));
if ( NULL == pMac->lim.gpSession[i].gpLimPeerIdxpool )
{
PELOGE(limLog(pMac, LOGE, FL("memory allocate failed!"));)
vos_mem_free(pMac->lim.gpSession[i].dph.dphHashTable.pHashTable);
vos_mem_free(pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray);
pMac->lim.gpSession[i].dph.dphHashTable.pHashTable = NULL;
pMac->lim.gpSession[i].dph.dphHashTable.pDphNodeArray = NULL;
return NULL;
}
/*--------------------------------------------------------------------------
\brief peFindSessionBySessionId() - looks up the PE session given the session ID.
This function returns the session context if the session
corresponding to the given session ID is found in the PE session table.
\param pMac - pointer to global adapter context
\param sessionId -session ID for which session context needs to be looked up.
\return tpPESession - pointer to the session context or NULL if session is not found.
\sa
--------------------------------------------------------------------------*/
tpPESession peFindSessionBySessionId(tpAniSirGlobal pMac , tANI_U8 sessionId)
{
if(sessionId >= pMac->lim.maxBssId)
{
limLog(pMac, LOGE, FL("Invalid sessionId: %d \n "), sessionId);
return(NULL);
}
if((pMac->lim.gpSession[sessionId].valid == TRUE))
{
return(&pMac->lim.gpSession[sessionId]);
}
limLog(pMac, LOG1, FL("Session %d not active\n "), sessionId);
return(NULL);
}
tANI_U8
isLimSessionOffChannel(tpAniSirGlobal pMac, tANI_U8 sessionId)
{
tANI_U8 i;
if(sessionId >= pMac->lim.maxBssId)
{
limLog(pMac, LOGE, FL("Invalid sessionId: %d \n "), sessionId);
return FALSE;
}
for(i =0; i < pMac->lim.maxBssId; i++)
{
if( i == sessionId )
{
continue;
}
if( (pMac->lim.gpSession[i].valid) &&
(pMac->lim.gpSession[i].currentOperChannel !=
pMac->lim.gpSession[sessionId].currentOperChannel) )
{
return TRUE;
}
}
return FALSE;
}
tANI_U8
isLimSessionOffChannel(tpAniSirGlobal pMac, tANI_U8 sessionId)
{
tANI_U8 i;
if(sessionId >= pMac->lim.maxBssId)
{
limLog(pMac, LOGE, FL("Invalid sessionId: %d \n "), sessionId);
return FALSE;
}
for(i =0; i < pMac->lim.maxBssId; i++)
{
if( i == sessionId )
{
//Skip the sessionId that is to be joined.
continue;
}
//if another ession is valid and it is on different channel
//it is an off channel operation.
if( (pMac->lim.gpSession[i].valid) &&
(pMac->lim.gpSession[i].currentOperChannel !=
pMac->lim.gpSession[sessionId].currentOperChannel) )
{
return TRUE;
}
}
return FALSE;
}
/**
* limProcessDisassocFrame
*
*FUNCTION:
* This function is called by limProcessMessageQueue() upon
* Disassociation frame reception.
*
*LOGIC:
*
*ASSUMPTIONS:
* DPH drops packets for STA with 'valid' bit in pStaDs set to '0'.
*
*NOTE:
*
* @param pMac - Pointer to Global MAC structure
* @param *pRxPacketInfo - A pointer to Rx packet info structure
* @return None
*/
void
limProcessDisassocFrame(tpAniSirGlobal pMac, tANI_U8 *pRxPacketInfo, tpPESession psessionEntry)
{
tANI_U8 *pBody;
tANI_U16 aid, reasonCode;
tpSirMacMgmtHdr pHdr;
tpDphHashNode pStaDs;
tLimMlmDisassocInd mlmDisassocInd;
#ifdef WLAN_FEATURE_11W
tANI_U32 frameLen;
#endif
int8_t frame_rssi;
pHdr = WDA_GET_RX_MAC_HEADER(pRxPacketInfo);
pBody = WDA_GET_RX_MPDU_DATA(pRxPacketInfo);
frame_rssi = (int8_t)WDA_GET_RX_RSSI_NORMALIZED(pRxPacketInfo);
if (limIsGroupAddr(pHdr->sa))
{
// Received Disassoc frame from a BC/MC address
// Log error and ignore it
PELOGE(limLog(pMac, LOGE,
FL("received Disassoc frame from a BC/MC address"));)
return;
void
limProcessProbeRspFrame(tpAniSirGlobal pMac, tANI_U8 *pRxPacketInfo,tpPESession psessionEntry)
{
tANI_U8 *pBody;
tANI_U32 frameLen = 0;
tSirMacAddr currentBssId;
tpSirMacMgmtHdr pHdr;
tSirProbeRespBeacon probeRsp;
tANI_U8 qosEnabled = false;
tANI_U8 wmeEnabled = false;
probeRsp.ssId.length = 0;
probeRsp.wpa.length = 0;
probeRsp.propIEinfo.apName.length = 0;
#if (WNI_POLARIS_FW_PACKAGE == ADVANCED)
probeRsp.propIEinfo.aniIndicator = 0;
probeRsp.propIEinfo.wdsLength = 0;
#endif
pHdr = WDA_GET_RX_MAC_HEADER(pRxPacketInfo);
PELOG2(limLog(pMac, LOG2,
FL("Received Probe Response frame with length=%d from "),
WDA_GET_RX_MPDU_LEN(pRxPacketInfo));
limPrintMacAddr(pMac, pHdr->sa, LOG2);)
if (limDeactivateMinChannelTimerDuringScan(pMac) != eSIR_SUCCESS)
static tSirRetStatus
limCalculateSvcInt(
tpAniSirGlobal pMac,
tSirMacTspecIE *pTspec,
tANI_U32 *pSvcInt)
{
tANI_U32 msduSz, dataRate;
*pSvcInt = 0;
if ((pTspec->minSvcInterval != 0) || (pTspec->maxSvcInterval != 0))
{
*pSvcInt = (pTspec->maxSvcInterval != 0)
? pTspec->maxSvcInterval : pTspec->minSvcInterval;
return eSIR_SUCCESS;
}
if (pTspec->nomMsduSz != 0)
msduSz = (pTspec->nomMsduSz & 0x7fff);
else if (pTspec->maxMsduSz != 0)
msduSz = pTspec->maxMsduSz;
else
{
PELOGE(limLog(pMac, LOGE, FL("MsduSize not specified"));)
return eSIR_FAILURE;
}
void
limProcessDeauthFrame(tpAniSirGlobal pMac, tANI_U8 *pRxPacketInfo, tpPESession psessionEntry)
{
tANI_U8 *pBody;
tANI_U16 aid, reasonCode;
tpSirMacMgmtHdr pHdr;
tLimMlmAssocCnf mlmAssocCnf;
tLimMlmDeauthInd mlmDeauthInd;
tpDphHashNode pStaDs;
tpPESession pRoamSessionEntry=NULL;
tANI_U8 roamSessionId;
#ifdef WLAN_FEATURE_11W
tANI_U32 frameLen;
#endif
pHdr = WDA_GET_RX_MAC_HEADER(pRxPacketInfo);
pBody = WDA_GET_RX_MPDU_DATA(pRxPacketInfo);
if ((eLIM_STA_ROLE == psessionEntry->limSystemRole) && (eLIM_SME_WT_DEAUTH_STATE == psessionEntry->limSmeState))
{
/*Every 15th deauth frame will be logged in kmsg*/
if(!(pMac->lim.deauthMsgCnt & 0xF))
{
PELOGE(limLog(pMac, LOGE,
FL("received Deauth frame in DEAUTH_WT_STATE"
"(already processing previously received DEAUTH frame).."
"Dropping this.. Deauth Failed %d"),++pMac->lim.deauthMsgCnt);)
}
else
{
tANI_U32
limDeactivateMinChannelTimerDuringScan(tpAniSirGlobal pMac)
{
if ((pMac->lim.gLimMlmState == eLIM_MLM_WT_PROBE_RESP_STATE) && (pMac->lim.gLimHalScanState == eLIM_HAL_SCANNING_STATE))
{
/**
* Beacon/Probe Response is received during active scanning.
* Deactivate MIN channel timer if running.
*/
limDeactivateAndChangeTimer(pMac,eLIM_MIN_CHANNEL_TIMER);
MTRACE(macTrace(pMac, TRACE_CODE_TIMER_ACTIVATE, NO_SESSION, eLIM_MAX_CHANNEL_TIMER));
if (tx_timer_activate(&pMac->lim.limTimers.gLimMaxChannelTimer)
== TX_TIMER_ERROR)
{
/// Could not activate max channel timer.
// Log error
limLog(pMac,LOGP, FL("could not activate max channel timer"));
limCompleteMlmScan(pMac, eSIR_SME_RESOURCES_UNAVAILABLE);
return TX_TIMER_ERROR;
}
}
return eSIR_SUCCESS;
} /*** end limDeactivateMinChannelTimerDuringScan() ***/
static tSirRetStatus
limCalculateSvcInt(
tpAniSirGlobal pMac,
tSirMacTspecIE *pTspec,
tANI_U32 *pSvcInt)
{
tANI_U32 msduSz, dataRate;
*pSvcInt = 0;
// if a service interval is already specified, we are done
if ((pTspec->minSvcInterval != 0) || (pTspec->maxSvcInterval != 0))
{
*pSvcInt = (pTspec->maxSvcInterval != 0)
? pTspec->maxSvcInterval : pTspec->minSvcInterval;
return eSIR_SUCCESS;
}
/* Masking off the fixed bits according to definition of MSDU size
* in IEEE 802.11-2007 spec (section 7.3.2.30). Nominal MSDU size
* is defined as: Bit[0:14]=Size, Bit[15]=Fixed
*/
if (pTspec->nomMsduSz != 0)
msduSz = (pTspec->nomMsduSz & 0x7fff);
else if (pTspec->maxMsduSz != 0)
msduSz = pTspec->maxMsduSz;
else
{
PELOGE(limLog(pMac, LOGE, FL("MsduSize not specified"));)
return eSIR_FAILURE;
}
tSirRetStatus limGetStaHashBssidx(tpAniSirGlobal pMac, tANI_U16 assocId, tANI_U8 *bssidx, tpPESession psessionEntry)
{
tpDphHashNode pSta = dphGetHashEntry(pMac, assocId, &psessionEntry->dph.dphHashTable);
if (pSta == NULL)
{
PELOGE(limLog(pMac, LOGE, FL("invalid STA %d"), assocId);)
return eSIR_LIM_INVALID_STA;
static void
limSetDefaultKeyIdAndKeys(tpAniSirGlobal pMac)
{
#ifdef FIXME_GEN6
tANI_U32 val;
tANI_U32 dkCfgId;
PELOG1(limLog(pMac, LOG1, FL("Setting default keys at SP"));)
if (wlan_cfgGetInt(pMac, WNI_CFG_WEP_DEFAULT_KEYID,
void macTrace(tpAniSirGlobal pMac, tANI_U8 code, tANI_U8 session, tANI_U32 data)
{
//Today macTrace is being invoked by PE only, need to remove this function once PE is migrated to using new trace API.
macTraceNew(pMac, VOS_MODULE_ID_PE, code, session, data);
#if 0
tpTraceRecord rec = NULL;
//limLog(pMac, LOGE, "mac Trace code: %d, data: %x, head: %d, tail: %d\n", code, data, gTraceData.head, gTraceData.tail);
if(!gTraceData.enable)
return;
gTraceData.num++;
if (gTraceData.head == INVALID_TRACE_ADDR)
{
/* first record */
gTraceData.head = 0;
gTraceData.tail = 0;
}
else
{
/* queue is not empty */
tANI_U32 tail = gTraceData.tail + 1;
if (tail == MAX_TRACE_RECORDS)
tail = 0;
if (gTraceData.head == tail)
{
/* full */
if (++gTraceData.head == MAX_TRACE_RECORDS)
gTraceData.head = 0;
}
gTraceData.tail = tail;
}
rec = &gTraceTbl[gTraceData.tail];
rec->code = code;
rec->session = session;
rec->data = data;
rec->time = vos_timer_get_system_time();
rec->module = VOS_MODULE_ID_PE;
gTraceData.numSinceLastDump ++;
if(gTraceData.numSinceLastDump == gTraceData.dumpCount)
{
limLog(pMac, LOGE, "Trace Dump last %d traces\n", gTraceData.dumpCount);
macTraceDumpAll(pMac, 0, 0, gTraceData.dumpCount);
gTraceData.numSinceLastDump = 0;
}
#endif
}
void macTrace(tpAniSirGlobal pMac, tANI_U8 code, tANI_U8 session, tANI_U32 data)
{
macTraceNew(pMac, VOS_MODULE_ID_PE, code, session, data);
#if 0
tpTraceRecord rec = NULL;
if(!gTraceData.enable)
return;
gTraceData.num++;
if (gTraceData.head == INVALID_TRACE_ADDR)
{
gTraceData.head = 0;
gTraceData.tail = 0;
}
else
{
tANI_U32 tail = gTraceData.tail + 1;
if (tail == MAX_TRACE_RECORDS)
tail = 0;
if (gTraceData.head == tail)
{
if (++gTraceData.head == MAX_TRACE_RECORDS)
gTraceData.head = 0;
}
gTraceData.tail = tail;
}
rec = &gTraceTbl[gTraceData.tail];
rec->code = code;
rec->session = session;
rec->data = data;
rec->time = vos_timer_get_system_time();
rec->module = VOS_MODULE_ID_PE;
gTraceData.numSinceLastDump ++;
if(gTraceData.numSinceLastDump == gTraceData.dumpCount)
{
limLog(pMac, LOGE, "Trace Dump last %d traces\n", gTraceData.dumpCount);
macTraceDumpAll(pMac, 0, 0, gTraceData.dumpCount);
gTraceData.numSinceLastDump = 0;
}
#endif
}
/**
* rrmSendSetMaxTxPowerReq
*
* FUNCTION: Send WDA_SET_MAX_TX_POWER_REQ message to change the max tx power.
*
* LOGIC:
*
* ASSUMPTIONS:
*
* NOTE:
*
* @param txPower txPower to be set.
* @param pSessionEntry session entry.
* @return None
*/
tSirRetStatus
rrmSendSetMaxTxPowerReq ( tpAniSirGlobal pMac, tPowerdBm txPower, tpPESession pSessionEntry )
{
tpMaxTxPowerParams pMaxTxParams;
tSirRetStatus retCode = eSIR_SUCCESS;
tSirMsgQ msgQ;
if( pSessionEntry == NULL )
{
PELOGE(limLog(pMac, LOGE, FL("Invalid parameters"));)
return eSIR_FAILURE;
/** ---------------------------------------------------------
\fn limDeleteStaContext
\brief This function handles the message from HAL:
\ WDA_DELETE_STA_CONTEXT_IND. This function
\ validates that the given station id exist, and if so,
\ deletes the station by calling limTriggerSTAdeletion.
\param tpAniSirGlobal pMac
\param tpSirMsgQ limMsg
\return none
-----------------------------------------------------------*/
void
limDeleteStaContext(tpAniSirGlobal pMac, tpSirMsgQ limMsg)
{
tpDeleteStaContext pMsg = (tpDeleteStaContext)limMsg->bodyptr;
tpDphHashNode pStaDs;
tpPESession psessionEntry ;
if(NULL == pMsg)
{
PELOGE(limLog(pMac, LOGE,FL("Invalid body pointer in message"));)
return;
inline static tANI_BOOLEAN
limIsSmeMeasurementReqValid(tpAniSirGlobal pMac, tpSirSmeMeasurementReq pMeasReq)
{
#ifdef ANI_AP_SDK
if (!pMeasReq->channelList.numChannels ||
((pMeasReq->measControl.periodicMeasEnabled) &&
(!pMeasReq->measIndPeriod)) ||
(pMeasReq->measIndPeriod &&
((pMeasReq->measIndPeriod < 1))) ||
!pMeasReq->measDuration.shortTermPeriod ||
((pMeasReq->measDuration.shortTermPeriod < 1)) ||
!pMeasReq->measDuration.averagingPeriod ||
(pMeasReq->measDuration.averagingPeriod <
pMeasReq->measDuration.shortTermPeriod) ||
!pMeasReq->measDuration.shortChannelScanDuration ||
((pMeasReq->measDuration.shortChannelScanDuration <
1)) ||
!pMeasReq->measDuration.longChannelScanDuration ||
(pMeasReq->measDuration.longChannelScanDuration <
pMeasReq->measDuration.shortChannelScanDuration) ||
((pMeasReq->measDuration.longChannelScanDuration <
1)))
#else
if (!pMeasReq->channelList.numChannels ||
((pMeasReq->measControl.periodicMeasEnabled) &&
(!pMeasReq->measIndPeriod)) ||
(pMeasReq->measIndPeriod &&
((pMeasReq->measIndPeriod < SYS_TICK_DUR_MS))) ||
!pMeasReq->measDuration.shortTermPeriod ||
((pMeasReq->measDuration.shortTermPeriod < SYS_TICK_DUR_MS)) ||
!pMeasReq->measDuration.averagingPeriod ||
(pMeasReq->measDuration.averagingPeriod <
pMeasReq->measDuration.shortTermPeriod) ||
!pMeasReq->measDuration.shortChannelScanDuration ||
((pMeasReq->measDuration.shortChannelScanDuration <
SYS_TICK_DUR_MS)) ||
!pMeasReq->measDuration.longChannelScanDuration ||
(pMeasReq->measDuration.longChannelScanDuration <
pMeasReq->measDuration.shortChannelScanDuration) ||
((pMeasReq->measDuration.longChannelScanDuration <
SYS_TICK_DUR_MS)))
#endif
{
limLog(pMac, LOGW,
FL("Received MEASUREMENT_REQ with invalid data\n"));
return eANI_BOOLEAN_FALSE;
}
else
return eANI_BOOLEAN_TRUE;
} /*** end limIsSmeMeasurementReqValid() ***/
void
limProcessProbeRspFrame(tpAniSirGlobal pMac, tANI_U8 *pRxPacketInfo,tpPESession psessionEntry)
{
tANI_U8 *pBody;
tANI_U32 frameLen = 0;
tSirMacAddr currentBssId;
tpSirMacMgmtHdr pHdr;
tSirProbeRespBeacon *pProbeRsp;
tANI_U8 qosEnabled = false;
tANI_U8 wmeEnabled = false;
if (!psessionEntry)
{
limLog(pMac, LOGE, FL("psessionEntry is NULL") );
return;
}
limLog(pMac,LOG1,"SessionId:%d ProbeRsp Frame is received",
psessionEntry->peSessionId);
pProbeRsp = vos_mem_malloc(sizeof(tSirProbeRespBeacon));
if ( NULL == pProbeRsp )
{
limLog(pMac, LOGE, FL("Unable to allocate memory in limProcessProbeRspFrame") );
return;
}
pProbeRsp->ssId.length = 0;
pProbeRsp->wpa.length = 0;
pProbeRsp->propIEinfo.apName.length = 0;
pHdr = WDA_GET_RX_MAC_HEADER(pRxPacketInfo);
PELOG2(limLog(pMac, LOG2,
FL("Received Probe Response frame with length=%d from "),
WDA_GET_RX_MPDU_LEN(pRxPacketInfo));
limPrintMacAddr(pMac, pHdr->sa, LOG2);)
if (!pMac->fScanOffload)
