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;
}
/**
* aniSsmReplayCtrCreate
*
* Creates a replay counter and initializes it for first time
* use. The initialization can be done randomly or with a passed in
* value like 0. In case this is going to be used on the RX side, it
* doesn't matter what the initialization is and can be optimized to
* a fixed value so as to avoid the overhead of obtaining a random
* value.
*
* @param ctrPtr a pointer that will be set to the newly allocated
* counter if the operation succeeds
* @param size the number of bytes that are desired in the counter
* @param initValue if this is negative and size is greater than 4,
* the initialization is done randomly. Otherwise, these bytes are
* copied into the least significant four or less octets of the
* counter, depending on the size of the counter. i.e., if the counter
* is only 2B, then the least significant 2B of initValue will be
* copied over.
*
* @return ANI_OK if the operation succeeds
*/
int
aniSsmReplayCtrCreate(v_U32_t cryptHandle, tAniSsmReplayCtr **ctrPtr,
v_U8_t size,
int initValue)
{
tAniSsmReplayCtr *ctr;
ctr = vos_mem_malloc( sizeof(tAniSsmReplayCtr) );
if( NULL == ctr )
{
return ANI_E_MALLOC_FAILED;
}
ctr->buf = vos_mem_malloc( size );
if (ctr->buf == NULL)
{
VOS_ASSERT( 0 );
vos_mem_free(ctr);
return ANI_E_MALLOC_FAILED;
}
ctr->size = size;
// We cannot randomly generate the most significant bytes if the
// total number of bytes is not greater than 4 (sizeof ANI_U32).
if (initValue < 0 && ctr->size <= 4)
initValue = 0;
// If initValue is negative, initialize the ctr randomly, else
// initialize it to what the user specified.
if (initValue < 0)
{
if( !VOS_IS_STATUS_SUCCESS( vos_rand_get_bytes(cryptHandle, ctr->buf, ctr->size) ) )
{
return ANI_ERROR;
}
}
else {
ctr->currentValue = initValue - 1;
}
*ctrPtr = ctr;
return ANI_OK;
}
/*------------------------------------------------------------------
*
* Below function is called if pMac->fP2pListenOffload enabled and hdd
* requests a remain on channel.
*
*------------------------------------------------------------------*/
static eHalStatus limSendHalReqRemainOnChanOffload(tpAniSirGlobal pMac,
tSirRemainOnChnReq *pRemOnChnReq)
{
tSirScanOffloadReq *pScanOffloadReq;
tSirMsgQ msg;
tSirRetStatus rc = eSIR_SUCCESS;
tANI_U8 bssid[SIR_MAC_ADDR_LENGTH] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
pScanOffloadReq = vos_mem_malloc(sizeof(tSirScanOffloadReq));
if (NULL == pScanOffloadReq)
{
limLog(pMac, LOGE,
FL("Memory allocation failed for pScanOffloadReq"));
return eHAL_STATUS_FAILURE;
}
vos_mem_zero(pScanOffloadReq, sizeof(tSirScanOffloadReq));
msg.type = WDA_START_SCAN_OFFLOAD_REQ;
msg.bodyptr = pScanOffloadReq;
msg.bodyval = 0;
vos_mem_copy((tANI_U8 *) pScanOffloadReq->selfMacAddr,
(tANI_U8 *) pRemOnChnReq->selfMacAddr,
sizeof(tSirMacAddr));
vos_mem_copy((tANI_U8 *) pScanOffloadReq->bssId,
(tANI_U8 *) bssid,
sizeof(tSirMacAddr));
pScanOffloadReq->scanType = eSIR_PASSIVE_SCAN;
pScanOffloadReq->p2pScanType = P2P_SCAN_TYPE_LISTEN;
pScanOffloadReq->minChannelTime = pRemOnChnReq->duration;
pScanOffloadReq->maxChannelTime = pRemOnChnReq->duration;
pScanOffloadReq->sessionId = pRemOnChnReq->sessionId;
pScanOffloadReq->channelList.numChannels = 1;
pScanOffloadReq->channelList.channelNumber[0] = pRemOnChnReq->chnNum;
limLog(pMac, LOG1,
FL("Req-rem-on-channel: duration %u, session %hu, chan %hu"),
pRemOnChnReq->duration, pRemOnChnReq->sessionId,
pRemOnChnReq->chnNum);
rc = wdaPostCtrlMsg(pMac, &msg);
if (rc != eSIR_SUCCESS)
{
limLog(pMac, LOGE, FL("wdaPostCtrlMsg() return failure %u"),
rc);
vos_mem_free(pScanOffloadReq);
return eHAL_STATUS_FAILURE;
}
pMac->lim.fOffloadScanPending = 1;
pMac->lim.fOffloadScanP2PListen = 1;
return eHAL_STATUS_SUCCESS;
}
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;
}
tSirRetStatus schSetFixedBeaconFields(tpAniSirGlobal pMac,tpPESession psessionEntry)
{
tpAniBeaconStruct pBeacon = (tpAniBeaconStruct)
pMac->sch.schObject.gSchBeaconFrameBegin;
tpSirMacMgmtHdr mac;
tANI_U16 offset;
tANI_U8 *ptr;
tDot11fBeacon1 *pBcn1;
tDot11fBeacon2 *pBcn2;
tANI_U32 i, nStatus, nBytes;
tANI_U32 wpsApEnable=0, tmp;
tDot11fIEWscProbeRes *pWscProbeRes;
tANI_U8 *pExtraIe = NULL;
tANI_U32 extraIeLen =0;
tANI_U16 extraIeOffset = 0;
tANI_U16 p2pIeOffset = 0;
tSirRetStatus status = eSIR_SUCCESS;
pBcn1 = vos_mem_malloc(sizeof(tDot11fBeacon1));
if ( NULL == pBcn1 )
{
schLog(pMac, LOGE, FL("Failed to allocate memory") );
return eSIR_FAILURE;
}
pBcn2 = vos_mem_malloc(sizeof(tDot11fBeacon2));
if ( NULL == pBcn2 )
{
schLog(pMac, LOGE, FL("Failed to allocate memory") );
vos_mem_free(pBcn1);
return eSIR_FAILURE;
}
pWscProbeRes = vos_mem_malloc(sizeof(tDot11fIEWscProbeRes));
if ( NULL == pWscProbeRes )
{
schLog(pMac, LOGE, FL("Failed to allocate memory") );
vos_mem_free(pBcn1);
vos_mem_free(pBcn2);
return eSIR_FAILURE;
}
PELOG1(schLog(pMac, LOG1, FL("Setting fixed beacon fields"));)
/**
* aniAsfPacketAllocateExplicit
*
* FUNCTION:
* Create a packet of the desired size and position the head of the
* packet at the desired offset in the internal raw data buffer. An
* application would normally set this offset to the expected length
* of the protocol header, then append the payload, and finally,
* prepend the header. The allocated storage can be free with a call
* to aniAsfPacketFree.
*
* LOGIC:
* Allocates storage for tAniPacket and its internal raw data
* buffer. Positions the head and tail pointers at the given offset in
* the internal raw data buffer.
*
* @param packetPtr pointer that will be set to newly allocated
* tAniPacket if the operation succeeds.
* @param size the size of the internal raw data buffer
* @param offset the offset in the internal raw data buffer where the
* head of the packet will be positioned initially
*
* @return ANI_OK if the operation succeeds; ANI_E_MALLOC_FAILED if
* memory could not be allocated.
* @see aniAsfPacketFree
*/
int
aniAsfPacketAllocateExplicit(tAniPacket **packetPtr,
v_U32_t size,
v_U32_t offset)
{
tAniPacket *packet = NULL;
v_U32_t maxHead = size;
*packetPtr = NULL;
if (size == 0)
return ANI_E_ILLEGAL_ARG;
VOS_ASSERT(ANI_CHECK_RANGE(offset, maxHead));
if (!ANI_CHECK_RANGE(offset, maxHead))
return ANI_E_ILLEGAL_ARG;
packet = (tAniPacket *) vos_mem_malloc( sizeof(tAniPacket) );
if (packet == NULL)
{
VOS_ASSERT( 0 );
return ANI_E_MALLOC_FAILED;
}
// transparently add one to the size since last byte is wasted
size = (size + 4) & 0xfffffffc;
packet->buf = (v_U8_t *)vos_mem_malloc( sizeof(v_U8_t) * size );
if (packet->buf == NULL)
{
vos_mem_free( packet );
VOS_ASSERT( 0 );
return ANI_E_MALLOC_FAILED;
}
packet->size = size; // Should not be visible to the user
packet->head = packet->buf + offset;
packet->tail = packet->head;
packet->len = 0;
*packetPtr = packet;
return ANI_OK;
}
eHalStatus p2pProcessRemainOnChannelCmd(tpAniSirGlobal pMac, tSmeCmd *p2pRemainonChn)
{
eHalStatus status = eHAL_STATUS_FAILURE;
tSirRemainOnChnReq* pMsg;
tANI_U32 len;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, p2pRemainonChn->sessionId );
if(!pSession)
{
smsLog(pMac, LOGE, FL(" session %d not found "), p2pRemainonChn->sessionId);
goto error;
}
if(!pSession->sessionActive)
{
smsLog(pMac, LOGE, FL(" session %d is invalid or listen is disabled "),
p2pRemainonChn->sessionId);
goto error;
}
len = sizeof(tSirRemainOnChnReq) + pMac->p2pContext.probeRspIeLength;
if( len > 0xFFFF )
{
/*In coming len for Msg is more then 16bit value*/
smsLog(pMac, LOGE, FL(" Message length is very large, %d"),
len);
goto error;
}
pMsg = vos_mem_malloc(len);
if ( NULL == pMsg )
goto error;
else
{
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO, "%s call", __func__);
vos_mem_set(pMsg, sizeof(tSirRemainOnChnReq), 0);
pMsg->messageType = eWNI_SME_REMAIN_ON_CHANNEL_REQ;
pMsg->length = (tANI_U16)len;
vos_mem_copy(pMsg->selfMacAddr, pSession->selfMacAddr, sizeof(tSirMacAddr));
pMsg->chnNum = p2pRemainonChn->u.remainChlCmd.chn;
pMsg->phyMode = p2pRemainonChn->u.remainChlCmd.phyMode;
pMsg->duration = p2pRemainonChn->u.remainChlCmd.duration;
pMsg->sessionId = p2pRemainonChn->sessionId;
pMsg->isProbeRequestAllowed = p2pRemainonChn->u.remainChlCmd.isP2PProbeReqAllowed;
if( pMac->p2pContext.probeRspIeLength )
vos_mem_copy((void *)pMsg->probeRspIe, (void *)pMac->p2pContext.probeRspIe,
pMac->p2pContext.probeRspIeLength);
status = palSendMBMessage(pMac->hHdd, pMsg);
}
error:
if (eHAL_STATUS_FAILURE == status)
csr_release_roc_req_cmd(pMac);
return status;
}
VOS_STATUS vos_timer_init_debug( vos_timer_t *timer, VOS_TIMER_TYPE timerType,
vos_timer_callback_t callback, v_PVOID_t userData,
char* fileName, v_U32_t lineNum )
{
VOS_STATUS vosStatus;
unsigned long flags;
// Check for invalid pointer
if ((timer == NULL) || (callback == NULL))
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Null params being passed",__func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
timer->ptimerNode = vos_mem_malloc(sizeof(timer_node_t));
if(timer->ptimerNode == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Not able to allocate memory for timeNode",__func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
vos_mem_set(timer->ptimerNode, sizeof(timer_node_t), 0);
timer->ptimerNode->fileName = fileName;
timer->ptimerNode->lineNum = lineNum;
timer->ptimerNode->vosTimer = timer;
spin_lock_irqsave(&vosTimerList.lock, flags);
vosStatus = hdd_list_insert_front(&vosTimerList, &timer->ptimerNode->pNode);
spin_unlock_irqrestore(&vosTimerList.lock, flags);
if(VOS_STATUS_SUCCESS != vosStatus)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Unable to insert node into List vosStatus %d", __func__, vosStatus);
}
// set the various members of the timer structure
// with arguments passed or with default values
spin_lock_init(&timer->platformInfo.spinlock);
init_timer(&(timer->platformInfo.Timer));
timer->platformInfo.Timer.function = vos_linux_timer_callback;
timer->platformInfo.Timer.data = (unsigned long)timer;
timer->callback = callback;
timer->userData = userData;
timer->type = timerType;
timer->platformInfo.cookie = LINUX_TIMER_COOKIE;
timer->platformInfo.threadID = 0;
timer->state = VOS_TIMER_STATE_STOPPED;
return VOS_STATUS_SUCCESS;
}
eHalStatus palAllocateMemory( tHddHandle hHdd, void **ppMemory, tANI_U32 numBytes )
{
eHalStatus halStatus = eHAL_STATUS_SUCCESS;
*ppMemory = vos_mem_malloc( numBytes );
if ( NULL == *ppMemory )
{
halStatus = eHAL_STATUS_FAILURE;
}
return( halStatus );
}
static void
ibss_coalesce_save(
tpAniSirGlobal pMac,
tpSirMacMgmtHdr pHdr,
tpSchBeaconStruct pBeacon)
{
ibss_coalesce_free(pMac);
pMac->lim.ibssInfo.pHdr = vos_mem_malloc(sizeof(*pHdr));
if (NULL == pMac->lim.ibssInfo.pHdr)
{
PELOGE(limLog(pMac, LOGE, FL("ibbs-save: Failed malloc pHdr"));)
return;
int
aagPrf(v_U32_t cryptHandle,
v_U8_t result[AAG_PRF_MAX_OUTPUT_SIZE],
v_U8_t *key, v_U8_t keyLen,
v_U8_t *a, v_U8_t aLen,
v_U8_t *b, v_U8_t bLen,
v_U32_t prfLen)
{
static v_U8_t y;
v_U8_t *hmacText = NULL;
v_U8_t *resultOffset = result;
int numLoops;
int loopCtrPos;
int i, retVal=0;
hmacText = vos_mem_malloc( aLen + bLen + 2 );
if( NULL == hmacText )
{
return ANI_E_NULL_VALUE;
}
vos_mem_copy(hmacText + 0, a, aLen);
hmacText[aLen] = y;
vos_mem_copy(hmacText + aLen + 1, b, bLen);
loopCtrPos = aLen + 1 + bLen;
numLoops = prfLen + AAG_PTK_PRF_ADD_PARAM;
numLoops /= AAG_PTK_PRF_DIV_PARAM;
for (i = 0; i < numLoops; i++)
{
VOS_ASSERT((resultOffset - result + VOS_DIGEST_SHA1_SIZE)
<= AAG_PRF_MAX_OUTPUT_SIZE);
hmacText[loopCtrPos] = i;
if( VOS_IS_STATUS_SUCCESS( vos_sha1_hmac_str(cryptHandle, hmacText, loopCtrPos + 1, key, keyLen, resultOffset) ) )
{
resultOffset += VOS_DIGEST_SHA1_SIZE;
retVal = ANI_OK;
}
else
{
retVal = ANI_ERROR;
}
}
vos_mem_free(hmacText);
return retVal;
}
tSirRetStatus macOpen(tHalHandle *pHalHandle, tHddHandle hHdd, tMacOpenParameters *pMacOpenParms)
{
tpAniSirGlobal pMac = NULL;
if(pHalHandle == NULL)
return eSIR_FAILURE;
/*
* Make sure this adapter is not already opened. (Compare pAdapter pointer in already
* allocated pMac structures.)
* If it is opened just return pointer to previously allocated pMac pointer.
* Or should this result in error?
*/
/* Allocate pMac */
pMac = vos_mem_malloc(sizeof(tAniSirGlobal));
if ( NULL == pMac )
return eSIR_FAILURE;
/* Initialize the pMac structure */
vos_mem_set(pMac, sizeof(tAniSirGlobal), 0);
/** Store the Driver type in pMac Global.*/
//pMac->gDriverType = pMacOpenParms->driverType;
/*
* Set various global fields of pMac here
* (Could be platform dependant as some variables in pMac are platform
* dependant)
*/
pMac->hHdd = hHdd;
pMac->pAdapter = hHdd; //This line wil be removed
*pHalHandle = (tHalHandle)pMac;
{
/* Call various PE (and other layer init here) */
if( eSIR_SUCCESS != logInit(pMac))
return eSIR_FAILURE;
/* Call routine to initialize CFG data structures */
if( eSIR_SUCCESS != cfgInit(pMac) )
return eSIR_FAILURE;
sysInitGlobals(pMac);
}
return peOpen(pMac, pMacOpenParms);
}
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
pMac->pResetMsg = vos_mem_malloc(sizeof(tSirMbMsg));
if ( NULL == pMac->pResetMsg )
{
sysLog(pMac, LOGE, FL("pMac->pResetMsg is NULL\n"));
status = eSIR_FAILURE;
break;
}
else
{
vos_mem_set(pMac->pResetMsg, sizeof(tSirMbMsg), 0);
}
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 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;
tdlsLinkEstablishReq->transactionId = 0;
palCopyMemory(pMac->hHdd, tdlsLinkEstablishReq->peerMac,
tdlsLinkEstablishCmdInfo->peerMac, sizeof(tSirMacAddr));
palCopyMemory(pMac->hHdd, tdlsLinkEstablishReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
tdlsLinkEstablishReq->isBufSta = tdlsLinkEstablishCmdInfo->isBufSta;
tdlsLinkEstablishReq->isResponder= tdlsLinkEstablishCmdInfo->isResponder;
tdlsLinkEstablishReq->uapsdQueues= tdlsLinkEstablishCmdInfo->uapsdQueues;
tdlsLinkEstablishReq->maxSp= tdlsLinkEstablishCmdInfo->maxSp;
smsLog( pMac, LOGE, "sending TDLS Link Establish Request to PE \n" );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_LINK_ESTABLISH_REQ,
(void *)tdlsLinkEstablishReq,
sizeof(tSirTdlsLinkEstablishReq));
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC\n"));
}
return status;
}
// tdlsoffchan
eHalStatus csrTdlsProcessChanSwitchReq( tpAniSirGlobal pMac, tSmeCmd *cmd )
{
tTdlsChanSwitchCmdInfo *tdlsChanSwitchCmdInfo = &cmd->u.tdlsCmd.u.tdlsChanSwitchCmdInfo ;
tSirTdlsChanSwitch *tdlsChanSwitch = NULL ;
eHalStatus status = eHAL_STATUS_FAILURE;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
if (NULL == pSession)
{
smsLog( pMac, LOGE, FL("pSession is NULL"));
return eHAL_STATUS_FAILURE;
}
tdlsChanSwitch = vos_mem_malloc(sizeof(tSirTdlsChanSwitch));
if (tdlsChanSwitch == NULL)
{
smsLog( pMac, LOGE, FL("alloc failed \n") );
VOS_ASSERT(0) ;
return status ;
}
tdlsChanSwitch->sessionId = cmd->sessionId;
//Using dialog as transactionId. This can be used to match response with request
tdlsChanSwitch->transactionId = 0;
vos_mem_copy( tdlsChanSwitch->peerMac,
tdlsChanSwitchCmdInfo->peerMac, sizeof(tSirMacAddr));
vos_mem_copy(tdlsChanSwitch->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
tdlsChanSwitch->tdlsOffCh = tdlsChanSwitchCmdInfo->tdlsOffCh;
tdlsChanSwitch->tdlsOffChBwOffset = tdlsChanSwitchCmdInfo->tdlsOffChBwOffset;
tdlsChanSwitch->tdlsSwMode = tdlsChanSwitchCmdInfo->tdlsSwMode;
// Send the request to PE.
smsLog( pMac, LOGE, "sending TDLS Channel Switch to PE \n" );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_CHANNEL_SWITCH_REQ,
(void *)tdlsChanSwitch,
sizeof(tSirTdlsChanSwitch));
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC\n"));
}
return status;
}
static tCfgReq * allocateCfgReq(tHddHandle hHdd, tANI_U32 type, tANI_S32 length)
{
tCfgReq *req ;
tANI_S32 alloc_len = sizeof(tCfgReq) ;
if (type == CCM_STRING_TYPE)
{
alloc_len += length ;
}
req = vos_mem_malloc(alloc_len);
if ( NULL == req )
{
return NULL ;
}
req->ccmPtr = (req+1);
return req ;
}
void
limProcessProbeRspFrame(tpAniSirGlobal pMac, tANI_U8 *pRxPacketInfo,tpPESession psessionEntry)
{
tANI_U8 *pBody;
tANI_U32 frameLen = 0;
tSirMacAddr currentBssId;
tpSirMacMgmtHdr pHdr;
tSirProbeRespBeacon *pProbeRsp;
tANI_U8 qosEnabled = false;
tANI_U8 wmeEnabled = false;
if (!psessionEntry)
{
limLog(pMac, LOGE, FL("psessionEntry is NULL") );
return;
}
limLog(pMac,LOG1,"SessionId:%d ProbeRsp Frame is received",
psessionEntry->peSessionId);
pProbeRsp = vos_mem_malloc(sizeof(tSirProbeRespBeacon));
if ( NULL == pProbeRsp )
{
limLog(pMac, LOGE, FL("Unable to allocate memory in limProcessProbeRspFrame") );
return;
}
pProbeRsp->ssId.length = 0;
pProbeRsp->wpa.length = 0;
pProbeRsp->propIEinfo.apName.length = 0;
pHdr = WDA_GET_RX_MAC_HEADER(pRxPacketInfo);
PELOG2(limLog(pMac, LOG2,
FL("Received Probe Response frame with length=%d from "),
WDA_GET_RX_MPDU_LEN(pRxPacketInfo));
limPrintMacAddr(pMac, pHdr->sa, LOG2);)
if (!pMac->fScanOffload)
/*==========================================================================
FUNCTION sapChanSelInit
DESCRIPTION
Function sapChanSelInit allocates the memory, intializes the
structures used by the channel selection algorithm
DEPENDENCIES
NA.
PARAMETERS
IN
*pSpectInfoParams : Pointer to tSapChSelSpectInfo structure
RETURN VALUE
v_BOOL_t: Success or FAIL
SIDE EFFECTS
============================================================================*/
v_BOOL_t sapChanSelInit(tHalHandle halHandle, tSapChSelSpectInfo *pSpectInfoParams)
{
tSapSpectChInfo *pSpectCh = NULL;
v_U8_t *pChans = NULL;
v_U16_t channelnum = 0;
tpAniSirGlobal pMac = PMAC_STRUCT(halHandle);
VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_INFO_HIGH, "In %s", __FUNCTION__);
// Channels for that 2.4GHz band
//Considered only for 2.4GHz need to change in future to support 5GHz support
pSpectInfoParams->numSpectChans = pMac->scan.base20MHzChannels.numChannels;
// Allocate memory for weight computation of 2.4GHz
pSpectCh = (tSapSpectChInfo *)vos_mem_malloc((pSpectInfoParams->numSpectChans) * sizeof(*pSpectCh));
if(pSpectCh == NULL) {
VOS_TRACE(VOS_MODULE_ID_SAP, VOS_TRACE_LEVEL_ERROR, "In %s, VOS_MALLOC_ERR", __FUNCTION__);
return eSAP_FALSE;
}
vos_mem_zero(pSpectCh, (pSpectInfoParams->numSpectChans) * sizeof(*pSpectCh));
// Initialize the pointers in the DfsParams to the allocated memory
pSpectInfoParams->pSpectCh = pSpectCh;
pChans = pMac->scan.base20MHzChannels.channelList;
// Fill the channel number in the spectrum in the operating freq band
for (channelnum = 0; channelnum < pSpectInfoParams->numSpectChans; channelnum++) {
if(*pChans == 14 ) //OFDM rates are not supported on channel 14
continue;
pSpectCh->chNum = *pChans;
pSpectCh->valid = eSAP_TRUE;
pSpectCh->rssiAgr = SOFTAP_MIN_RSSI;// Initialise for all channels
pSpectCh++;
pChans++;
}
return eSAP_TRUE;
}
eHalStatus p2pSetPs(tHalHandle hHal, tP2pPsConfig *pNoA)
{
tpP2pPsConfig pNoAParam;
tSirMsgQ msg;
eHalStatus status = eHAL_STATUS_SUCCESS;
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
pNoAParam = vos_mem_malloc(sizeof(tP2pPsConfig));
if ( NULL == pNoAParam )
status = eHAL_STATUS_FAILURE;
else
{
vos_mem_set(pNoAParam, sizeof(tP2pPsConfig), 0);
vos_mem_copy(pNoAParam, pNoA, sizeof(tP2pPsConfig));
msg.type = eWNI_SME_UPDATE_NOA;
msg.bodyval = 0;
msg.bodyptr = pNoAParam;
limPostMsgApi(pMac, &msg);
}
return status;
}
/*
* CCM_STRING_TYPE CCM_INTEGER_TYPE
* |<-------- 4 ----->| |<-------- 4 ----->|
* +----------+ <-- msg --> +----------+
* |type | |type |
* +----------+ +----------+
* |msgLen=24 | |msgLen=16 |
* +----------+----------+ +----------+----------+
* | cfgId | | cfgId |
* +---------------------+ +---------------------+
* | length=11 | | length=4 |
* +---------------------+ +---------------------+
* | | | value |
* | | +---------------------+
* | |
* | +----+
* | |////| <- padding to 4-byte boundary
* +----------------+----+
*/
static eHalStatus sendCfg(tpAniSirGlobal pMac, tHddHandle hHdd, tCfgReq *req, tANI_BOOLEAN fRsp)
{
tSirMbMsg *msg;
eHalStatus status;
tANI_S16 msgLen = (tANI_U16)(4 + /* 4 bytes for msg header */
CFGOBJ_ID_SIZE +
CFGOBJ_LEN_SIZE +
CFGOBJ_ALIGN(req->length)) ;
msg = vos_mem_malloc(msgLen);
if ( NULL != msg )
{
if( fRsp )
{
msg->type = pal_cpu_to_be16(WNI_CFG_SET_REQ);
}
else
{
msg->type = pal_cpu_to_be16(WNI_CFG_SET_REQ_NO_RSP);
}
msg->msgLen = pal_cpu_to_be16(msgLen);
(void)encodeCfgReq(hHdd, msg->data, req->cfgId, req->length, req->ccmPtr, req->ccmValue, req->type) ;
status = palSendMBMessage(hHdd, msg) ;
if (status != eHAL_STATUS_SUCCESS)
{
smsLog( pMac, LOGW, FL("palSendMBMessage() failed"));
//No need to free msg. palSendMBMessage frees it.
status = eHAL_STATUS_FAILURE ;
}
}
else
{
smsLog( pMac, LOGW, FL("failed to allocate memory(len=%d)"), msgLen );
status = eHAL_STATUS_FAILURE;
}
return status ;
}
static ssize_t ath_procfs_diag_read(struct file *file, char __user *buf,
size_t count, loff_t *pos)
{
hif_handle_t hif_hdl;
int rv;
A_UINT8 *read_buffer = NULL;
read_buffer = (A_UINT8 *)vos_mem_malloc(count);
if (NULL == read_buffer) {
pr_debug("%s: vos_mem_alloc failed\n", __func__);
return -EINVAL;
}
hif_hdl = get_hif_hdl_from_file(file);
pr_debug("rd buff 0x%p cnt %zu offset 0x%x buf 0x%p\n",
read_buffer,count,
(int)*pos, buf);
if ((count == 4) && ((((A_UINT32)(*pos)) & 3) == 0)) {
/* reading a word? */
rv = HIFDiagReadAccess(hif_hdl, (A_UINT32)(*pos),
(A_UINT32 *)read_buffer);
} else {
rv = HIFDiagReadMem(hif_hdl, (A_UINT32)(*pos),
(A_UINT8 *)read_buffer, count);
}
if(copy_to_user(buf, read_buffer, count)) {
vos_mem_free(read_buffer);
return -EFAULT;
} else
vos_mem_free(read_buffer);
if (rv == 0) {
return count;
} else {
return -EIO;
}
}
static ssize_t ath_procfs_diag_write(struct file *file, const char __user *buf,
size_t count, loff_t *pos)
{
hif_handle_t hif_hdl;
int rv;
A_UINT8 *write_buffer = NULL;
write_buffer = (A_UINT8 *)vos_mem_malloc(count);
if (NULL == write_buffer) {
pr_debug("%s: vos_mem_alloc failed\n", __func__);
return -EINVAL;
}
if(copy_from_user(write_buffer, buf, count)) {
vos_mem_free(write_buffer);
return -EFAULT;
}
hif_hdl = get_hif_hdl_from_file(file);
pr_debug("wr buff 0x%p buf 0x%p cnt %zu offset 0x%x value 0x%x\n",
write_buffer, buf, count,
(int)*pos, *((A_UINT32 *)write_buffer));
if ((count == 4) && ((((A_UINT32)(*pos)) & 3) == 0)) {
/* reading a word? */
A_UINT32 value = *((A_UINT32 *)write_buffer);
rv = HIFDiagWriteAccess(hif_hdl,
(A_UINT32)(*pos), value);
} else {
rv = HIFDiagWriteMem(hif_hdl, (A_UINT32)(*pos),
(A_UINT8 *)write_buffer, count);
}
vos_mem_free(write_buffer);
if (rv == 0) {
return count;
} else {
return -EIO;
}
}
tSirRetStatus macOpen(tHalHandle *pHalHandle, tHddHandle hHdd, tMacOpenParameters *pMacOpenParms)
{
tpAniSirGlobal pMac = NULL;
if(pHalHandle == NULL)
return eSIR_FAILURE;
pMac = vos_mem_malloc(sizeof(tAniSirGlobal));
if ( NULL == pMac )
return eSIR_FAILURE;
vos_mem_set(pMac, sizeof(tAniSirGlobal), 0);
pMac->hHdd = hHdd;
pMac->pAdapter = hHdd;
*pHalHandle = (tHalHandle)pMac;
{
if( eSIR_SUCCESS != logInit(pMac))
return eSIR_FAILURE;
if( eSIR_SUCCESS != cfgInit(pMac) )
return eSIR_FAILURE;
sysInitGlobals(pMac);
}
return peOpen(pMac, pMacOpenParms);
}
tSirRetStatus macPreStart(tHalHandle hHal)
{
tSirRetStatus status = eSIR_SUCCESS;
tANI_BOOLEAN memAllocFailed = eANI_BOOLEAN_FALSE;
tpAniSirGlobal pMac = (tpAniSirGlobal) hHal;
tANI_U8 i;
for(i=0; i<MAX_DUMP_TABLE_ENTRY; i++)
{
pMac->dumpTableEntry[i] = vos_mem_malloc(sizeof(tDumpModuleEntry));
if ( NULL == pMac->dumpTableEntry[i] )
{
memAllocFailed = eANI_BOOLEAN_TRUE;
break;
}
else
{
vos_mem_set(pMac->dumpTableEntry[i], sizeof(tSirMbMsg), 0);
}
}
if( memAllocFailed )
{
while(i>0)
{
i--;
vos_mem_free(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;
}
eHalStatus palTimerAlloc_debug( tHddHandle hHdd, tPalTimerHandle *phPalTimer,
palTimerCallback pCallback, void *pContext, char* fileName, v_U32_t lineNum )
{
eHalStatus halStatus = eHAL_STATUS_FAILURE;
tPalTimer *pPalTimer = NULL;
VOS_STATUS vosStatus;
do
{
// allocate the internal timer structure.
pPalTimer = vos_mem_malloc( sizeof( tPalTimer ) );
if ( NULL == pPalTimer ) break;
// initialize the vos Timer that underlies the pal Timer.
vosStatus = vos_timer_init_debug( &pPalTimer->vosTimer, VOS_TIMER_TYPE_SW,
internalTimerCallback, pPalTimer, fileName, lineNum );
if ( !VOS_IS_STATUS_SUCCESS( vosStatus ) )
{
// if fail to init the vos timer, free the memory and bail out.
vos_mem_free( pPalTimer );
break;
}
// initialize the info in the internal palTimer struct so we can
pPalTimer->timerCallback = pCallback;
pPalTimer->pContext = pContext;
pPalTimer->hHdd = hHdd;
// return a 'handle' to the caller.
*phPalTimer = pPalTimer;
halStatus = eHAL_STATUS_SUCCESS;
} while( 0 );
return( halStatus );
}
eHalStatus p2pCancelRemainOnChannel(tHalHandle hHal, tANI_U8 sessionId)
{
eHalStatus status = eHAL_STATUS_SUCCESS;
tpAniSirGlobal pMac = PMAC_STRUCT(hHal);
tSirMbMsgP2p *pMsg;
tANI_U16 msgLen;
//Need to check session ID to support concurrency
msgLen = (tANI_U16)(sizeof( tSirMbMsg ));
pMsg = vos_mem_malloc(msgLen);
if ( NULL == pMsg )
status = eHAL_STATUS_FAILURE;
else
{
vos_mem_set((void *)pMsg, msgLen, 0);
pMsg->type = pal_cpu_to_be16((tANI_U16)eWNI_SME_ABORT_REMAIN_ON_CHAN_IND);
pMsg->msgLen = pal_cpu_to_be16(msgLen);
pMsg->sessionId = sessionId;
status = palSendMBMessage(pMac->hHdd, pMsg);
}
return( status );
}
/******************************************************************************
* Function: sme_NanRequest
*
* Description:
* This function gets called when HDD receives NAN vendor command
* from user space
*
* Args:
* Nan Request structure ptr
*
* Returns:
* VOS_STATUS
*****************************************************************************/
VOS_STATUS sme_NanRequest(tpNanRequestReq input)
{
vos_msg_t msg;
tpNanRequest data;
size_t data_len;
data_len = sizeof(tNanRequest) + input->request_data_len;
data = vos_mem_malloc(data_len);
if (data == NULL) {
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
FL("Memory allocation failure"));
return VOS_STATUS_E_FAULT;
}
vos_mem_zero(data, data_len);
data->request_data_len = input->request_data_len;
if (input->request_data_len) {
vos_mem_copy(data->request_data,
input->request_data, input->request_data_len);
}
msg.type = WDA_NAN_REQUEST;
msg.reserved = 0;
msg.bodyptr = data;
if (VOS_STATUS_SUCCESS != vos_mq_post_message(VOS_MODULE_ID_WDA,
&msg)) {
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_ERROR,
FL("Not able to post WDA_NAN_REQUEST message to WDA"));
vos_mem_free(data);
return VOS_STATUS_SUCCESS;
}
return VOS_STATUS_SUCCESS;
}
/**
* 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;
pBcnParams = vos_mem_malloc(sizeof(*pBcnParams));
if ( NULL == pBcnParams )
{
limLog( pMac, LOGP,
FL( "Unable to allocate memory during Update Beacon Params" ));
return eSIR_MEM_ALLOC_FAILED;
}
vos_mem_copy((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);)
if(NULL == psessionEntry)
/**
* limSendCFParams()
*
*FUNCTION:
* This function is called to send CFP Parameters to WDA, when they are changed.
*
*LOGIC:
*
*ASSUMPTIONS:
* NA
*
*NOTE:
* NA
*
* @param pMac pointer to Global Mac structure.
* @param bssIdx Bss Index of the BSS to which STA is associated.
* @param cfpCount CFP Count, if that is changed.
* @param cfpPeriod CFP Period if that is changed.
*
* @return success if message send is ok, else false.
*/
tSirRetStatus limSendCFParams(tpAniSirGlobal pMac, tANI_U8 bssIdx, tANI_U8 cfpCount, tANI_U8 cfpPeriod)
{
tpUpdateCFParams pCFParams = NULL;
tSirRetStatus retCode = eSIR_SUCCESS;
tSirMsgQ msgQ;
pCFParams = vos_mem_malloc(sizeof( tUpdateCFParams ));
if ( NULL == pCFParams )
{
limLog( pMac, LOGP,
FL( "Unable to allocate memory during Update CF Params" ));
retCode = eSIR_MEM_ALLOC_FAILED;
goto returnFailure;
}
vos_mem_set( (tANI_U8 *) pCFParams, sizeof(tUpdateCFParams), 0);
pCFParams->cfpCount = cfpCount;
pCFParams->cfpPeriod = cfpPeriod;
pCFParams->bssIdx = bssIdx;
msgQ.type = WDA_UPDATE_CF_IND;
msgQ.reserved = 0;
msgQ.bodyptr = pCFParams;
msgQ.bodyval = 0;
limLog( pMac, LOG3,
FL( "Sending WDA_UPDATE_CF_IND..." ));
MTRACE(macTraceMsgTx(pMac, NO_SESSION, msgQ.type));
if( eSIR_SUCCESS != (retCode = wdaPostCtrlMsg( pMac, &msgQ )))
{
vos_mem_free(pCFParams);
limLog( pMac, LOGP,
FL("Posting WDA_UPDATE_CF_IND to WDA failed, reason=%X"),
retCode );
}
returnFailure:
return retCode;
}
