/**
* 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)
eHalStatus csrTdlsProcessAddSta( tpAniSirGlobal pMac, tSmeCmd *cmd )
{
tTdlsAddStaCmdInfo *tdlsAddStaCmdInfo = &cmd->u.tdlsCmd.u.tdlsAddStaCmdInfo ;
tSirTdlsAddStaReq *tdlsAddStaReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (NULL == pSession->pConnectBssDesc)
{
smsLog( pMac, LOGE, FL("BSS description is not present") );
return eHAL_STATUS_FAILURE;
}
status = palAllocateMemory( pMac->hHdd, (void **)&tdlsAddStaReq,
(sizeof(tSirTdlsAddStaReq) ) );
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("alloc failed") );
VOS_ASSERT(0) ;
return status ;
}
tdlsAddStaReq->sessionId = cmd->sessionId;
tdlsAddStaReq->tdlsAddOper = tdlsAddStaCmdInfo->tdlsAddOper;
//Using dialog as transactionId. This can be used to match response with request
tdlsAddStaReq->transactionId = 0;
palCopyMemory(pMac->hHdd, tdlsAddStaReq->bssid,
pSession->pConnectBssDesc->bssId, sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, tdlsAddStaReq->peerMac,
tdlsAddStaCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
tdlsAddStaReq->capability = tdlsAddStaCmdInfo->capability;
tdlsAddStaReq->uapsd_queues = tdlsAddStaCmdInfo->uapsdQueues;
tdlsAddStaReq->max_sp = tdlsAddStaCmdInfo->maxSp;
palCopyMemory(pMac->hHdd, tdlsAddStaReq->extn_capability,
tdlsAddStaCmdInfo->extnCapability,
SIR_MAC_MAX_EXTN_CAP);
tdlsAddStaReq->htcap_present = tdlsAddStaCmdInfo->htcap_present;
palCopyMemory(pMac->hHdd, &tdlsAddStaReq->htCap,
&tdlsAddStaCmdInfo->HTCap, sizeof(tdlsAddStaCmdInfo->HTCap));
tdlsAddStaReq->vhtcap_present = tdlsAddStaCmdInfo->vhtcap_present;
palCopyMemory(pMac->hHdd, &tdlsAddStaReq->vhtCap,
&tdlsAddStaCmdInfo->VHTCap, sizeof(tdlsAddStaCmdInfo->VHTCap));
tdlsAddStaReq->supported_rates_length = tdlsAddStaCmdInfo->supportedRatesLen;
palCopyMemory(pMac->hHdd, &tdlsAddStaReq->supported_rates,
tdlsAddStaCmdInfo->supportedRates, tdlsAddStaCmdInfo->supportedRatesLen);
// Send the request to PE.
smsLog( pMac, LOGE, "sending TDLS Add Sta req to PE " );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_ADD_STA_REQ,
(void *)tdlsAddStaReq , sizeof(tSirTdlsAddStaReq)) ;
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC"));
}
return status;
}
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)
/* ---------------------------------------------------------------------------
\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;
}
eHalStatus csrTdlsProcessSendMgmt( tpAniSirGlobal pMac, tSmeCmd *cmd )
{
tTdlsSendMgmtCmdInfo *tdlsSendMgmtCmdInfo = &cmd->u.tdlsCmd.u.tdlsSendMgmtCmdInfo ;
tSirTdlsSendMgmtReq *tdlsSendMgmtReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (NULL == pSession->pConnectBssDesc)
{
smsLog( pMac, LOGE, FL("BSS Description is not present") );
return eHAL_STATUS_FAILURE;
}
status = palAllocateMemory( pMac->hHdd, (void **)&tdlsSendMgmtReq,
(sizeof(tSirTdlsSendMgmtReq) + tdlsSendMgmtCmdInfo->len ) );
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("alloc failed") );
VOS_ASSERT(0) ;
return status ;
}
tdlsSendMgmtReq->sessionId = cmd->sessionId;
//Using dialog as transactionId. This can be used to match response with request
tdlsSendMgmtReq->transactionId = tdlsSendMgmtCmdInfo->dialog;
tdlsSendMgmtReq->reqType = tdlsSendMgmtCmdInfo->frameType ;
tdlsSendMgmtReq->dialog = tdlsSendMgmtCmdInfo->dialog ;
tdlsSendMgmtReq->statusCode = tdlsSendMgmtCmdInfo->statusCode ;
tdlsSendMgmtReq->responder = tdlsSendMgmtCmdInfo->responder;
palCopyMemory(pMac->hHdd, tdlsSendMgmtReq->bssid,
pSession->pConnectBssDesc->bssId, sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, tdlsSendMgmtReq->peerMac,
tdlsSendMgmtCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
if(tdlsSendMgmtCmdInfo->len && tdlsSendMgmtCmdInfo->buf)
{
palCopyMemory(pMac->hHdd, tdlsSendMgmtReq->addIe, tdlsSendMgmtCmdInfo->buf,
tdlsSendMgmtCmdInfo->len);
}
// Send the request to PE.
smsLog( pMac, LOG1, "sending TDLS Mgmt Frame req to PE " );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_SEND_MGMT_REQ,
(void *)tdlsSendMgmtReq , sizeof(tSirTdlsSendMgmtReq)+tdlsSendMgmtCmdInfo->len) ;
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC"));
}
if(tdlsSendMgmtCmdInfo->len && tdlsSendMgmtCmdInfo->buf)
{
//Done with the buf. Free it.
vos_mem_free( tdlsSendMgmtCmdInfo->buf );
tdlsSendMgmtCmdInfo->buf = NULL;
tdlsSendMgmtCmdInfo->len = 0;
}
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 ;
}
/*
* TDLS request API, called from HDD to send a TDLS frame
* in SME/CSR and send message to PE to trigger TDLS discovery procedure.
*/
eHalStatus csrTdlsSendMgmtReq(tHalHandle hHal, tANI_U8 sessionId, tCsrTdlsSendMgmt *tdlsSendMgmt)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tSmeCmd *tdlsSendMgmtCmd ;
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 != tdlsSendMgmt) )
{
tdlsSendMgmtCmd = csrGetCommandBuffer(pMac) ;
if(tdlsSendMgmtCmd)
{
tTdlsSendMgmtCmdInfo *tdlsSendMgmtCmdInfo =
&tdlsSendMgmtCmd->u.tdlsCmd.u.tdlsSendMgmtCmdInfo ;
vos_mem_zero(&tdlsSendMgmtCmd->u.tdlsCmd, sizeof(tTdlsCmd));
tdlsSendMgmtCmd->sessionId = sessionId;
tdlsSendMgmtCmdInfo->frameType = tdlsSendMgmt->frameType ;
tdlsSendMgmtCmdInfo->dialog = tdlsSendMgmt->dialog ;
tdlsSendMgmtCmdInfo->statusCode = tdlsSendMgmt->statusCode ;
tdlsSendMgmtCmdInfo->responder = tdlsSendMgmt->responder;
palCopyMemory(pMac->hHdd, tdlsSendMgmtCmdInfo->peerMac,
tdlsSendMgmt->peerMac, sizeof(tSirMacAddr)) ;
if( (0 != tdlsSendMgmt->len) && (NULL != tdlsSendMgmt->buf) )
{
status = palAllocateMemory( pMac->hHdd, (void **)&tdlsSendMgmtCmdInfo->buf,
tdlsSendMgmt->len );
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Alloc Failed") );
VOS_ASSERT(0) ;
return status ;
}
palCopyMemory(pMac->hHdd, tdlsSendMgmtCmdInfo->buf,
tdlsSendMgmt->buf, tdlsSendMgmt->len );
tdlsSendMgmtCmdInfo->len = tdlsSendMgmt->len;
}
else
{
tdlsSendMgmtCmdInfo->buf = NULL;
tdlsSendMgmtCmdInfo->len = 0;
}
tdlsSendMgmtCmd->command = eSmeCommandTdlsSendMgmt ;
tdlsSendMgmtCmd->u.tdlsCmd.size = sizeof(tTdlsSendMgmtCmdInfo) ;
smePushCommand(pMac, tdlsSendMgmtCmd, FALSE) ;
status = eHAL_STATUS_SUCCESS ;
}
}
return status ;
}
tSirRetStatus schSetFixedBeaconFields(tpAniSirGlobal pMac,tpPESession psessionEntry)
{
tpAniBeaconStruct pBeacon = (tpAniBeaconStruct)
pMac->sch.schObject.gSchBeaconFrameBegin;
tpSirMacMgmtHdr mac;
tANI_U16 offset;
tANI_U8 *ptr;
tDot11fBeacon1 *pBcn1;
tDot11fBeacon2 *pBcn2;
tANI_U32 i, nStatus, nBytes;
tANI_U32 wpsApEnable=0, tmp;
tDot11fIEWscProbeRes *pWscProbeRes;
tANI_U8 *pExtraIe = NULL;
tANI_U32 extraIeLen =0;
tANI_U16 extraIeOffset = 0;
tANI_U16 p2pIeOffset = 0;
tSirRetStatus status = eSIR_SUCCESS;
status = palAllocateMemory(pMac->hHdd, (void **)&pBcn1, sizeof(tDot11fBeacon1));
if(status != eSIR_SUCCESS)
{
schLog(pMac, LOGE, FL("Failed to allocate memory") );
return eSIR_FAILURE;
}
status = palAllocateMemory(pMac->hHdd, (void **)&pBcn2, sizeof(tDot11fBeacon2));
if(status != eSIR_SUCCESS)
{
schLog(pMac, LOGE, FL("Failed to allocate memory") );
palFreeMemory(pMac->hHdd, pBcn1);
return eSIR_FAILURE;
}
status = palAllocateMemory(pMac->hHdd, (void **)&pWscProbeRes, sizeof(tDot11fIEWscProbeRes));
if(status != eSIR_SUCCESS)
{
schLog(pMac, LOGE, FL("Failed to allocate memory") );
palFreeMemory(pMac->hHdd, pBcn1);
palFreeMemory(pMac->hHdd, pBcn2);
return eSIR_FAILURE;
}
PELOG1(schLog(pMac, LOG1, FL("Setting fixed beacon fields"));)
eHalStatus csrTdlsProcessDelSta( tpAniSirGlobal pMac, tSmeCmd *cmd )
{
tTdlsDelStaCmdInfo *tdlsDelStaCmdInfo = &cmd->u.tdlsCmd.u.tdlsDelStaCmdInfo ;
tSirTdlsDelStaReq *tdlsDelStaReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (NULL == pSession)
{
return eHAL_STATUS_FAILURE;
}
if (NULL == pSession->pConnectBssDesc)
{
smsLog( pMac, LOGE, FL("BSS description is not present") );
return eHAL_STATUS_FAILURE;
}
status = palAllocateMemory( pMac->hHdd, (void **)&tdlsDelStaReq,
(sizeof(tSirTdlsDelStaReq) ) );
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("alloc failed") );
VOS_ASSERT(0) ;
return status ;
}
tdlsDelStaReq->sessionId = cmd->sessionId;
//Using dialog as transactionId. This can be used to match response with request
tdlsDelStaReq->transactionId = 0;
palCopyMemory(pMac->hHdd, tdlsDelStaReq->bssid,
pSession->pConnectBssDesc->bssId, sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, tdlsDelStaReq->peerMac,
tdlsDelStaCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
// Send the request to PE.
#ifdef WLAN_FEATURE_TDLS_DEBUG
smsLog( pMac, LOGE,
#else
smsLog( pMac, LOG1,
#endif
"sending TDLS Del Sta %02x:%02x:%02x:%02x:%02x:%02x req to PE",
tdlsDelStaCmdInfo->peerMac[0], tdlsDelStaCmdInfo->peerMac[1], tdlsDelStaCmdInfo->peerMac[2],
tdlsDelStaCmdInfo->peerMac[3], tdlsDelStaCmdInfo->peerMac[4], tdlsDelStaCmdInfo->peerMac[5]);
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_DEL_STA_REQ,
(void *)tdlsDelStaReq , sizeof(tSirTdlsDelStaReq)) ;
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC"));
}
return status;
}
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);
}
eHalStatus csrTdlsProcessLinkEstablish( tpAniSirGlobal pMac, tSmeCmd *cmd )
{
tTdlsLinkEstablishCmdInfo *tdlsLinkEstablishCmdInfo = &cmd->u.tdlsCmd.u.tdlsLinkEstablishCmdInfo ;
tSirTdlsLinkEstablishReq *tdlsLinkEstablishReq = NULL ;
eHalStatus status = eHAL_STATUS_FAILURE;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
if (NULL == pSession)
{
smsLog( pMac, LOGE, FL("pSession is NULL"));
return eHAL_STATUS_FAILURE;
}
status = palAllocateMemory( pMac->hHdd, (void **)&tdlsLinkEstablishReq,
(sizeof(tSirTdlsLinkEstablishReq) ) );
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("alloc failed \n") );
VOS_ASSERT(0) ;
return status ;
}
tdlsLinkEstablishReq->sessionId = cmd->sessionId;
tdlsLinkEstablishReq->transactionId = 0;
palCopyMemory(pMac->hHdd, tdlsLinkEstablishReq->peerMac,
tdlsLinkEstablishCmdInfo->peerMac, sizeof(tSirMacAddr));
palCopyMemory(pMac->hHdd, tdlsLinkEstablishReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
tdlsLinkEstablishReq->isBufSta = tdlsLinkEstablishCmdInfo->isBufSta;
tdlsLinkEstablishReq->isResponder= tdlsLinkEstablishCmdInfo->isResponder;
tdlsLinkEstablishReq->uapsdQueues= tdlsLinkEstablishCmdInfo->uapsdQueues;
tdlsLinkEstablishReq->maxSp= tdlsLinkEstablishCmdInfo->maxSp;
smsLog( pMac, LOGE, "sending TDLS Link Establish Request to PE \n" );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_LINK_ESTABLISH_REQ,
(void *)tdlsLinkEstablishReq,
sizeof(tSirTdlsLinkEstablishReq));
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC\n"));
}
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;
}
static tCfgReq * allocateCfgReq(tHddHandle hHdd, tANI_U32 type, tANI_S32 length)
{
tCfgReq *req ;
tANI_S32 alloc_len = sizeof(tCfgReq) ;
if (type == CCM_STRING_TYPE)
{
alloc_len += length ;
}
if (palAllocateMemory(hHdd, (void **)&req, alloc_len) != eHAL_STATUS_SUCCESS)
{
return NULL ;
}
req->ccmPtr = (req+1);
return req ;
}
/*
* 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 ;
}
static eHalStatus sendCfg(tpAniSirGlobal pMac, tHddHandle hHdd, tCfgReq *req, tANI_BOOLEAN fRsp)
{
tSirMbMsg *msg;
eHalStatus status;
tANI_S16 msgLen = (tANI_U16)(4 +
CFGOBJ_ID_SIZE +
CFGOBJ_LEN_SIZE +
CFGOBJ_ALIGN(req->length)) ;
status = palAllocateMemory(hHdd, (void **)&msg, msgLen);
if (status == eHAL_STATUS_SUCCESS)
{
if( fRsp )
{
msg->type = pal_cpu_to_be16(WNI_CFG_SET_REQ);
}
else
{
msg->type = pal_cpu_to_be16(WNI_CFG_SET_REQ_NO_RSP);
}
msg->msgLen = pal_cpu_to_be16(msgLen);
(void)encodeCfgReq(hHdd, msg->data, req->cfgId, req->length, req->ccmPtr, req->ccmValue, req->type) ;
status = palSendMBMessage(hHdd, msg) ;
if (status != eHAL_STATUS_SUCCESS)
{
smsLog( pMac, LOGE, FL("palSendMBMessage() failed"));
status = eHAL_STATUS_FAILURE ;
}
}
else
{
smsLog( pMac, LOGW, FL("palAllocateMemory(len=%d)"), msgLen );
}
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;
}
/**
* limSendBeaconParams()
*
*FUNCTION:
* This function is called to send beacnon interval, short preamble or other
* parameters to WDA, which are changed and indication is received in beacon.
*
*LOGIC:
*
*ASSUMPTIONS:
* NA
*
*NOTE:
* NA
*
* @param pMac pointer to Global Mac structure.
* @param tpUpdateBeaconParams pointer to the structure,
which contains the beacon parameters which are changed.
*
* @return success if message send is ok, else false.
*/
tSirRetStatus limSendBeaconParams(tpAniSirGlobal pMac,
tpUpdateBeaconParams pUpdatedBcnParams,
tpPESession psessionEntry )
{
tpUpdateBeaconParams pBcnParams = NULL;
tSirRetStatus retCode = eSIR_SUCCESS;
tSirMsgQ msgQ;
if( eHAL_STATUS_SUCCESS != palAllocateMemory( pMac->hHdd,
(void **) &pBcnParams, sizeof(*pBcnParams)))
{
limLog( pMac, LOGP,
FL( "Unable to PAL allocate memory during Update Beacon Params\n" ));
return eSIR_MEM_ALLOC_FAILED;
}
palCopyMemory( pMac->hHdd, (tANI_U8 *) pBcnParams, pUpdatedBcnParams, sizeof(*pBcnParams));
msgQ.type = WDA_UPDATE_BEACON_IND;
msgQ.reserved = 0;
msgQ.bodyptr = pBcnParams;
msgQ.bodyval = 0;
PELOG3(limLog( pMac, LOG3,
FL( "Sending WDA_UPDATE_BEACON_IND, paramChangeBitmap in hex = %x" ),
pUpdatedBcnParams->paramChangeBitmap);)
/**
* 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;
}
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;
}
/*--------------------------------------------------------------------------
\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;
}
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 );
}
tSirRetStatus uMacPostCtrlMsg(void* pSirGlobal, tSirMbMsg* pMb)
{
tSirMsgQ msg;
tpAniSirGlobal pMac = (tpAniSirGlobal)pSirGlobal;
tSirMbMsg* pMbLocal;
msg.type = pMb->type;
msg.bodyval = 0;
WDALOG3(wdaLog(pMac, LOG3, FL("msgType %d, msgLen %d\n" ),
pMb->type, pMb->msgLen));
// copy the message from host buffer to firmware buffer
// this will make sure that firmware allocates, uses and frees
// it's own buffers for mailbox message instead of working on
// host buffer
// second parameter, 'wait option', to palAllocateMemory is ignored on Windows
if( eHAL_STATUS_SUCCESS != palAllocateMemory( pMac->hHdd, (void **)&pMbLocal, pMb->msgLen))
{
WDALOGE( wdaLog(pMac, LOGE, FL("Buffer Allocation failed!\n")));
return eSIR_FAILURE;
}
palCopyMemory(pMac, (void *)pMbLocal, (void *)pMb, pMb->msgLen);
msg.bodyptr = pMbLocal;
switch (msg.type & HAL_MMH_MB_MSG_TYPE_MASK)
{
case WDA_MSG_TYPES_BEGIN: // Posts a message to the HAL MsgQ
wdaPostCtrlMsg(pMac, &msg);
break;
case SIR_LIM_MSG_TYPES_BEGIN: // Posts a message to the LIM MsgQ
limPostMsgApi(pMac, &msg);
break;
case SIR_CFG_MSG_TYPES_BEGIN: // Posts a message to the CFG MsgQ
wdaPostCfgMsg(pMac, &msg);
break;
case SIR_PMM_MSG_TYPES_BEGIN: // Posts a message to the PMM MsgQ
pmmPostMessage(pMac, &msg);
break;
case SIR_PTT_MSG_TYPES_BEGIN:
WDALOGW( wdaLog(pMac, LOGW, FL("%s:%d: message type = 0x%X"),
__func__, __LINE__, msg.type));
vos_mem_free(msg.bodyptr);
break;
default:
WDALOGW( wdaLog(pMac, LOGW, FL("Unknown message type = "
"0x%X\n"),
msg.type));
// Release the memory.
if (palFreeMemory( pMac->hHdd, (void*)(msg.bodyptr))
!= eHAL_STATUS_SUCCESS)
{
WDALOGE( wdaLog(pMac, LOGE, FL("Buffer Allocation failed!\n")));
return eSIR_FAILURE;
}
break;
}
return eSIR_SUCCESS;
} // uMacPostCtrlMsg()
static eHalStatus cfgUpdate(tpAniSirGlobal pMac, tHddHandle hHdd, tCcmCfgSetCallback callback)
{
tANI_U32 i, *pl ;
tCfgReq *req ;
tSirMbMsg *msg ;
eHalStatus status ;
tANI_S16 msgLen = 4 +
CFGOBJ_ID_SIZE +
CFGOBJ_LEN_SIZE +
CFGOBJ_INTEGER_VALUE_SIZE ;
if (pMac->ccm.state == eCCM_STOPPED || pMac->ccm.replay.started)
{
status = eHAL_STATUS_FAILURE ;
goto end ;
}
palSpinLockTake(hHdd, pMac->ccm.lock);
pMac->ccm.replay.started = 1 ;
pMac->ccm.replay.nr_param = 0 ;
palSpinLockGive(hHdd, pMac->ccm.lock);
for (i = 0 ; i < CFG_PARAM_MAX_NUM ; ++i)
{
if ((req = pMac->ccm.comp[i]) != NULL)
{
msgLen += (tANI_S16)(CFGOBJ_ID_SIZE + CFGOBJ_LEN_SIZE + CFGOBJ_ALIGN(req->length)) ;
pMac->ccm.replay.nr_param += 1 ;
#ifdef CCM_DEBUG
smsLog(pMac, LOGW, FL("cfgId=%d"), req->cfgId);
#endif
}
}
if (pMac->ccm.replay.nr_param == 0)
{
if (callback)
{
callback((tHalHandle)pMac, WNI_CFG_SUCCESS) ;
}
status = eHAL_STATUS_SUCCESS ;
goto end ;
}
pMac->ccm.replay.in_progress = 0 ;
pMac->ccm.replay.result = WNI_CFG_SUCCESS ;
pMac->ccm.replay.callback = callback ;
pMac->ccm.replay.done = NULL ;
status = palAllocateMemory(hHdd, (void **)&msg, msgLen) ;
if (status != eHAL_STATUS_SUCCESS)
{
pMac->ccm.replay.started = 0 ;
goto end ;
}
msg->type = pal_cpu_to_be16(WNI_CFG_SET_REQ);
msg->msgLen = pal_cpu_to_be16(msgLen);
pl = encodeCfgReq(hHdd, msg->data, CFG_UPDATE_MAGIC_DWORD, 4, NULL, 0, CCM_INTEGER_TYPE) ;
for (i = 0 ; i < CFG_PARAM_MAX_NUM ; ++i)
{
if ((req = pMac->ccm.comp[i]) != NULL)
{
pl = encodeCfgReq(hHdd, pl, req->cfgId, req->length, req->ccmPtr, req->ccmValue, req->type) ;
}
}
status = palSendMBMessage(hHdd, msg) ;
if (status != eHAL_STATUS_SUCCESS)
{
smsLog(pMac, LOGW, FL("palSendMBMessage() failed. status=%d"), status);
pMac->ccm.replay.started = 0 ;
goto end ;
}
end:
return status ;
}
/*
* commands received from CSR
*/
eHalStatus csrTdlsProcessCmd(tpAniSirGlobal pMac, tSmeCmd *cmd)
{
eSmeCommandType cmdType = cmd->command ;
#ifdef FEATURE_WLAN_TDLS_INTERNAL
tTdlsCmd tdlsCmd = cmd->u.tdlsCmd ;
#endif
tANI_BOOLEAN status = eANI_BOOLEAN_TRUE;
switch(cmdType)
{
case eSmeCommandTdlsSendMgmt:
{
status = csrTdlsProcessSendMgmt( pMac, cmd );
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
}
break ;
case eSmeCommandTdlsAddPeer:
{
status = csrTdlsProcessAddSta( pMac, cmd );
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
}
break;
case eSmeCommandTdlsDelPeer:
{
status = csrTdlsProcessDelSta( pMac, cmd );
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
}
break;
#ifdef FEATURE_WLAN_TDLS_INTERNAL
case eSmeCommandTdlsDiscovery:
{
tTdlsDisReqCmdinfo *disReqCmdInfo = &tdlsCmd.u.tdlsDisReqCmdInfo ;
tSirTdlsDisReq *disReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
status = palAllocateMemory( pMac->hHdd, (void **)&disReq,
sizeof(tSirTdlsDisReq));
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, "dis Req alloc failed " );
VOS_ASSERT(0) ;
break ;
}
disReq->sessionId = cmd->sessionId;
disReq->transactionId = 0; /* TODO ? */
disReq->reqType = disReqCmdInfo->tdlsDisType ;
palCopyMemory(pMac->hHdd, disReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, disReq->peerMac,
disReqCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
smsLog( pMac, LOGE, "sending TDLS discovery to PE " );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_DISCOVERY_START_REQ,
(void *)disReq , sizeof(tSirTdlsDisReq)) ;
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
/* TODO: Add error handling */
break ;
}
case eSmeCommandTdlsLinkSetup:
{
tTdlsLinkSetupReqCmdinfo *linkSetupReqCmdInfo =
&tdlsCmd.u.tdlsLinkSetupReqCmdInfo ;
tSirTdlsSetupReq *setupReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
status = palAllocateMemory( pMac->hHdd, (void **)&setupReq,
sizeof(tSirTdlsSetupReq));
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, "dis Req alloc failed " );
VOS_ASSERT(0) ;
break ;
}
setupReq->sessionId = cmd->sessionId;
setupReq->transactionId = 0; /* TODO ? */
palCopyMemory(pMac->hHdd, setupReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, setupReq->peerMac,
linkSetupReqCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("sending TDLS link setup to PE "));
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_LINK_START_REQ,
(void *)setupReq , sizeof(tSirTdlsSetupReq) ) ;
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
/* TODO: Add error handling */
break ;
}
case eSmeCommandTdlsLinkTear:
{
tTdlsLinkTeardownCmdinfo *linkTeardownCmdInfo =
&tdlsCmd.u.tdlsLinkTeardownCmdInfo ;
tSirTdlsTeardownReq *teardownReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
status = palAllocateMemory( pMac->hHdd, (void **)&teardownReq,
sizeof(tSirTdlsTeardownReq));
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, "teardown Req alloc failed " );
VOS_ASSERT(0) ;
break ;
}
teardownReq->sessionId = cmd->sessionId;
teardownReq->transactionId = 0; /* TODO ? */
palCopyMemory(pMac->hHdd, teardownReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, &teardownReq->peerMac,
linkTeardownCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("teardown request..")) ;
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_TEARDOWN_REQ,
(void *)teardownReq , sizeof(tSirTdlsTeardownReq)) ;
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
/* TODO: Add error handling */
break ;
}
#endif
default:
{
/* TODO: Add defualt handling */
break ;
}
}
return status ;
}
tSirRetStatus uMacPostCtrlMsg(void* pSirGlobal, tSirMbMsg* pMb)
{
tSirMsgQ msg;
tpAniSirGlobal pMac = (tpAniSirGlobal)pSirGlobal;
#ifdef ANI_OS_TYPE_RTAI_LINUX
msg.type = pMb->type;
msg.bodyptr = pMb;
msg.bodyval = 0;
WDALOG3( wdaLog(pMac, LOG3, FL("msgType %d, msgLen %d\n" ),
pMb->type, pMb->msgLen));
#else
tSirMbMsg* pMbLocal;
msg.type = pMb->type;
msg.bodyval = 0;
WDALOG3(wdaLog(pMac, LOG3, FL("msgType %d, msgLen %d\n" ),
pMb->type, pMb->msgLen));
// copy the message from host buffer to firmware buffer
// this will make sure that firmware allocates, uses and frees
// it's own buffers for mailbox message instead of working on
// host buffer
// second parameter, 'wait option', to palAllocateMemory is ignored on Windows
if( eHAL_STATUS_SUCCESS != palAllocateMemory( pMac->hHdd, (void **)&pMbLocal, pMb->msgLen))
{
WDALOGE( wdaLog(pMac, LOGE, FL("Buffer Allocation failed!\n")));
return eSIR_FAILURE;
}
palCopyMemory(pMac, (void *)pMbLocal, (void *)pMb, pMb->msgLen);
msg.bodyptr = pMbLocal;
#endif
switch (msg.type & HAL_MMH_MB_MSG_TYPE_MASK)
{
case WDA_MSG_TYPES_BEGIN: // Posts a message to the HAL MsgQ
wdaPostCtrlMsg(pMac, &msg);
break;
case SIR_LIM_MSG_TYPES_BEGIN: // Posts a message to the LIM MsgQ
limPostMsgApi(pMac, &msg);
break;
case SIR_CFG_MSG_TYPES_BEGIN: // Posts a message to the CFG MsgQ
wdaPostCfgMsg(pMac, &msg);
break;
case SIR_PMM_MSG_TYPES_BEGIN: // Posts a message to the PMM MsgQ
pmmPostMessage(pMac, &msg);
break;
#if defined(ANI_MANF_DIAG) || defined(ANI_PHY_DEBUG)
case SIR_PTT_MSG_TYPES_BEGIN:
#ifndef FEATURE_WLAN_INTEGRATED_SOC
halNimPTTPostMsgApi(pMac, &msg); // Posts a message to the NIM PTT MsgQ
#endif /* FEATURE_WLAN_INTEGRATED_SOC */
break;
#endif
default:
WDALOGW( wdaLog(pMac, LOGW, FL("Unknown message type = "
"0x%X\n"),
msg.type));
// Release the memory.
if (palFreeMemory( pMac->hHdd, (void*)(msg.bodyptr))
!= eHAL_STATUS_SUCCESS)
{
WDALOGE( wdaLog(pMac, LOGE, FL("Buffer Allocation failed!\n")));
return eSIR_FAILURE;
}
break;
}
return eSIR_SUCCESS;
} // uMacPostCtrlMsg()