自学教程：C++ HAL_STATUS_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 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;}

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 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;}

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;}

/* * commands received from CSR */eHalStatus csrTdlsProcessCmd(tpAniSirGlobal pMac, tSmeCmd *cmd){    eSmeCommandType  cmdType = cmd->command ;    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;       default:       {            /* TODO: Add default handling */           break ;       }    }    return status ;}

/* ---------------------------------------------------------------------------    /fn oemData_ProcessOemDataReqCommand    /brief This function is called by the smeProcessCommand when the case hits           eSmeCommandOemDataReq    /return eHalStatus  -------------------------------------------------------------------------------*/eHalStatus oemData_ProcessOemDataReqCommand(tpAniSirGlobal pMac, tSmeCmd *pOemDataReqCmd){    eHalStatus status = eHAL_STATUS_SUCCESS;    //check if the system is in proper mode of operation for    //oem data req/rsp to be functional. Currently, concurrency is not    //supported and the driver must be operational only as    //STA for oem data req/rsp to be functional. We return an invalid    //mode flag if it is operational as any one of the following    //in any of the active sessions    //1. AP Mode    //2. IBSS Mode    //3. BTAMP Mode ...    if(eHAL_STATUS_SUCCESS == oemData_IsOemDataReqAllowed(pMac))    {        smsLog(pMac, LOG1, "%s: OEM_DATA REQ allowed in the current mode", __func__);        pMac->oemData.oemDataReqActive = eANI_BOOLEAN_TRUE;        status = oemData_SendMBOemDataReq(pMac, &(pOemDataReqCmd->u.oemDataCmd.oemDataReq));    }    else    {        smsLog(pMac, LOG1, "%s: OEM_DATA REQ not allowed in the current mode", __func__);        status = eHAL_STATUS_FAILURE;    }    if(!HAL_STATUS_SUCCESS(status))    {        smsLog(pMac, LOG1, "%s: OEM_DATA Failure, Release command", __func__);        oemData_ReleaseOemDataReqCommand(pMac, pOemDataReqCmd, eOEM_DATA_REQ_INVALID_MODE);        pMac->oemData.oemDataReqActive = eANI_BOOLEAN_FALSE;    }    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;}

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 ;            tdlsSendMgmtCmd->sessionId = sessionId;            tdlsSendMgmtCmdInfo->frameType = tdlsSendMgmt->frameType ;               tdlsSendMgmtCmdInfo->dialog = tdlsSendMgmt->dialog ;               tdlsSendMgmtCmdInfo->statusCode = tdlsSendMgmt->statusCode ;            tdlsSendMgmtCmdInfo->responder = tdlsSendMgmt->responder;            tdlsSendMgmtCmdInfo->peerCapability = tdlsSendMgmt->peerCapability;            vos_mem_copy(tdlsSendMgmtCmdInfo->peerMac,                                   tdlsSendMgmt->peerMac, sizeof(tSirMacAddr)) ;             if( (0 != tdlsSendMgmt->len) && (NULL != tdlsSendMgmt->buf) )            {                tdlsSendMgmtCmdInfo->buf = vos_mem_malloc(tdlsSendMgmt->len);                if ( NULL == tdlsSendMgmtCmdInfo->buf )                    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 ;                }                vos_mem_copy(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 ;}

/*-------------------------------------------------------------------------- * * 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_U8 *ric_ies, tANI_U32 ric_ies_ip_len,                    tANI_U32 *ric_ies_length ){    tpAniSirGlobal pMac = PMAC_STRUCT( hHal );    eHalStatus status = eHAL_STATUS_FAILURE;    *ric_ies_length = 0;    status = sme_AcquireGlobalLock( &pMac->sme );    if (!( HAL_STATUS_SUCCESS( status )))        return;    /* All or nothing */    if (pMac->ft.ftSmeContext.psavedFTPreAuthRsp->ric_ies_length >         ric_ies_ip_len)    {       sme_ReleaseGlobalLock( &pMac->sme );       return;    }    vos_mem_copy(ric_ies, pMac->ft.ftSmeContext.psavedFTPreAuthRsp->ric_ies,                  pMac->ft.ftSmeContext.psavedFTPreAuthRsp->ric_ies_length);    *ric_ies_length = pMac->ft.ftSmeContext.psavedFTPreAuthRsp->ric_ies_length;#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG    smsLog( pMac, LOGE, FL(" Filled ric ies = %d/n"), *ric_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;}

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;}

