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;
}
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;
}
/* ---------------------------------------------------------------------------
\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));
pMsg = vos_mem_malloc(msgLen);
if ( NULL == pMsg )
status = eHAL_STATUS_FAILURE;
else
status = eHAL_STATUS_SUCCESS;
if(HAL_STATUS_SUCCESS(status))
{
vos_mem_set(pMsg, msgLen, 0);
pMsg->messageType = pal_cpu_to_be16((tANI_U16)eWNI_SME_OEM_DATA_REQ);
pMsg->messageLen = pal_cpu_to_be16(msgLen);
vos_mem_copy(pMsg->selfMacAddr, pSession->selfMacAddr, sizeof(tSirMacAddr) );
vos_mem_copy(pMsg->oemDataReq, pOemDataReq->oemDataReq, OEM_DATA_REQ_SIZE);
smsLog(pMac, LOGW, "OEM_DATA: sending message to pe%s", __func__);
status = palSendMBMessage(pMac->hHdd, pMsg);
}
smsLog(pMac, LOGW, "OEM_DATA: exiting Function %s", __func__);
return status;
}
void sme_SetFTPreAuthState(tHalHandle hHal, tANI_U32 sessionId, v_BOOL_t state)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
if (pSession)
pSession->ftSmeContext.setFTPreAuthState = state;
}
/* ---------------------------------------------------------------------------
\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;
}
/*--------------------------------------------------------------------------
Cleanup the SME FT Global context.
------------------------------------------------------------------------*/
void sme_FTClose(tHalHandle hHal, tANI_U32 sessionId)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tCsrRoamSession *pSession = NULL;
/* Clear the FT Context */
sme_FTReset(hHal, sessionId);
pSession = CSR_GET_SESSION( pMac, sessionId );
if (NULL != pSession)
{
/* check if the timer is running */
if (VOS_TIMER_STATE_RUNNING ==
vos_timer_getCurrentState(
&pSession->ftSmeContext.preAuthReassocIntvlTimer))
{
vos_timer_stop(&pSession->ftSmeContext.preAuthReassocIntvlTimer);
}
if (VOS_STATUS_SUCCESS !=
vos_timer_destroy(&pSession->ftSmeContext.preAuthReassocIntvlTimer))
{
smsLog(pMac, LOGE, FL("preAuthReAssocTimer destroy failed"));
}
if (pSession->ftSmeContext.pUsrCtx != NULL) {
smsLog(pMac, LOG1,
FL("Freeing ftSmeContext.pUsrCtx and setting to NULL"));
vos_mem_free(pSession->ftSmeContext.pUsrCtx);
pSession->ftSmeContext.pUsrCtx = NULL;
}
}
}
/*--------------------------------------------------------------------------
Initialize the FT context.
------------------------------------------------------------------------*/
void sme_FTOpen(tHalHandle hHal, tANI_U32 sessionId)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
eHalStatus status = eHAL_STATUS_SUCCESS;
tCsrRoamSession *pSession = CSR_GET_SESSION(pMac, sessionId);
if (NULL != pSession) {
/* Clean up the context */
vos_mem_set(&pSession->ftSmeContext, sizeof(tftSMEContext), 0);
pSession->ftSmeContext.pUsrCtx = vos_mem_malloc(
sizeof(tFTRoamCallbackUsrCtx));
if (NULL == pSession->ftSmeContext.pUsrCtx) {
smsLog(pMac, LOGE, FL("Memory allocation failure"));
return;
}
pSession->ftSmeContext.pUsrCtx->pMac = pMac;
pSession->ftSmeContext.pUsrCtx->sessionId = sessionId;
status =
vos_timer_init(&pSession->ftSmeContext.preAuthReassocIntvlTimer,
VOS_TIMER_TYPE_SW,
sme_PreauthReassocIntvlTimerCallback,
(void *)pSession->ftSmeContext.pUsrCtx);
if (eHAL_STATUS_SUCCESS != status) {
smsLog(pMac, LOGE,
FL("Preauth Reassoc interval Timer allocation failed"));
vos_mem_free(pSession->ftSmeContext.pUsrCtx);
pSession->ftSmeContext.pUsrCtx = NULL;
return;
}
}
}
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)
{
smsLog( pMac, LOGE, FL("pSession is NULL"));
return eHAL_STATUS_FAILURE;
}
if (NULL == pSession->pConnectBssDesc)
{
smsLog( pMac, LOGE, FL("BSS description is not present") );
return eHAL_STATUS_FAILURE;
}
tdlsDelStaReq = vos_mem_malloc(sizeof(tSirTdlsDelStaReq));
if ( NULL == tdlsDelStaReq )
status = eHAL_STATUS_FAILURE;
else
status = eHAL_STATUS_SUCCESS;
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;
vos_mem_copy( tdlsDelStaReq->bssid,
pSession->pConnectBssDesc->bssId, sizeof (tSirMacAddr));
vos_mem_copy( 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 "MAC_ADDRESS_STR" req to PE",
MAC_ADDR_ARRAY(tdlsDelStaCmdInfo->peerMac));
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;
}
CDF_STATUS p2p_process_remain_on_channel_cmd(tpAniSirGlobal pMac,
tSmeCmd *p2pRemainonChn)
{
CDF_STATUS status = CDF_STATUS_E_FAILURE;
tSirRemainOnChnReq *pMsg;
uint32_t len;
tCsrRoamSession *pSession =
CSR_GET_SESSION(pMac, p2pRemainonChn->sessionId);
if (!pSession) {
sms_log(pMac, LOGE, FL(" session %d not found "),
p2pRemainonChn->sessionId);
goto error;
}
if (!pSession->sessionActive) {
sms_log(pMac, LOGE,
FL(" session %d is invalid or listen is disabled "),
p2pRemainonChn->sessionId);
goto error;
}
len = sizeof(tSirRemainOnChnReq) + pMac->p2pContext.probeRspIeLength;
if (len > 0xFFFF) {
/*In coming len for Msg is more then 16bit value */
sms_log(pMac, LOGE, FL(" Message length is very large, %d"),
len);
goto error;
}
pMsg = cdf_mem_malloc(len);
if (NULL == pMsg)
goto error;
else {
CDF_TRACE(CDF_MODULE_ID_SME, CDF_TRACE_LEVEL_INFO, "%s call",
__func__);
cdf_mem_set(pMsg, sizeof(tSirRemainOnChnReq), 0);
pMsg->messageType = eWNI_SME_REMAIN_ON_CHANNEL_REQ;
pMsg->length = (uint16_t) len;
cdf_copy_macaddr(&pMsg->selfMacAddr, &pSession->selfMacAddr);
pMsg->chnNum = p2pRemainonChn->u.remainChlCmd.chn;
pMsg->phyMode = p2pRemainonChn->u.remainChlCmd.phyMode;
pMsg->duration = p2pRemainonChn->u.remainChlCmd.duration;
pMsg->sessionId = p2pRemainonChn->sessionId;
pMsg->isProbeRequestAllowed =
p2pRemainonChn->u.remainChlCmd.isP2PProbeReqAllowed;
pMsg->scan_id = p2pRemainonChn->u.remainChlCmd.scan_id;
if (pMac->p2pContext.probeRspIeLength)
cdf_mem_copy((void *)pMsg->probeRspIe,
(void *)pMac->p2pContext.probeRspIe,
pMac->p2pContext.probeRspIeLength);
status = cds_send_mb_message_to_mac(pMsg);
}
error:
if (CDF_STATUS_E_FAILURE == status)
csr_release_roc_req_cmd(pMac);
return status;
}
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;
}
tdlsLinkEstablishReq = vos_mem_malloc(sizeof(tSirTdlsLinkEstablishReq));
if (tdlsLinkEstablishReq == NULL)
{
smsLog( pMac, LOGE, FL("alloc failed \n") );
VOS_ASSERT(0) ;
return status ;
}
tdlsLinkEstablishReq->sessionId = cmd->sessionId;
//Using dialog as transactionId. This can be used to match response with request
tdlsLinkEstablishReq->transactionId = 0;
vos_mem_copy(tdlsLinkEstablishReq->peerMac,
tdlsLinkEstablishCmdInfo->peerMac, sizeof(tSirMacAddr));
vos_mem_copy(tdlsLinkEstablishReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
vos_mem_copy(tdlsLinkEstablishReq->supportedChannels,
tdlsLinkEstablishCmdInfo->supportedChannels,
tdlsLinkEstablishCmdInfo->supportedChannelsLen);
tdlsLinkEstablishReq->supportedChannelsLen =
tdlsLinkEstablishCmdInfo->supportedChannelsLen;
vos_mem_copy(tdlsLinkEstablishReq->supportedOperClasses,
tdlsLinkEstablishCmdInfo->supportedOperClasses,
tdlsLinkEstablishCmdInfo->supportedOperClassesLen);
tdlsLinkEstablishReq->supportedOperClassesLen =
tdlsLinkEstablishCmdInfo->supportedOperClassesLen;
tdlsLinkEstablishReq->isBufSta = tdlsLinkEstablishCmdInfo->isBufSta;
tdlsLinkEstablishReq->isResponder= tdlsLinkEstablishCmdInfo->isResponder;
tdlsLinkEstablishReq->uapsdQueues= tdlsLinkEstablishCmdInfo->uapsdQueues;
tdlsLinkEstablishReq->maxSp= tdlsLinkEstablishCmdInfo->maxSp;
tdlsLinkEstablishReq->isOffChannelSupported =
tdlsLinkEstablishCmdInfo->isOffChannelSupported;
// Send the request to PE.
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;
}
v_BOOL_t sme_GetFTPreAuthState(tHalHandle hHal, tANI_U32 sessionId)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
if (pSession)
return pSession->ftSmeContext.setFTPreAuthState;
return FALSE;
}
eHalStatus p2pProcessRemainOnChannelCmd(tpAniSirGlobal pMac, tSmeCmd *p2pRemainonChn)
{
eHalStatus status = eHAL_STATUS_FAILURE;
tSirRemainOnChnReq* pMsg;
tANI_U32 len;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, p2pRemainonChn->sessionId );
if(!pSession)
{
smsLog(pMac, LOGE, FL(" session %d not found "), p2pRemainonChn->sessionId);
goto error;
}
if(!pSession->sessionActive)
{
smsLog(pMac, LOGE, FL(" session %d is invalid or listen is disabled "),
p2pRemainonChn->sessionId);
goto error;
}
len = sizeof(tSirRemainOnChnReq) + pMac->p2pContext.probeRspIeLength;
if( len > 0xFFFF )
{
/*In coming len for Msg is more then 16bit value*/
smsLog(pMac, LOGE, FL(" Message length is very large, %d"),
len);
goto error;
}
pMsg = vos_mem_malloc(len);
if ( NULL == pMsg )
goto error;
else
{
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO, "%s call", __func__);
vos_mem_set(pMsg, sizeof(tSirRemainOnChnReq), 0);
pMsg->messageType = eWNI_SME_REMAIN_ON_CHANNEL_REQ;
pMsg->length = (tANI_U16)len;
vos_mem_copy(pMsg->selfMacAddr, pSession->selfMacAddr, sizeof(tSirMacAddr));
pMsg->chnNum = p2pRemainonChn->u.remainChlCmd.chn;
pMsg->phyMode = p2pRemainonChn->u.remainChlCmd.phyMode;
pMsg->duration = p2pRemainonChn->u.remainChlCmd.duration;
pMsg->sessionId = p2pRemainonChn->sessionId;
pMsg->isProbeRequestAllowed = p2pRemainonChn->u.remainChlCmd.isP2PProbeReqAllowed;
if( pMac->p2pContext.probeRspIeLength )
vos_mem_copy((void *)pMsg->probeRspIe, (void *)pMac->p2pContext.probeRspIe,
pMac->p2pContext.probeRspIeLength);
status = palSendMBMessage(pMac->hHdd, pMsg);
}
error:
if (eHAL_STATUS_FAILURE == status)
csr_release_roc_req_cmd(pMac);
return status;
}
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;
}
void sme_SetFTPTKState(tHalHandle hHal, tANI_U32 sessionId, v_BOOL_t state)
{
tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
tCsrRoamSession *pSession = CSR_GET_SESSION(pMac, sessionId);
if (!pSession) {
smsLog(pMac, LOGE, FL("pSession is NULL"));
return;
}
pSession->ftSmeContext.setFTPTKState = state;
}
/*--------------------------------------------------------------------------
Reset the FT context.
------------------------------------------------------------------------*/
void sme_FTReset(tHalHandle hHal, tANI_U32 sessionId)
{
tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
tCsrRoamSession *pSession = NULL;
if (pMac == NULL) {
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR, FL("pMac is NULL"));
return;
}
pSession = CSR_GET_SESSION(pMac, sessionId);
if (NULL != pSession) {
if (pSession->ftSmeContext.auth_ft_ies != NULL) {
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog(pMac, LOG1, FL("Freeing FT Auth IE %p and setting to NULL"),
pSession->ftSmeContext.auth_ft_ies);
#endif
vos_mem_free(pSession->ftSmeContext.auth_ft_ies);
pSession->ftSmeContext.auth_ft_ies = NULL;
}
pSession->ftSmeContext.auth_ft_ies_length = 0;
if (pSession->ftSmeContext.reassoc_ft_ies != NULL) {
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog(pMac, LOG1,
FL("Freeing FT Reassoc IE %p and setting to NULL"),
pSession->ftSmeContext.reassoc_ft_ies);
#endif
vos_mem_free(pSession->ftSmeContext.reassoc_ft_ies);
pSession->ftSmeContext.reassoc_ft_ies = NULL;
}
pSession->ftSmeContext.reassoc_ft_ies_length = 0;
if (pSession->ftSmeContext.psavedFTPreAuthRsp != NULL) {
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, FL("Freeing FtPreAuthRsp %p and setting to NULL"),
pSession->ftSmeContext.psavedFTPreAuthRsp);
#endif
vos_mem_free(pSession->ftSmeContext.psavedFTPreAuthRsp);
vos_mem_set(pSession->ftSmeContext.psavedFTPreAuthRsp,
sizeof(tSirFTPreAuthRsp), 0);
}
pSession->ftSmeContext.setFTPreAuthState = VOS_FALSE;
pSession->ftSmeContext.setFTPTKState = VOS_FALSE;
vos_mem_zero(pSession->ftSmeContext.preAuthbssId, ANI_MAC_ADDR_SIZE);
pSession->ftSmeContext.FTState = eFT_START_READY;
}
}
/*--------------------------------------------------------------------------
*
* HDD Interface to SME. SME now sends the Auth 2 and RIC IEs up to the supplicant.
* The supplicant will then proceed to send down the
* Reassoc Req.
*
*------------------------------------------------------------------------*/
void sme_GetFTPreAuthResponse( tHalHandle hHal, tANI_U32 sessionId, tANI_U8 *ft_ies,
tANI_U32 ft_ies_ip_len, tANI_U16 *ft_ies_length )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (!pSession)
{
smsLog( pMac, LOGE, FL("pSession is NULL"));
return;
}
*ft_ies_length = 0;
status = sme_AcquireGlobalLock( &pMac->sme );
if (!( HAL_STATUS_SUCCESS( status )))
return;
/* All or nothing - proceed only if both BSSID and FT IE fit */
if((ANI_MAC_ADDR_SIZE +
pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length) > ft_ies_ip_len)
{
sme_ReleaseGlobalLock( &pMac->sme );
return;
}
// hdd needs to pack the bssid also along with the
// auth response to supplicant
vos_mem_copy(ft_ies, pSession->ftSmeContext.preAuthbssId, ANI_MAC_ADDR_SIZE);
// Copy the auth resp FTIEs
vos_mem_copy(&(ft_ies[ANI_MAC_ADDR_SIZE]),
pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies,
pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length);
*ft_ies_length = ANI_MAC_ADDR_SIZE +
pSession->ftSmeContext.psavedFTPreAuthRsp->ft_ies_length;
pSession->ftSmeContext.FTState = eFT_REASSOC_REQ_WAIT;
#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, FL(" Filled auth resp = %d"), *ft_ies_length);
#endif
sme_ReleaseGlobalLock( &pMac->sme );
return;
}
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;
}
// tdlsoffchan
eHalStatus csrTdlsProcessChanSwitchReq( tpAniSirGlobal pMac, tSmeCmd *cmd )
{
tTdlsChanSwitchCmdInfo *tdlsChanSwitchCmdInfo = &cmd->u.tdlsCmd.u.tdlsChanSwitchCmdInfo ;
tSirTdlsChanSwitch *tdlsChanSwitch = 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;
}
tdlsChanSwitch = vos_mem_malloc(sizeof(tSirTdlsChanSwitch));
if (tdlsChanSwitch == NULL)
{
smsLog( pMac, LOGE, FL("alloc failed \n") );
VOS_ASSERT(0) ;
return status ;
}
tdlsChanSwitch->sessionId = cmd->sessionId;
//Using dialog as transactionId. This can be used to match response with request
tdlsChanSwitch->transactionId = 0;
vos_mem_copy( tdlsChanSwitch->peerMac,
tdlsChanSwitchCmdInfo->peerMac, sizeof(tSirMacAddr));
vos_mem_copy(tdlsChanSwitch->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
tdlsChanSwitch->tdlsOffCh = tdlsChanSwitchCmdInfo->tdlsOffCh;
tdlsChanSwitch->tdlsOffChBwOffset = tdlsChanSwitchCmdInfo->tdlsOffChBwOffset;
tdlsChanSwitch->tdlsSwMode = tdlsChanSwitchCmdInfo->tdlsSwMode;
// Send the request to PE.
smsLog( pMac, LOGE, "sending TDLS Channel Switch to PE \n" );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_CHANNEL_SWITCH_REQ,
(void *)tdlsChanSwitch,
sizeof(tSirTdlsChanSwitch));
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC\n"));
}
return status;
}
/*--------------------------------------------------------------------------
*
* SME now sends the RIC IEs up to the supplicant.
* The supplicant will then proceed to send down the
* Reassoc Req.
*
*------------------------------------------------------------------------*/
void sme_GetRICIEs(tHalHandle hHal, tANI_U32 sessionId, tANI_U8 *ric_ies,
tANI_U32 ric_ies_ip_len, tANI_U32 *ric_ies_length )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (!pSession)
{
smsLog( pMac, LOGE, FL("pSession is NULL"));
return;
}
*ric_ies_length = 0;
status = sme_AcquireGlobalLock( &pMac->sme );
if (!( HAL_STATUS_SUCCESS( status )))
return;
/* All or nothing */
if (pSession->ftSmeContext.psavedFTPreAuthRsp->ric_ies_length >
ric_ies_ip_len)
{
sme_ReleaseGlobalLock( &pMac->sme );
return;
}
vos_mem_copy(ric_ies, pSession->ftSmeContext.psavedFTPreAuthRsp->ric_ies,
pSession->ftSmeContext.psavedFTPreAuthRsp->ric_ies_length);
*ric_ies_length = pSession->ftSmeContext.psavedFTPreAuthRsp->ric_ies_length;
#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, FL(" Filled ric ies = %d"), *ric_ies_length);
#endif
sme_ReleaseGlobalLock( &pMac->sme );
return;
}
eHalStatus csrMsgProcessor( tpAniSirGlobal pMac, void *pMsgBuf )
{
eHalStatus status = eHAL_STATUS_SUCCESS;
tSirSmeRsp *pSmeRsp = (tSirSmeRsp *)pMsgBuf;
#ifdef FEATURE_WLAN_SCAN_PNO
tSirMbMsg *pMsg = (tSirMbMsg *)pMsgBuf;
tCsrRoamSession *pSession;
#endif
smsLog(pMac, LOG2, FL("Message %d[0x%04X] received in curState %s"
" and substate %s sessionId (%d)"),
pSmeRsp->messageType, pSmeRsp->messageType,
macTraceGetcsrRoamState(pMac->roam.curState[pSmeRsp->sessionId]),
macTraceGetcsrRoamSubState(
pMac->roam.curSubState[pSmeRsp->sessionId]), pSmeRsp->sessionId);
#ifdef FEATURE_WLAN_SCAN_PNO
/*
* PNO scan responses have to be handled irrespective of CSR roam state.
* Check if PNO has been started and only then process the PNO scan results.
* Also note that normal scan is not allowed when PNO scan is in progress
* and so the scan responses reaching here when PNO is started must be
* PNO responses. For normal scan, the PNO started flag will be FALSE and
* it will be processed as usual based on the current CSR roam state.
*/
pSession = CSR_GET_SESSION(pMac, pSmeRsp->sessionId);
if(!pSession)
{
smsLog(pMac, LOGE, FL(" session %d not found, msgType : %d"), pSmeRsp->sessionId,
pMsg->type);
return eHAL_STATUS_FAILURE;
}
if((eWNI_SME_SCAN_RSP == pMsg->type) && (TRUE == pSession->pnoStarted))
{
status = csrScanningStateMsgProcessor(pMac, pMsgBuf);
if (eHAL_STATUS_SUCCESS != status)
{
smsLog(pMac, LOGE, FL(" handling PNO scan resp msg 0x%X CSR state is %d"),
pSmeRsp->messageType, pMac->roam.curState[pSmeRsp->sessionId]);
}
return (status);
}
#endif
// Process the message based on the state of the roaming states...
#if defined( ANI_RTT_DEBUG )
if(!pAdapter->fRttModeEnabled)
{
#endif//RTT
switch (pMac->roam.curState[pSmeRsp->sessionId])
{
case eCSR_ROAMING_STATE_SCANNING:
{
//Are we in scan state
#if defined( ANI_EMUL_ASSOC )
emulScanningStateMsgProcessor( pAdapter, pMBBufHdr );
#else
status = csrScanningStateMsgProcessor(pMac, pMsgBuf);
#endif
break;
}
case eCSR_ROAMING_STATE_JOINED:
{
//are we in joined state
csrRoamJoinedStateMsgProcessor( pMac, pMsgBuf );
break;
}
case eCSR_ROAMING_STATE_JOINING:
{
//are we in roaming states
#if defined( ANI_EMUL_ASSOC )
emulRoamingStateMsgProcessor( pAdapter, pMBBufHdr );
#endif
csrRoamingStateMsgProcessor( pMac, pMsgBuf );
break;
}
//For all other messages, we ignore it
default:
{
/*To work-around an issue where checking for set/remove key base on connection state is no longer
* workable due to failure or finding the condition meets both SAP and infra/IBSS requirement.
*/
if( (eWNI_SME_SETCONTEXT_RSP == pSmeRsp->messageType) ||
(eWNI_SME_REMOVEKEY_RSP == pSmeRsp->messageType) )
{
smsLog(pMac, LOGW, FL(" handling msg 0x%X CSR state is %d"), pSmeRsp->messageType, pMac->roam.curState[pSmeRsp->sessionId]);
csrRoamCheckForLinkStatusChange(pMac, pSmeRsp);
}
else if(eWNI_SME_GET_RSSI_REQ == pSmeRsp->messageType)
{
tAniGetRssiReq *pGetRssiReq = (tAniGetRssiReq*)pMsgBuf;
if(NULL != pGetRssiReq->rssiCallback)
{
smsLog(pMac,
LOGW,
FL("Message eWNI_SME_GET_RSSI_REQ is not handled"
" by CSR in state %d. calling RSSI callback"),
pMac->roam.curState[pSmeRsp->sessionId]);
((tCsrRssiCallback)(pGetRssiReq->rssiCallback))(pGetRssiReq->lastRSSI,
pGetRssiReq->staId,
pGetRssiReq->pDevContext);
}
else
{
smsLog(pMac, LOGE, FL("pGetRssiReq->rssiCallback is NULL"));
}
}
else
{
smsLog(pMac, LOGE, "Message 0x%04X is not handled by CSR "
" CSR state is %d session Id %d", pSmeRsp->messageType,
pMac->roam.curState[pSmeRsp->sessionId], pSmeRsp->sessionId);
if (eWNI_SME_FT_PRE_AUTH_RSP == pSmeRsp->messageType) {
smsLog(pMac, LOGE, "Dequeue eSmeCommandRoam command"
" with reason eCsrPerformPreauth");
csrDequeueRoamCommand(pMac, eCsrPerformPreauth);
}
else if (eWNI_SME_REASSOC_RSP == pSmeRsp->messageType) {
smsLog(pMac, LOGE, "Dequeue eSmeCommandRoam command"
" with reason eCsrSmeIssuedFTReassoc");
csrDequeueRoamCommand(pMac, eCsrSmeIssuedFTReassoc);
}
}
break;
}
}//switch
#if defined( ANI_RTT_DEBUG )
}
#endif//RTT
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;
case eSmeCommandTdlsLinkEstablish:
{
status = csrTdlsProcessLinkEstablish( 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 );
disReq = vos_mem_malloc(sizeof(tSirTdlsDisReq));
if ( NULL == disReq )
status = eHAL_STATUS_FAILURE;
else
status = eHAL_STATUS_SUCCESS;
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 ;
vos_mem_copy( disReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
vos_mem_copy( 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 );
setupReq = vos_mem_malloc(sizeof(tSirTdlsSetupReq));
if ( NULL == setupReq )
status = eHAL_STATUS_FAILURE;
else
status = eHAL_STATUS_SUCCESS;
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, "dis Req alloc failed " );
VOS_ASSERT(0) ;
break ;
}
setupReq->sessionId = cmd->sessionId;
setupReq->transactionId = 0; /* TODO ? */
vos_mem_copy( setupReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
vos_mem_copy( 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 );
teardownReq = vos_mem_malloc(sizeof(tSirTdlsTeardownReq));
if ( NULL == teardownReq )
status = eHAL_STATUS_FAILURE;
else
status = eHAL_STATUS_SUCCESS;
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, "teardown Req alloc failed " );
VOS_ASSERT(0) ;
break ;
}
teardownReq->sessionId = cmd->sessionId;
teardownReq->transactionId = 0; /* TODO ? */
vos_mem_copy( teardownReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
vos_mem_copy( &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 ;
}
/*--------------------------------------------------------------------------
Each time the supplicant sends down the FT IEs to the driver.
This function is called in SME. This function packages and sends
the FT IEs to PE.
------------------------------------------------------------------------*/
void sme_SetFTIEs(tHalHandle hHal, tANI_U32 sessionId, const tANI_U8 *ft_ies,
tANI_U16 ft_ies_length )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (NULL == pSession || NULL == ft_ies)
{
smsLog( pMac, LOGE, FL(" ft ies or pSession is NULL"));
return;
}
status = sme_AcquireGlobalLock( &pMac->sme );
if (!( HAL_STATUS_SUCCESS( status ))) return;
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, "FT IEs Req is received in state %d",
pSession->ftSmeContext.FTState);
#endif
// Global Station FT State
switch(pSession->ftSmeContext.FTState)
{
case eFT_START_READY:
case eFT_AUTH_REQ_READY:
if ((pSession->ftSmeContext.auth_ft_ies) &&
(pSession->ftSmeContext.auth_ft_ies_length))
{
// Free the one we received last from the supplicant
vos_mem_free(pSession->ftSmeContext.auth_ft_ies);
pSession->ftSmeContext.auth_ft_ies_length = 0;
pSession->ftSmeContext.auth_ft_ies = NULL;
}
// Save the FT IEs
pSession->ftSmeContext.auth_ft_ies =
vos_mem_malloc(ft_ies_length);
if ( NULL == pSession->ftSmeContext.auth_ft_ies )
{
smsLog( pMac, LOGE, FL("Memory allocation failed for "
"auth_ft_ies"));
sme_ReleaseGlobalLock( &pMac->sme );
return;
}
pSession->ftSmeContext.auth_ft_ies_length = ft_ies_length;
vos_mem_copy((tANI_U8 *)pSession->ftSmeContext.auth_ft_ies,
ft_ies,ft_ies_length);
pSession->ftSmeContext.FTState = eFT_AUTH_REQ_READY;
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, "ft_ies_length=%d", ft_ies_length);
#endif
break;
case eFT_AUTH_COMPLETE:
// We will need to re-start preauth. If we received FT IEs in
// eFT_PRE_AUTH_DONE state, it implies there was a rekey in
// our pre-auth state. Hence this implies we need Pre-auth again.
// OK now inform SME we have no pre-auth list.
// Delete the pre-auth node locally. Set your self back to restart pre-auth
// TBD
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1,
"Pre-auth done and now receiving---> AUTH REQ <---- in state %d",
pSession->ftSmeContext.FTState);
smsLog( pMac, LOG1, "Unhandled reception of FT IES in state %d",
pSession->ftSmeContext.FTState);
#endif
break;
case eFT_REASSOC_REQ_WAIT:
// We are done with pre-auth, hence now waiting for
// reassoc req. This is the new FT Roaming in place
// At this juncture we are ready to start sending Re-Assoc Req.
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, "New Reassoc Req=%p in state %d",
ft_ies, pSession->ftSmeContext.FTState);
#endif
if ((pSession->ftSmeContext.reassoc_ft_ies) &&
(pSession->ftSmeContext.reassoc_ft_ies_length))
{
// Free the one we received last from the supplicant
vos_mem_free(pSession->ftSmeContext.reassoc_ft_ies);
pSession->ftSmeContext.reassoc_ft_ies_length = 0;
}
// Save the FT IEs
pSession->ftSmeContext.reassoc_ft_ies = vos_mem_malloc(ft_ies_length);
if ( NULL == pSession->ftSmeContext.reassoc_ft_ies )
{
smsLog( pMac, LOGE, FL("Memory allocation failed for "
"reassoc_ft_ies"));
sme_ReleaseGlobalLock( &pMac->sme );
return;
}
pSession->ftSmeContext.reassoc_ft_ies_length = ft_ies_length;
vos_mem_copy((tANI_U8 *)pSession->ftSmeContext.reassoc_ft_ies, ft_ies,
ft_ies_length);
pSession->ftSmeContext.FTState = eFT_SET_KEY_WAIT;
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, "ft_ies_length=%d state=%d", ft_ies_length,
pSession->ftSmeContext.FTState);
#endif
break;
default:
smsLog( pMac, LOGE, FL(" Unhandled state=%d"),
pSession->ftSmeContext.FTState);
break;
}
sme_ReleaseGlobalLock( &pMac->sme );
}
eHalStatus sme_FTUpdateKey(tHalHandle hHal, tANI_U32 sessionId,
tCsrRoamSetKey * pFTKeyInfo )
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (!pSession)
{
smsLog( pMac, LOGE, FL("pSession is NULL"));
return eHAL_STATUS_FAILURE;
}
if (pFTKeyInfo == NULL)
{
smsLog( pMac, LOGE, "%s: pFTKeyInfo is NULL", __func__);
return eHAL_STATUS_FAILURE;
}
status = sme_AcquireGlobalLock( &pMac->sme );
if (!( HAL_STATUS_SUCCESS( status )))
{
return eHAL_STATUS_FAILURE;
}
#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, "sme_FTUpdateKey is received in state %d",
pSession->ftSmeContext.FTState);
#endif
// Global Station FT State
switch(pSession->ftSmeContext.FTState)
{
case eFT_SET_KEY_WAIT:
if (sme_GetFTPreAuthState(hHal, sessionId) == TRUE)
{
status = sme_FTSendUpdateKeyInd(pMac, sessionId, pFTKeyInfo);
if (status != 0 )
{
smsLog( pMac, LOGE, "%s: Key set failure %d", __func__,
status);
pSession->ftSmeContext.setFTPTKState = FALSE;
status = eHAL_STATUS_FT_PREAUTH_KEY_FAILED;
}
else
{
pSession->ftSmeContext.setFTPTKState = TRUE;
status = eHAL_STATUS_FT_PREAUTH_KEY_SUCCESS;
smsLog( pMac, LOG1, "%s: Key set success", __func__);
}
sme_SetFTPreAuthState(hHal, sessionId, FALSE);
}
pSession->ftSmeContext.FTState = eFT_START_READY;
#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG
smsLog( pMac, LOG1, "%s: state changed to %d status %d", __func__,
pSession->ftSmeContext.FTState, status);
#endif
break;
default:
smsLog( pMac, LOGW, "%s: Unhandled state=%d", __func__,
pSession->ftSmeContext.FTState);
status = eHAL_STATUS_FAILURE;
break;
}
sme_ReleaseGlobalLock( &pMac->sme );
return status;
}
