/* ---------------------------------------------------------------------------
\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;
}
/*
* 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 ;
}
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;
}
eHalStatus ccmCfgGetStr(tHalHandle hHal, tANI_U32 cfgId, tANI_U8 *pBuf, tANI_U32 *pLength)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tHddHandle hHdd;
eHalStatus status = eHAL_STATUS_SUCCESS ;
tCfgReq *req;
if (!pMac)
return eHAL_STATUS_FAILURE;
hHdd = halHandle2HddHandle(hHal);
req = pMac->ccm.comp[cfgId] ;
if (req && req->state == eCCM_REQ_DONE && (tANI_U32)req->length <= *pLength)
{
*pLength = req->length ;
palCopyMemory(hHdd, (void*)pBuf, (void*)req->ccmPtr, req->length);
}
else
{
if (wlan_cfgGetStr(pMac, (tANI_U16)cfgId, pBuf, pLength) != eSIR_SUCCESS)
status = eHAL_STATUS_FAILURE;
}
return status ;
}
/*
* TDLS request API, called from HDD to delete a TDLS peer
*/
eHalStatus csrTdlsDelPeerSta(tHalHandle hHal, tANI_U8 sessionId, tSirMacAddr peerMac)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tSmeCmd *tdlsDelStaCmd ;
eHalStatus status = eHAL_STATUS_FAILURE ;
//If connected and in Infra. Only then allow this
if( CSR_IS_SESSION_VALID( pMac, sessionId ) &&
csrIsConnStateConnectedInfra( pMac, sessionId ) &&
(NULL != peerMac) )
{
tdlsDelStaCmd = csrGetCommandBuffer(pMac) ;
if(tdlsDelStaCmd)
{
tTdlsDelStaCmdInfo *tdlsDelStaCmdInfo =
&tdlsDelStaCmd->u.tdlsCmd.u.tdlsDelStaCmdInfo ;
vos_mem_zero(&tdlsDelStaCmd->u.tdlsCmd, sizeof(tTdlsCmd));
tdlsDelStaCmd->sessionId = sessionId;
palCopyMemory(pMac->hHdd, tdlsDelStaCmdInfo->peerMac,
peerMac, sizeof(tSirMacAddr)) ;
tdlsDelStaCmd->command = eSmeCommandTdlsDelPeer ;
tdlsDelStaCmd->u.tdlsCmd.size = sizeof(tTdlsDelStaCmdInfo) ;
smePushCommand(pMac, tdlsDelStaCmd, FALSE) ;
status = eHAL_STATUS_SUCCESS ;
}
}
return status ;
}
/*
* TDLS request API, called from HDD to enable TDLS link teardown request
* in SME/CSR and send message to PE to trigger TDLS link teardown procedure.
*/
eHalStatus csrTdlsTeardownReq(tHalHandle hHal, tANI_U8 sessionId,
tCsrTdlsTeardownRequest *tdlsTeardownReq)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tSmeCmd *tdlsTeardownReqCmd ;
eHalStatus status = eHAL_STATUS_FAILURE ;
if(tdlsTeardownReq)
{
tdlsTeardownReqCmd = csrGetCommandBuffer(pMac) ;
if(tdlsTeardownReqCmd)
{
tTdlsLinkTeardownCmdinfo *teardownCmdInfo =
&tdlsTeardownReqCmd->u.tdlsCmd.u.tdlsLinkTeardownCmdInfo ;
vos_mem_zero(&tdlsTeardownReqCmd->u.tdlsCmd, sizeof(tTdlsCmd));
tdlsTeardownReqCmd->sessionId = sessionId;
palCopyMemory(pMac->hHdd, teardownCmdInfo->peerMac,
tdlsTeardownReq->peerMac, sizeof(tSirMacAddr)) ;
tdlsTeardownReqCmd->command = eSmeCommandTdlsLinkTear ;
tdlsTeardownReqCmd->u.tdlsCmd.size =
sizeof(tTdlsLinkTeardownCmdinfo) ;
smePushCommand(pMac, tdlsTeardownReqCmd, FALSE) ;
status = eHAL_STATUS_SUCCESS ;
}
}
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 enable TDLS discovery request
* in SME/CSR and send message to PE to trigger TDLS discovery procedure.
*/
eHalStatus csrTdlsDiscoveryReq(tHalHandle hHal, tANI_U8 sessionId, tCsrTdlsDisRequest *tdlsDisReq)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tSmeCmd *tdlsDisReqCmd ;
eHalStatus status = eHAL_STATUS_FAILURE ;
if(tdlsDisReq)
{
tdlsDisReqCmd = csrGetCommandBuffer(pMac) ;
if(tdlsDisReqCmd)
{
tTdlsDisReqCmdinfo *disReqCmdInfo =
&tdlsDisReqCmd->u.tdlsCmd.u.tdlsDisReqCmdInfo ;
tdlsDisReqCmd->sessionId = sessionId;
disReqCmdInfo->tdlsDisType = tdlsDisReq->disType ;
palCopyMemory(pMac->hHdd, disReqCmdInfo->peerMac,
tdlsDisReq->peerMac, sizeof(tSirMacAddr)) ;
tdlsDisReqCmd->command = eSmeCommandTdlsDiscovery ;
tdlsDisReqCmd->u.tdlsCmd.size = sizeof(tTdlsDisReqCmdinfo) ;
smePushCommand(pMac, tdlsDisReqCmd, FALSE) ;
status = eHAL_STATUS_SUCCESS ;
}
}
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;
}
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;
}
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 limGetWPSPBCSessions(tpAniSirGlobal pMac, tANI_U8 *addr,
tANI_U8 *uuid_e, eWPSPBCOverlap *overlap,
tpPESession psessionEntry)
{
int count = 0;
tSirWPSPBCSession *pbc;
tANI_TIMESTAMP curTime;
curTime = (tANI_TIMESTAMP)(palGetTickCount(pMac->hHdd) / PAL_TICKS_PER_SECOND);
palFillMemory( pMac->hHdd, (tANI_U8 *)addr, sizeof(tSirMacAddr), 0);
palFillMemory( pMac->hHdd, (tANI_U8 *)uuid_e, SIR_WPS_UUID_LEN, 0);
for (pbc = psessionEntry->pAPWPSPBCSession; pbc; pbc = pbc->next) {
if (curTime > pbc->timestamp + SIR_WPS_PBC_WALK_TIME)
break;
count++;
if(count > 1)
break;
palCopyMemory(pMac->hHdd, (tANI_U8 *)addr, (tANI_U8 *)pbc->addr, sizeof(tSirMacAddr));
palCopyMemory(pMac->hHdd, (tANI_U8 *)uuid_e, (tANI_U8 *)pbc->uuid_e, SIR_WPS_UUID_LEN);
}
if (count > 1)
{
*overlap = eSAP_WPSPBC_OVERLAP_IN120S; // Overlap
}
else if(count == 0)
{
*overlap = eSAP_WPSPBC_NO_WPSPBC_PROBE_REQ_IN120S; // no WPS probe request in 120 second
} else
{
*overlap = eSAP_WPSPBC_ONE_WPSPBC_PROBE_REQ_IN120S; // One WPS probe request in 120 second
}
PELOGE(limLog(pMac, LOGE, FL("overlap = %d\n"), *overlap);)
static tANI_U32 * encodeCfgReq(tHddHandle hHdd, tANI_U32 *pl, tANI_U32 cfgId, tANI_S32 length, void *pBuf, tANI_U32 value, tANI_U32 type)
{
*pl++ = pal_cpu_to_be32(cfgId) ;
*pl++ = pal_cpu_to_be32(length) ;
if (type == CCM_INTEGER_TYPE)
{
*pl++ = pal_cpu_to_be32(value) ;
}
else
{
palCopyMemory(hHdd, (void *)pl, (void *)pBuf, length);
pl += (CFGOBJ_ALIGN(length) / CFGOBJ_ALIGNTO);
}
return pl ;
}
/*
* 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 ;
}
/**
* 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);)
/*
* TDLS request API, called from HDD to Send Link Establishment Parameters
*/
VOS_STATUS csrTdlsSendLinkEstablishParams(tHalHandle hHal,
tANI_U8 sessionId,
tSirMacAddr peerMac,
tCsrTdlsLinkEstablishParams *tdlsLinkEstablishParams)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tSmeCmd *tdlsLinkEstablishCmd;
eHalStatus status = eHAL_STATUS_FAILURE ;
//If connected and in Infra. Only then allow this
if( CSR_IS_SESSION_VALID( pMac, sessionId ) &&
csrIsConnStateConnectedInfra( pMac, sessionId ) &&
(NULL != peerMac) )
{
tdlsLinkEstablishCmd = csrGetCommandBuffer(pMac) ;
if(tdlsLinkEstablishCmd)
{
tTdlsLinkEstablishCmdInfo *tdlsLinkEstablishCmdInfo =
&tdlsLinkEstablishCmd->u.tdlsCmd.u.tdlsLinkEstablishCmdInfo ;
tdlsLinkEstablishCmd->sessionId = sessionId;
palCopyMemory(pMac->hHdd, tdlsLinkEstablishCmdInfo->peerMac,
peerMac, sizeof(tSirMacAddr));
tdlsLinkEstablishCmdInfo->isBufSta = tdlsLinkEstablishParams->isBufSta;
tdlsLinkEstablishCmdInfo->isResponder= tdlsLinkEstablishParams->isResponder;
tdlsLinkEstablishCmdInfo->maxSp= tdlsLinkEstablishParams->maxSp;
tdlsLinkEstablishCmdInfo->uapsdQueues= tdlsLinkEstablishParams->uapsdQueues;
tdlsLinkEstablishCmd->command = eSmeCommandTdlsLinkEstablish ;
tdlsLinkEstablishCmd->u.tdlsCmd.size = sizeof(tTdlsLinkEstablishCmdInfo) ;
smePushCommand(pMac, tdlsLinkEstablishCmd, FALSE) ;
status = eHAL_STATUS_SUCCESS ;
}
}
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()
eHalStatus tdlsMsgProcessor(tpAniSirGlobal pMac, v_U16_t msgType,
void *pMsgBuf)
{
switch(msgType)
{
case eWNI_SME_TDLS_SEND_MGMT_RSP:
{
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsSendMgmt) ;
}
break;
case eWNI_SME_TDLS_ADD_STA_RSP:
{
tSirTdlsAddStaRsp *addStaRsp = (tSirTdlsAddStaRsp *) pMsgBuf ;
eCsrRoamResult roamResult ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, addStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = addStaRsp->staId ;
roamInfo.ucastSig = addStaRsp->ucastSig ;
roamInfo.bcastSig = addStaRsp->bcastSig ;
roamInfo.statusCode = addStaRsp->statusCode ;
if (addStaRsp->tdlsAddOper == TDLS_OPER_ADD)
roamResult = eCSR_ROAM_RESULT_ADD_TDLS_PEER;
else
roamResult = eCSR_ROAM_RESULT_UPDATE_TDLS_PEER;
csrRoamCallCallback(pMac, addStaRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
roamResult);
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsAddPeer) ;
}
break;
case eWNI_SME_TDLS_DEL_STA_RSP:
{
tSirTdlsDelStaRsp *delStaRsp = (tSirTdlsDelStaRsp *) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, delStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = delStaRsp->staId ;
roamInfo.statusCode = delStaRsp->statusCode ;
csrRoamCallCallback(pMac, delStaRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_DELETE_TDLS_PEER);
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsDelPeer) ;
}
break;
case eWNI_SME_TDLS_DEL_STA_IND:
{
tpSirTdlsDelStaInd pSirTdlsDelStaInd = (tpSirTdlsDelStaInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, pSirTdlsDelStaInd->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = pSirTdlsDelStaInd->staId ;
roamInfo.reasonCode = pSirTdlsDelStaInd->reasonCode ;
csrRoamCallCallback(pMac, pSirTdlsDelStaInd->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_TEARDOWN_TDLS_PEER_IND);
break ;
}
case eWNI_SME_TDLS_DEL_ALL_PEER_IND:
{
tpSirTdlsDelAllPeerInd pSirTdlsDelAllPeerInd = (tpSirTdlsDelAllPeerInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
csrRoamCallCallback(pMac, pSirTdlsDelAllPeerInd->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_DELETE_ALL_TDLS_PEER_IND);
break ;
}
case eWNI_SME_MGMT_FRM_TX_COMPLETION_IND:
{
tpSirMgmtTxCompletionInd pSirTdlsDelAllPeerInd = (tpSirMgmtTxCompletionInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
roamInfo.reasonCode = pSirTdlsDelAllPeerInd->txCompleteStatus;
csrRoamCallCallback(pMac, pSirTdlsDelAllPeerInd->sessionId, &roamInfo,
0, eCSR_ROAM_RESULT_MGMT_TX_COMPLETE_IND, 0);
break;
}
case eWNI_SME_TDLS_LINK_ESTABLISH_RSP:
{
tSirTdlsLinkEstablishReqRsp *linkEstablishReqRsp = (tSirTdlsLinkEstablishReqRsp *) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
#if 0
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, delStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = delStaRsp->staId ;
roamInfo.statusCode = delStaRsp->statusCode ;
#endif
csrRoamCallCallback(pMac, linkEstablishReqRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_LINK_ESTABLISH_REQ_RSP);
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsLinkEstablish);
break;
}
#ifdef FEATURE_WLAN_TDLS_INTERNAL
case eWNI_SME_TDLS_DISCOVERY_START_RSP:
{
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsDiscovery) ;
}
case eWNI_SME_TDLS_DISCOVERY_START_IND:
{
tSirTdlsDisRsp *disRsp = (tSirTdlsDisRsp *)pMsgBuf ;
if(eSIR_SME_SUCCESS == disRsp->statusCode)
{
tCsrTdlsCtxStruct *disInfo = &pMac->tdlsCtx ;
tANI_U16 disStaCount = disRsp->numDisSta ;
tCsrTdlsPeerLinkinfo *peerLinkInfo = NULL ;
tANI_U8 i = 0 ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("DIS START RSP/IND recieved sta count = %d"), disStaCount) ;
for( ; i < disStaCount ; i++)
{
tSirTdlsPeerInfo *peerInfo = &disRsp->tdlsDisPeerInfo[i] ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("SME, peer MAC: "MAC_ADDRESS_STR),
MAC_ADDR_ARRAY(peerInfo->peerMac));
peerLinkInfo = findTdlsPeer(pMac,
&disInfo->tdlsPotentialPeerList,
peerInfo->peerMac) ;
if(NULL == peerLinkInfo)
{
tdlsSaveTdlsPeerInfo(pMac, peerInfo) ;
}
else
{
tSirTdlsPeerInfo *newPeerInfo =
&peerLinkInfo->tdlsDisPeerInfo ;
newPeerInfo->tdlsPeerRssi = peerInfo->tdlsPeerRssi ;
}
}
if(0 == i)
{
smsLog( pMac, LOGW, "there is no tdls client \
discovered .." ) ;
}
}
else
{
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()
/*
* TDLS Message processor, will be called after TDLS message recieved from
* PE
*/
eHalStatus tdlsMsgProcessor(tpAniSirGlobal pMac, v_U16_t msgType,
void *pMsgBuf)
{
switch(msgType)
{
case eWNI_SME_TDLS_SEND_MGMT_RSP:
{
/* remove pending eSmeCommandTdlsDiscovery command */
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsSendMgmt) ;
}
break;
case eWNI_SME_TDLS_ADD_STA_RSP:
{
tSirTdlsAddStaRsp *addStaRsp = (tSirTdlsAddStaRsp *) pMsgBuf ;
eCsrRoamResult roamResult ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, addStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = addStaRsp->staId ;
roamInfo.ucastSig = addStaRsp->ucastSig ;
roamInfo.bcastSig = addStaRsp->bcastSig ;
roamInfo.statusCode = addStaRsp->statusCode ;
/*
* register peer with TL, we have to go through HDD as this is
* the only way to register any STA with TL.
*/
if (addStaRsp->tdlsAddOper == TDLS_OPER_ADD)
roamResult = eCSR_ROAM_RESULT_ADD_TDLS_PEER;
else /* addStaRsp->tdlsAddOper must be TDLS_OPER_UPDATE */
roamResult = eCSR_ROAM_RESULT_UPDATE_TDLS_PEER;
csrRoamCallCallback(pMac, addStaRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
roamResult);
/* remove pending eSmeCommandTdlsDiscovery command */
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsAddPeer) ;
}
break;
case eWNI_SME_TDLS_DEL_STA_RSP:
{
tSirTdlsDelStaRsp *delStaRsp = (tSirTdlsDelStaRsp *) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, delStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = delStaRsp->staId ;
roamInfo.statusCode = delStaRsp->statusCode ;
/*
* register peer with TL, we have to go through HDD as this is
* the only way to register any STA with TL.
*/
csrRoamCallCallback(pMac, delStaRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_DELETE_TDLS_PEER);
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsDelPeer) ;
}
break;
case eWNI_SME_TDLS_DEL_STA_IND:
{
tpSirTdlsDelStaInd pSirTdlsDelStaInd = (tpSirTdlsDelStaInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, pSirTdlsDelStaInd->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = pSirTdlsDelStaInd->staId ;
roamInfo.reasonCode = pSirTdlsDelStaInd->reasonCode ;
/* Sending the TEARDOWN indication to HDD. */
csrRoamCallCallback(pMac, pSirTdlsDelStaInd->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_TEARDOWN_TDLS_PEER_IND);
break ;
}
case eWNI_SME_TDLS_DEL_ALL_PEER_IND:
{
tpSirTdlsDelAllPeerInd pSirTdlsDelAllPeerInd = (tpSirTdlsDelAllPeerInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
/* Sending the TEARDOWN indication to HDD. */
csrRoamCallCallback(pMac, pSirTdlsDelAllPeerInd->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_DELETE_ALL_TDLS_PEER_IND);
break ;
}
case eWNI_SME_MGMT_FRM_TX_COMPLETION_IND:
{
tpSirMgmtTxCompletionInd pSirTdlsDelAllPeerInd = (tpSirMgmtTxCompletionInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
roamInfo.reasonCode = pSirTdlsDelAllPeerInd->txCompleteStatus;
csrRoamCallCallback(pMac, pSirTdlsDelAllPeerInd->sessionId, &roamInfo,
0, eCSR_ROAM_RESULT_MGMT_TX_COMPLETE_IND, 0);
}
#ifdef FEATURE_WLAN_TDLS_INTERNAL
case eWNI_SME_TDLS_DISCOVERY_START_RSP:
{
/* remove pending eSmeCommandTdlsDiscovery command */
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsDiscovery) ;
}
/* fall through .. */
case eWNI_SME_TDLS_DISCOVERY_START_IND:
{
tSirTdlsDisRsp *disRsp = (tSirTdlsDisRsp *)pMsgBuf ;
if(eSIR_SME_SUCCESS == disRsp->statusCode)
{
tCsrTdlsCtxStruct *disInfo = &pMac->tdlsCtx ;
tANI_U16 disStaCount = disRsp->numDisSta ;
tCsrTdlsPeerLinkinfo *peerLinkInfo = NULL ;
tANI_U8 i = 0 ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("DIS START RSP/IND recieved sta count = %d"), disStaCount) ;
for( ; i < disStaCount ; i++)
{
tSirTdlsPeerInfo *peerInfo = &disRsp->tdlsDisPeerInfo[i] ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("SME, peer MAC:")) ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
(" %02x,%02x,%02x,%02x,%02x,%02x"),
peerInfo->peerMac[0],
peerInfo->peerMac[1],
peerInfo->peerMac[2],
peerInfo->peerMac[3],
peerInfo->peerMac[4],
peerInfo->peerMac[5]) ;
peerLinkInfo = findTdlsPeer(pMac,
&disInfo->tdlsPotentialPeerList,
peerInfo->peerMac) ;
if(NULL == peerLinkInfo)
{
/* update discovery data base, if this is new entry */
tdlsSaveTdlsPeerInfo(pMac, peerInfo) ;
}
else
{
/* update RSSI of existing peer */
tSirTdlsPeerInfo *newPeerInfo =
&peerLinkInfo->tdlsDisPeerInfo ;
newPeerInfo->tdlsPeerRssi = peerInfo->tdlsPeerRssi ;
}
}
if(0 == i)
{
smsLog( pMac, LOGW, "there is no tdls client \
discovered .." ) ;
}
}
else
{
/*
* 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 ;
}
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 );
}
static eHalStatus cfgSetSub(tpAniSirGlobal pMac, tHddHandle hHdd, tANI_U32 cfgId, tANI_U32 type,
tANI_S32 length, void *ccmPtr, tANI_U32 ccmValue,
tCcmCfgSetCallback callback, eAniBoolean toBeSaved, void *sem, tCfgReq **r)
{
eHalStatus status = eHAL_STATUS_SUCCESS;
tCfgReq *req ;
do
{
*r = NULL ;
if (pMac->ccm.state == eCCM_STOPPED)
{
status = eHAL_STATUS_FAILURE ;
break ;
}
req = allocateCfgReq(hHdd, type, length);
if (req == NULL)
{
status = eHAL_STATUS_FAILED_ALLOC ;
break ;
}
req->next = NULL ;
req->cfgId = (tANI_U16)cfgId ;
req->type = (tANI_U8)type ;
req->state = eCCM_REQ_QUEUED ;
req->toBeSaved = !!toBeSaved ;
req->length = length ;
req->done = sem ;
req->callback = callback ;
if (type == CCM_INTEGER_TYPE)
{
req->ccmValue = ccmValue ;
}
else
{
palCopyMemory(hHdd, (void*)req->ccmPtr, (void*)ccmPtr, length);
}
palSpinLockTake(hHdd, pMac->ccm.lock);
add_req_tail(req, &pMac->ccm.reqQ);
if ((pMac->ccm.replay.started == 0) && (pMac->ccm.reqQ.head == req))
{
req->state = eCCM_REQ_SENT;
palSpinLockGive(hHdd, pMac->ccm.lock);
status = sendCfg(pMac, hHdd, req, eANI_BOOLEAN_TRUE) ;
if (status != eHAL_STATUS_SUCCESS)
{
smsLog( pMac, LOGE, FL("sendCfg() failed"));
palSpinLockTake(hHdd, pMac->ccm.lock);
del_req(req, &pMac->ccm.reqQ);
palSpinLockGive(hHdd, pMac->ccm.lock);
freeCfgReq(hHdd, req);
break ;
}
else
{
palSpinLockTake(hHdd, pMac->ccm.lock);
if(req != pMac->ccm.reqQ.head)
{
req = NULL;
}
palSpinLockGive(hHdd, pMac->ccm.lock);
}
}
else
{
palSpinLockGive(hHdd, pMac->ccm.lock);
}
*r = req ;
} while(0) ;
return status;
}
/*
* TDLS request API, called from HDD to add a TDLS peer
*/
eHalStatus csrTdlsChangePeerSta(tHalHandle hHal, tANI_U8 sessionId, tSirMacAddr peerMac,
tCsrStaParams *pstaParams)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tSmeCmd *tdlsAddStaCmd ;
eHalStatus status = eHAL_STATUS_FAILURE ;
//If connected and in Infra. Only then allow this
if (CSR_IS_SESSION_VALID( pMac, sessionId ) &&
csrIsConnStateConnectedInfra( pMac, sessionId ) &&
(NULL != peerMac)){
tdlsAddStaCmd = csrGetCommandBuffer(pMac) ;
if (tdlsAddStaCmd)
{
tTdlsAddStaCmdInfo *tdlsAddStaCmdInfo =
&tdlsAddStaCmd->u.tdlsCmd.u.tdlsAddStaCmdInfo ;
vos_mem_zero(&tdlsAddStaCmd->u.tdlsCmd, sizeof(tTdlsCmd));
tdlsAddStaCmdInfo->tdlsAddOper = TDLS_OPER_UPDATE;
tdlsAddStaCmd->sessionId = sessionId;
palCopyMemory(pMac->hHdd, tdlsAddStaCmdInfo->peerMac,
peerMac, sizeof(tSirMacAddr)) ;
tdlsAddStaCmdInfo->capability = pstaParams->capability;
tdlsAddStaCmdInfo->uapsdQueues = pstaParams->uapsd_queues;
tdlsAddStaCmdInfo->maxSp = pstaParams->max_sp;
palCopyMemory(pMac->hHdd, tdlsAddStaCmdInfo->extnCapability,
pstaParams->extn_capability,
sizeof(pstaParams->extn_capability));
tdlsAddStaCmdInfo->htcap_present = pstaParams->htcap_present;
if(pstaParams->htcap_present)
palCopyMemory(pMac->hHdd, &tdlsAddStaCmdInfo->HTCap,
&pstaParams->HTCap, sizeof(pstaParams->HTCap));
else
palZeroMemory(pMac->hHdd, &tdlsAddStaCmdInfo->HTCap, sizeof(pstaParams->HTCap));
tdlsAddStaCmdInfo->vhtcap_present = pstaParams->vhtcap_present;
if(pstaParams->vhtcap_present)
palCopyMemory(pMac->hHdd, &tdlsAddStaCmdInfo->VHTCap,
&pstaParams->VHTCap, sizeof(pstaParams->VHTCap));
else
palZeroMemory(pMac->hHdd, &tdlsAddStaCmdInfo->VHTCap, sizeof(pstaParams->VHTCap));
tdlsAddStaCmdInfo->supportedRatesLen = pstaParams->supported_rates_len;
if (0 != pstaParams->supported_rates_len)
palCopyMemory(pMac->hHdd, &tdlsAddStaCmdInfo->supportedRates,
pstaParams->supported_rates,
pstaParams->supported_rates_len);
tdlsAddStaCmd->command = eSmeCommandTdlsAddPeer;
tdlsAddStaCmd->u.tdlsCmd.size = sizeof(tTdlsAddStaCmdInfo) ;
smePushCommand(pMac, tdlsAddStaCmd, FALSE) ;
status = eHAL_STATUS_SUCCESS ;
}
}
return status ;
}
void
limCollectBssDescription(tpAniSirGlobal pMac,
tSirBssDescription *pBssDescr,
tpSirProbeRespBeacon pBPR,
tANI_U8 *pRxPacketInfo)
#endif
{
tANI_U8 *pBody;
tANI_U32 ieLen = 0;
tpSirMacMgmtHdr pHdr;
tANI_U8 channelNum;
tANI_U8 rxChannel;
pHdr = WDA_GET_RX_MAC_HEADER(pRxPacketInfo);
ieLen = WDA_GET_RX_PAYLOAD_LEN(pRxPacketInfo) - SIR_MAC_B_PR_SSID_OFFSET;
rxChannel = WDA_GET_RX_CH(pRxPacketInfo);
pBody = WDA_GET_RX_MPDU_DATA(pRxPacketInfo);
/**
* Length of BSS desription is without length of
* length itself and length of pointer
* that holds the next BSS description
*/
pBssDescr->length = (tANI_U16)(
sizeof(tSirBssDescription) - sizeof(tANI_U16) -
sizeof(tANI_U32) + ieLen);
// Copy BSS Id
palCopyMemory( pMac->hHdd, (tANI_U8 *) &pBssDescr->bssId,
(tANI_U8 *) pHdr->bssId,
sizeof(tSirMacAddr));
// Copy Timestamp, Beacon Interval and Capability Info
pBssDescr->scanSysTimeMsec = vos_timer_get_system_time();
pBssDescr->timeStamp[0] = pBPR->timeStamp[0];
pBssDescr->timeStamp[1] = pBPR->timeStamp[1];
pBssDescr->beaconInterval = pBPR->beaconInterval;
pBssDescr->capabilityInfo = limGetU16((tANI_U8 *) &pBPR->capabilityInfo);
/*
* There is a narrow window after Channel Switch msg is sent to HAL and before the AGC is shut
* down and beacons/Probe Rsps can trickle in and we may report the incorrect channel in 5Ghz
* band, so not relying on the 'last Scanned Channel' stored in LIM.
* Instead use the value returned by RXP in BD. This the the same value which HAL programs into
* RXP before every channel switch.
* Right now there is a problem in 5Ghz, where we are receiving beacons from a channel different from
* the currently scanned channel. so incorrect channel is reported to CSR and association does not happen.
* So for now we keep on looking for the channel info in the beacon (DSParamSet IE OR HT Info IE), and only if it
* is not present in the beacon, we go for the channel info present in RXP.
* This fix will work for 5Ghz 11n devices, but for 11a devices, we have to rely on RXP routing flag to get the correct channel.
* So The problem of incorrect channel reporting in 5Ghz will still remain for 11a devices.
*/
pBssDescr->channelId = limGetChannelFromBeacon(pMac, pBPR);
if (pBssDescr->channelId == 0)
{
/* If the channel Id is not retrieved from Beacon, extract the channel from BD */
/* Unmapped the channel.This We have to do since we have done mapping in the hal to
overcome the limitation of RXBD of not able to accomodate the bigger channel number.*/
if (!( rxChannel = limUnmapChannel(rxChannel)))
{
rxChannel = pMac->lim.gLimCurrentScanChannelId;
}
pBssDescr->channelId = rxChannel;
}
pBssDescr->channelIdSelf = rxChannel;
//set the network type in bss description
channelNum = pBssDescr->channelId;
pBssDescr->nwType = limGetNwType(pMac, channelNum, SIR_MAC_MGMT_FRAME, pBPR);
pBssDescr->aniIndicator = pBPR->propIEinfo.aniIndicator;
// Copy RSSI & SINR from BD
PELOG4(limLog(pMac, LOG4, "***********BSS Description for BSSID:*********** ");
sirDumpBuf(pMac, SIR_LIM_MODULE_ID, LOG4, pBssDescr->bssId, 6 );
sirDumpBuf( pMac, SIR_LIM_MODULE_ID, LOG4, (tANI_U8*)pRxPacketInfo, 36 );)