eHalStatus sme_p2pOpen( tHalHandle hHal ){   tpAniSirGlobal pMac = PMAC_STRUCT(hHal);   eHalStatus status = eHAL_STATUS_SUCCESS;   //If static structure is too big, Need to change this function to allocate memory dynamically   vos_mem_zero(&pMac->p2pContext, sizeof( tp2pContext ));   if(!HAL_STATUS_SUCCESS(status))   {      sme_p2pClose(hHal);    }   return status;}

/*-------------------------------------------------------------------------- * * 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;}

tSirRetStatus macStart(tHalHandle hHal, void* pHalMacStartParams){   tSirRetStatus status = eSIR_SUCCESS;   tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;   if (NULL == pMac)   {      VOS_ASSERT(0);      status = eSIR_FAILURE;      return status;   }   pMac->gDriverType = ((tHalMacStartParameters*)pHalMacStartParams)->driverType;   sysLog(pMac, LOG2, FL("called/n"));   do   {#if defined(TRACE_RECORD)      //Enable Tracing      macTraceInit(pMac);#endif      if (!HAL_STATUS_SUCCESS(palAllocateMemory(pMac->hHdd, ((void *)&pMac->pResetMsg), sizeof(tSirMbMsg))))      {         sysLog(pMac, LOGE, FL("pMac->pResetMsg is NULL/n"));         status = eSIR_FAILURE;         break;      }      else      {         palZeroMemory(pMac->hHdd, pMac->pResetMsg, sizeof(tSirMbMsg));      }      if (pMac->gDriverType != eDRIVER_TYPE_MFG)      {         status = peStart(pMac);      }   } while(0);   pMac->sys.abort = false;   return status;}

/* * save TDLS peer info, this will be called after successfull completion * of TDLS discovery procedure. */static eHalStatus tdlsSaveTdlsPeerInfo(tpAniSirGlobal pMac,                                           tSirTdlsPeerInfo *disPeerInfo){    tCsrTdlsPeerLinkinfo *peerInfo = NULL ;     tCsrTdlsCtxStruct *disInfo = &pMac->tdlsCtx ;    eHalStatus status = eHAL_STATUS_FAILURE ;    /*      * Ok, allocate memory for peer info here     * we allocate memory for each peer here and free his memory     * at the time the peer node is getting deleted, possible case is      * teardown     */    peerInfo = vos_mem_malloc(sizeof(tCsrTdlsPeerLinkinfo));    if ( NULL = peerInfo )        status = eHAL_STATUS_FAILURE;    else        status = eHAL_STATUS_SUCCESS;    /*      * go ahead and copy peerInfo and insert this node info discovery rsp     * database.     */     if (HAL_STATUS_SUCCESS(status))    {        vos_mem_set( &peerInfo->tdlsDisPeerInfo,                                            sizeof(tSirTdlsPeerInfo), 0);        vos_mem_copy( &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 ;}

eHalStatus oemData_OemDataReqOpen(tHalHandle hHal){    eHalStatus status = eHAL_STATUS_SUCCESS;    tpAniSirGlobal pMac = PMAC_STRUCT(hHal);    do    {        //initialize all the variables to null        vos_mem_set(&(pMac->oemData), sizeof(tOemDataStruct), 0);        if(!HAL_STATUS_SUCCESS(status))        {            smsLog(pMac, LOGE, "oemData_OemDataReqOpen: Cannot allocate memory for the timer function");            break;        }    } while(0);    return status;}

static char *dump_csr( tpAniSirGlobal pMac, tANI_U32 arg1, tANI_U32 arg2, tANI_U32 arg3, tANI_U32 arg4, char *p ){    static tCsrRoamProfile x;    static tSirMacSSid ssid;   //To be allocated for array of SSIDs    static tANI_U8 sessionId; // Defined for fixed session ID    vos_mem_set((void*)&x, sizeof(x), 0);    x.SSIDs.numOfSSIDs=1 ;    x.SSIDs.SSIDList[0].SSID = ssid ;    ssid.length=6 ;    vos_mem_copy(ssid.ssId, "AniNet", 6);    if(HAL_STATUS_SUCCESS(sme_AcquireGlobalLock( &pMac->sme )))    {        (void)csrRoamConnect(pMac, sessionId, &x, NULL, NULL);        sme_ReleaseGlobalLock( &pMac->sme );    }    return p;}

static char *dump_btcSetEvent( tpAniSirGlobal pMac, tANI_U32 arg1,                                tANI_U32 arg2, tANI_U32 arg3, tANI_U32 arg4, char *p ){    tSmeBtEvent btEvent;    if( arg1 < BT_EVENT_TYPE_MAX )    {        smsLog(pMac, LOGE, FL(" signal BT event (%d) handle (%d) 3rd param(%d)"), arg1, arg2, arg3);        vos_mem_zero(&btEvent, sizeof(tSmeBtEvent));        btEvent.btEventType = arg1;        switch( arg1 )        {        case BT_EVENT_SYNC_CONNECTION_COMPLETE:        case BT_EVENT_SYNC_CONNECTION_UPDATED:            btEvent.uEventParam.btSyncConnection.connectionHandle = (v_U16_t)arg2;            btEvent.uEventParam.btSyncConnection.status = (v_U8_t)arg3;            break;        case BT_EVENT_DISCONNECTION_COMPLETE:            btEvent.uEventParam.btDisconnect.connectionHandle = (v_U16_t)arg2;            break;        case BT_EVENT_CREATE_ACL_CONNECTION:        case BT_EVENT_ACL_CONNECTION_COMPLETE:            btEvent.uEventParam.btAclConnection.connectionHandle = (v_U16_t)arg2;            btEvent.uEventParam.btAclConnection.status = (v_U8_t)arg3;            break;        case BT_EVENT_MODE_CHANGED:            btEvent.uEventParam.btAclModeChange.connectionHandle = (v_U16_t)arg2;            break;        default:            break;        }#ifndef WLAN_MDM_CODE_REDUCTION_OPT        if(HAL_STATUS_SUCCESS(sme_AcquireGlobalLock( &pMac->sme )))        {            btcSignalBTEvent(pMac, &btEvent);            sme_ReleaseGlobalLock( &pMac->sme );        }#endif    }    else    {        smsLog(pMac, LOGE, FL(" invalid event (%d)"), arg1);    }    return p;}

// tdlsoffchaneHalStatus 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;}

eHalStatus sme_FTUpdateKey( tHalHandle hHal, tCsrRoamSetKey * pFTKeyInfo ){    tpAniSirGlobal pMac = PMAC_STRUCT( hHal );    eHalStatus status = eHAL_STATUS_FAILURE;    status = sme_AcquireGlobalLock( &pMac->sme );    if (!( HAL_STATUS_SUCCESS( status )))    {       return eHAL_STATUS_FAILURE;    }    if (pFTKeyInfo == NULL)     {        smsLog( pMac, LOGE, "%s: pFTKeyInfo is NULL/n", __FUNCTION__);        sme_ReleaseGlobalLock( &pMac->sme );        return eHAL_STATUS_FAILURE;     }#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG    smsLog( pMac, LOGE, "sme_FTUpdateKey is received in state %d/n",         pMac->ft.ftSmeContext.FTState);#endif    // Global Station FT State    switch(pMac->ft.ftSmeContext.FTState)    {    case eFT_SET_KEY_WAIT:       status = sme_FTSendUpdateKeyInd( hHal, pFTKeyInfo );       pMac->ft.ftSmeContext.FTState = eFT_START_READY;       break;              default:       smsLog( pMac, LOGE, "%s: Unhandled state=%d/n", __FUNCTION__,               pMac->ft.ftSmeContext.FTState);       status = eHAL_STATUS_FAILURE;       break;    }    sme_ReleaseGlobalLock( &pMac->sme );    return status;}

eHalStatus oemData_OemDataReqClose(tHalHandle hHal){    eHalStatus status = eHAL_STATUS_SUCCESS;    tpAniSirGlobal pMac = PMAC_STRUCT(hHal);    do    {        if(!HAL_STATUS_SUCCESS(status))        {            smsLog(pMac, LOGE, "oemData_OemDataReqClose: Failed in oemData_OemDataReqClose at StopTimers");            break;        }        if(pMac->oemData.pOemDataRsp != NULL)        {            vos_mem_free(pMac->oemData.pOemDataRsp);        }                //initialize all the variables to null        vos_mem_set(&(pMac->oemData), sizeof(tOemDataStruct), 0);    } while(0);    return eHAL_STATUS_SUCCESS;}

/* ---------------------------------------------------------------------------    /fn sme_HandleOemDataRsp    /brief This function processes the oem data response obtained from the PE    /param pMsg - Pointer to the pSirOemDataRsp    /return eHalStatus       -------------------------------------------------------------------------------*/eHalStatus sme_HandleOemDataRsp(tHalHandle hHal, tANI_U8* pMsg){    eHalStatus                         status = eHAL_STATUS_SUCCESS;    tpAniSirGlobal                     pMac;    tListElem                          *pEntry = NULL;    tSmeCmd                            *pCommand = NULL;    tSirOemDataRsp*                    pOemDataRsp = NULL;    pMac = PMAC_STRUCT(hHal);    smsLog(pMac, LOG1, "%s: OEM_DATA Entering", __func__);    do    {        if(pMsg == NULL)        {            smsLog(pMac, LOGE, "in %s msg ptr is NULL", __func__);            status = eHAL_STATUS_FAILURE;            break;        }            pEntry = csrLLPeekHead( &pMac->sme.smeCmdActiveList, LL_ACCESS_LOCK );        if(pEntry)        {            pCommand = GET_BASE_ADDR( pEntry, tSmeCmd, Link );            if(eSmeCommandOemDataReq == pCommand->command)            {                pOemDataRsp = (tSirOemDataRsp*)pMsg;                //make sure to acquire the lock before modifying the data                status = sme_AcquireGlobalLock(&pMac->sme);                if(!HAL_STATUS_SUCCESS(status))                {                    break;                }                if(pMac->oemData.pOemDataRsp != NULL)                {                    vos_mem_free(pMac->oemData.pOemDataRsp);                }                pMac->oemData.pOemDataRsp = (tOemDataRsp*)vos_mem_malloc(sizeof(tOemDataRsp));                if(pMac->oemData.pOemDataRsp == NULL)                {                    sme_ReleaseGlobalLock(&pMac->sme);                    smsLog(pMac, LOGE, "in %s vos_mem_malloc failed for pMac->oemData.pOemDataRsp", __func__);                    status = eHAL_STATUS_FAILURE;                    break;                }                smsLog(pMac, LOGE, "Before memory copy");                vos_mem_copy((v_VOID_t*)(pMac->oemData.pOemDataRsp), (v_VOID_t*)(&pOemDataRsp->oemDataRsp), sizeof(tOemDataRsp));                smsLog(pMac, LOGE, "after memory copy");                sme_ReleaseGlobalLock(&pMac->sme);            }            else            {                smsLog(pMac, LOGE, "in %s eWNI_SME_OEM_DATA_RSP Received but NO REQs are ACTIVE ...",                    __func__);                status = eHAL_STATUS_FAILURE;                break;            }        }        else        {            smsLog(pMac, LOGE, "in %s eWNI_SME_OEM_DATA_RSP Received but NO commands are ACTIVE ...", __func__);            status = eHAL_STATUS_FAILURE;            break;        }        oemData_ReleaseOemDataReqCommand(pMac, pCommand, eHAL_STATUS_SUCCESS);        pMac->oemData.oemDataReqActive = eANI_BOOLEAN_FALSE;    } while(0);    return status;}

/* ---------------------------------------------------------------------------    /fn oemData_OemDataReq    /brief Request an OEM DATA RSP    /param sessionId - Id of session to be used    /param pOemDataReqID - pointer to an object to get back the request ID    /param callback - a callback function that is called upon finish    /param pContext - a pointer passed in for the callback    /return eHalStatus       -------------------------------------------------------------------------------*/eHalStatus oemData_OemDataReq(tHalHandle hHal,                                 tANI_U8 sessionId,                                tOemDataReqConfig *oemDataReqConfig,                                 tANI_U32 *pOemDataReqID,                                 oemData_OemDataReqCompleteCallback callback,                                 void *pContext){    eHalStatus status = eHAL_STATUS_SUCCESS;    tpAniSirGlobal pMac = PMAC_STRUCT( hHal );    tSmeCmd *pOemDataCmd = NULL;    do     {        if( !CSR_IS_SESSION_VALID( pMac, sessionId ) )        {           status = eHAL_STATUS_FAILURE;           break;        }        pMac->oemData.oemDataReqConfig.sessionId = sessionId;        pMac->oemData.callback = callback;        pMac->oemData.pContext = pContext;        pMac->oemData.oemDataReqID = *(pOemDataReqID);            vos_mem_copy((v_VOID_t*)(pMac->oemData.oemDataReqConfig.oemDataReq), (v_VOID_t*)(oemDataReqConfig->oemDataReq), OEM_DATA_REQ_SIZE);            pMac->oemData.oemDataReqActive = eANI_BOOLEAN_FALSE;            pOemDataCmd = smeGetCommandBuffer(pMac);            //fill up the command before posting it.        if(pOemDataCmd)        {            pOemDataCmd->command = eSmeCommandOemDataReq;            pOemDataCmd->u.oemDataCmd.callback = callback;            pOemDataCmd->u.oemDataCmd.pContext = pContext;            pOemDataCmd->u.oemDataCmd.oemDataReqID = pMac->oemData.oemDataReqID;                //set the oem data request            pOemDataCmd->u.oemDataCmd.oemDataReq.sessionId = pMac->oemData.oemDataReqConfig.sessionId;            vos_mem_copy((v_VOID_t*)(pOemDataCmd->u.oemDataCmd.oemDataReq.oemDataReq),                                     (v_VOID_t*)(pMac->oemData.oemDataReqConfig.oemDataReq), OEM_DATA_REQ_SIZE);        }        else        {            status = eHAL_STATUS_FAILURE;            break;        }            //now queue this command in the sme command queue        //Here since this is not interacting with the csr just push the command        //into the sme queue. Also push this command with the normal priority        smePushCommand(pMac, pOemDataCmd, eANI_BOOLEAN_FALSE);    } while(0);    if(!HAL_STATUS_SUCCESS(status) && pOemDataCmd)    {        oemData_ReleaseOemDataReqCommand(pMac, pOemDataCmd, eOEM_DATA_REQ_FAILURE);        pMac->oemData.oemDataReqActive = eANI_BOOLEAN_FALSE;    }    return status;}

/*---------------------------------------------------------------------------- * * The function limSendRemainOnChannelDebugMarkerFrame, prepares Marker frame * for Start and End of remain on channel with RemainOnChannelMsg as Vendor * Specific information element of the frame. * *----------------------------------------------------------------------------*/tSirRetStatus limSendRemainOnChannelDebugMarkerFrame(tpAniSirGlobal pMac,                                                     tANI_U8 *remainOnChannelMsg){    tSirMacAddr          magicMacAddr= {0x11, 0x22, 0x33, 0x44, 0x55, 0x66};    tANI_U32             nBytes, nPayload;    tSirRetStatus        nSirStatus;    tANI_U8              *pFrame;    void                 *pPacket;    eHalStatus           halstatus;    tANI_U8              txFlag = 0;    publicVendorSpecific *pPublicVendorSpecific;    pPublicVendorSpecific = vos_mem_malloc(sizeof(publicVendorSpecific));    if( pPublicVendorSpecific == NULL )    {        limLog( pMac, LOGE,                FL( "Unable to allocate memory for Vendor specific information"                    " element" ) );        return eSIR_MEM_ALLOC_FAILED;    }    // Assigning Action category code as unknown as this is debug marker frame    pPublicVendorSpecific->category = REMAIN_ON_CHANNEL_UNKNOWN_ACTION_CATEGORY;    pPublicVendorSpecific->elementid = VENDOR_SPECIFIC_ELEMENT_ID;    pPublicVendorSpecific->length = strlen(remainOnChannelMsg);    nPayload = sizeof(publicVendorSpecific) + pPublicVendorSpecific->length;    nBytes = nPayload + sizeof( tSirMacMgmtHdr );    halstatus = palPktAlloc( pMac->hHdd, HAL_TXRX_FRM_802_11_MGMT,                             ( tANI_U16 )nBytes, ( void** ) &pFrame,                             ( void** ) &pPacket );    if ( ! HAL_STATUS_SUCCESS ( halstatus ) )    {        limLog( pMac, LOGE, FL("Failed to allocate %d bytes for a Remain"                               " on channel action frame."), nBytes );        nSirStatus = eSIR_MEM_ALLOC_FAILED;        goto end;    }    vos_mem_zero( pFrame, nBytes );    // Populate frame with MAC header    nSirStatus = limPopulateMacHeader( pMac, pFrame, SIR_MAC_MGMT_FRAME,                                SIR_MAC_MGMT_ACTION, magicMacAddr,                                pMac->lim.gSelfMacAddr);    if ( eSIR_SUCCESS != nSirStatus )    {        limLog( pMac, LOGE, FL("Failed to populate the buffer descriptor for a"                               " Action frame for remain on channel.") );        palPktFree( pMac->hHdd, HAL_TXRX_FRM_802_11_MGMT,                    ( void* ) pFrame, ( void* ) pPacket );        goto end;    }    // Copy Public Vendor specific fields to frame's information element    vos_mem_copy( (pFrame + (sizeof( tSirMacMgmtHdr ))),                   pPublicVendorSpecific, sizeof(publicVendorSpecific) );    // Copy Remain On channel message to Vendor Specific information field    vos_mem_copy( (pFrame + (nBytes - pPublicVendorSpecific->length)),                   remainOnChannelMsg, pPublicVendorSpecific->length );    halstatus = halTxFrame( pMac, pPacket,                            ( tANI_U16 ) sizeof(tSirMacMgmtHdr) + nPayload,                            HAL_TXRX_FRM_802_11_MGMT,                            ANI_TXDIR_TODS,                            7,//SMAC_SWBD_TX_TID_MGMT_HIGH,                            limTxComplete, pFrame, txFlag );    if ( ! HAL_STATUS_SUCCESS ( halstatus ) )    {        limLog( pMac, LOGE, FL("could not send marker frame for"                               " remain on channel!" ));        //Pkt will be freed up by the callback        nSirStatus = eSIR_FAILURE;        goto end;    }    nSirStatus = eSIR_SUCCESS;end:    vos_mem_free( pPublicVendorSpecific );    return nSirStatus;}

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 );}

/*--------------------------------------------------------------------------  Each time the supplicant sends down the FT IEs to the driver.  This function is called in SME. This fucntion packages and sends  the FT IEs to PE.  ------------------------------------------------------------------------*/void sme_SetFTIEs( tHalHandle hHal, tANI_U8 sessionId, tANI_U8 *ft_ies,         tANI_U16 ft_ies_length ){    tpAniSirGlobal pMac = PMAC_STRUCT( hHal );    eHalStatus status = eHAL_STATUS_FAILURE;    status = sme_AcquireGlobalLock( &pMac->sme );    if (!( HAL_STATUS_SUCCESS( status ))) return;    if (ft_ies == NULL)     {        smsLog( pMac, LOGE, FL(" ft ies is NULL/n"));        sme_ReleaseGlobalLock( &pMac->sme );        return;     }#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG    smsLog( pMac, LOGE, "FT IEs Req is received in state %d/n",         pMac->ft.ftSmeContext.FTState);#endif    // Global Station FT State    switch(pMac->ft.ftSmeContext.FTState)    {        case eFT_START_READY:        case eFT_AUTH_REQ_READY:            if ((pMac->ft.ftSmeContext.auth_ft_ies) &&                     (pMac->ft.ftSmeContext.auth_ft_ies_length))            {                // Free the one we received last from the supplicant                vos_mem_free(pMac->ft.ftSmeContext.auth_ft_ies);                pMac->ft.ftSmeContext.auth_ft_ies_length = 0;             }            // Save the FT IEs            pMac->ft.ftSmeContext.auth_ft_ies = vos_mem_malloc(ft_ies_length);            if(pMac->ft.ftSmeContext.auth_ft_ies == NULL)            {               smsLog( pMac, LOGE, FL("Memory allocation failed for "                                      "auth_ft_ies/n"));               sme_ReleaseGlobalLock( &pMac->sme );               return;            }            pMac->ft.ftSmeContext.auth_ft_ies_length = ft_ies_length;            vos_mem_copy((tANI_U8 *)pMac->ft.ftSmeContext.auth_ft_ies, ft_ies,                ft_ies_length);                            pMac->ft.ftSmeContext.FTState = eFT_AUTH_REQ_READY;#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG            smsLog( pMac, LOGE, "ft_ies_length=%d/n", ft_ies_length);            /*            smsLog( pMac, LOGE, "%d: New Auth ft_ies_length=%02x%02x%02x/n",                 current->pid, pMac->ft.ftSmeContext.auth_ft_ies[0],                pMac->ft.ftSmeContext.auth_ft_ies[1],                pMac->ft.ftSmeContext.auth_ft_ies[2]);                */#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, LOGE,                 "Pre-auth done and now receiving---> AUTH REQ <---- in state %d/n",                 pMac->ft.ftSmeContext.FTState);            smsLog( pMac, LOGE, "Unhandled reception of FT IES in state %d/n",                 pMac->ft.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, LOGE, "New Reassoc Req=%p in state %d/n",                 ft_ies, pMac->ft.ftSmeContext.FTState);#endif            if ((pMac->ft.ftSmeContext.reassoc_ft_ies) &&                 (pMac->ft.ftSmeContext.reassoc_ft_ies_length))            {                // Free the one we received last from the supplicant                vos_mem_free(pMac->ft.ftSmeContext.reassoc_ft_ies);                pMac->ft.ftSmeContext.reassoc_ft_ies_length = 0;             }            // Save the FT IEs//.........这里部分代码省略.........

/* 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"#endifextern tSirRetStatus halDoCfgInit(tpAniSirGlobal pMac);extern tSirRetStatus halProcessStartEvent(tpAniSirGlobal pMac);tSirRetStatus macReset(tpAniSirGlobal pMac, tANI_U32 rc);#ifdef FEATURE_WLAN_INTEGRATED_SOCtSirRetStatus 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"));//.........这里部分代码省略.........

eHalStatus sme_FTUpdateKey( tHalHandle hHal, tCsrRoamSetKey * pFTKeyInfo ){    tpAniSirGlobal pMac = PMAC_STRUCT( hHal );    eHalStatus status = eHAL_STATUS_FAILURE;    status = sme_AcquireGlobalLock( &pMac->sme );    if (!( HAL_STATUS_SUCCESS( status )))    {       return eHAL_STATUS_FAILURE;    }    if (pFTKeyInfo == NULL)    {        smsLog( pMac, LOGE, "%s: pFTKeyInfo is NULL", __func__);        sme_ReleaseGlobalLock( &pMac->sme );        return eHAL_STATUS_FAILURE;    }#if defined WLAN_FEATURE_VOWIFI_11R_DEBUG    smsLog( pMac, LOG1, "sme_FTUpdateKey is received in state %d",        pMac->ft.ftSmeContext.FTState);#endif    // Global Station FT State    switch(pMac->ft.ftSmeContext.FTState)    {    case eFT_SET_KEY_WAIT:#ifdef DEBUG_ROAM_DELAY    //store the PTK send event    vos_record_roam_event(e_HDD_SET_PTK_REQ, NULL, 0);#endif    if (sme_GetFTPreAuthState (hHal) == TRUE)      {          status = sme_FTSendUpdateKeyInd(pMac, pFTKeyInfo);          if (status != 0 )          {              smsLog( pMac, LOGE, "%s: Key set failure %d", __func__,                      status);              pMac->ft.ftSmeContext.setFTPTKState = FALSE;              status = eHAL_STATUS_FT_PREAUTH_KEY_FAILED;          }          else          {              pMac->ft.ftSmeContext.setFTPTKState = TRUE;              status = eHAL_STATUS_FT_PREAUTH_KEY_SUCCESS;              smsLog( pMac, LOG1, "%s: Key set success", __func__);          }          sme_SetFTPreAuthState(hHal, FALSE);      }      pMac->ft.ftSmeContext.FTState = eFT_START_READY;#ifdef WLAN_FEATURE_VOWIFI_11R_DEBUG      smsLog( pMac, LOG1, "%s: state changed to %d status %d", __func__,              pMac->ft.ftSmeContext.FTState, status);#endif       break;              default:       smsLog( pMac, LOGE, "%s: Unhandled state=%d", __func__,               pMac->ft.ftSmeContext.FTState);       status = eHAL_STATUS_FAILURE;       break;    }    sme_ReleaseGlobalLock( &pMac->sme );    return status;}