/****************************************************************************
* cmdBld_CmdIeEnableRx()
****************************************************************************
* DESCRIPTION: Construct the EnableRx command fileds and send it to the mailbox
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeEnableRx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TI_UINT8 uChannelNumber;
uChannelNumber = DB_DEFAULT_CHANNEL (hCmdBld);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_ENABLE_RX,
(TI_CHAR *)&uChannelNumber,
sizeof(TI_UINT8),
fCb,
hCb,
NULL);
}
/****************************************************************************
* cmdBld_ItrIeRoamimgStatisitics ()
****************************************************************************
* DESCRIPTION: Get the ACX GWSI statistics
*
* INPUTS:
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ItrIeRoamimgStatisitics (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb, void *pCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ACXRoamingStatisticsTable_t acx;
ACXRoamingStatisticsTable_t * pCfg = &acx;
/*
* Set information element header
*/
pCfg->EleHdr.id = ACX_ROAMING_STATISTICS_TBL;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_INTERROGATE, pCfg, sizeof(*pCfg), fCb, hCb, pCb);
}
/**
* \fn cmdBld_CmdIeStopPeriodicScan
* \brief Stops an on-going periodic scan operation
*
* Stops an on-going periodic scan operation
*
* \param hCmdBld - handle to command builder object
* \param fScanResponseCB - command complete function callback
* \param hCb - command complete callback handle
* \return TI_OK on success, any other code on error
* \sa cmdBld_CmdIeScanSsidList, cmdBld_CmdIePeriodicScanParams, cmdBld_CmdIeStartPeriodicScan
*/
TI_STATUS cmdBld_CmdIeStopPeriodicScan (TI_HANDLE hCmdBld,
PeriodicScanTag* pPeriodicScanStop,
void* fScanResponseCB,
TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_STOP_PERIODIC_SCAN,
pPeriodicScanStop,
sizeof(pPeriodicScanStop),
fScanResponseCB,
hCb,
NULL);
}
/****************************************************************************
* cmdBld_ItrIeErrorCnt ()
****************************************************************************
* DESCRIPTION: Get the ACX GWSI counters
*
* INPUTS:
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ItrIeErrorCnt (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb, void *pCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ACXErrorCounters_t acx;
ACXErrorCounters_t * pCfg = &acx;
/*
* Set information element header
*/
pCfg->EleHdr.id = ACX_ERROR_CNT;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_INTERROGATE, pCfg, sizeof(*pCfg), fCb, hCb, pCb);
}
/****************************************************************************
* cmdBld_CmdIeSetStaState()
****************************************************************************
* DESCRIPTION: Construct the Disconnect command fileds and send it to the mailbox
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeSetStaState (TI_HANDLE hCmdBld, TI_UINT8 staState, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
SetStaState_t AcxCmd_SetStaState;
AcxCmd_SetStaState.staState = staState;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_SET_STA_STATE,
(void *)&AcxCmd_SetStaState,
sizeof(AcxCmd_SetStaState),
fCb,
hCb,
NULL);
}
/****************************************************************************
* cmdBld_ItrIePowerConsumptionstat()
****************************************************************************
* DESCRIPTION: Get the Power consumption statistic from the Fw
*
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ItrIePowerConsumptionstat(TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb, void* pCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ACXPowerConsumptionTimeStat_t AcxPowerConsumptionStat;
ACXPowerConsumptionTimeStat_t* pCfg = &AcxPowerConsumptionStat;
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_ItrIePowerConsumptionstat \n");
/* Set information element header */
pCfg->EleHdr.id = ACX_PWR_CONSUMPTION_STATISTICS;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_INTERROGATE, pCfg, sizeof(AcxPowerConsumptionStat), fCb, hCb, pCb);
}
/****************************************************************************
* cmdBld_CmdIeSwitchChannel ()
****************************************************************************
* DESCRIPTION: Send CMD_SWITCH_CHANNEL Command
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeSwitchChannel (TI_HANDLE hCmdBld, TSwitchChannelParams *pSwitchChannelCmd, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ChannelSwitchParameters_t AcxCmd_SwitchChannel;
ChannelSwitchParameters_t *pCmd = &AcxCmd_SwitchChannel;
os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
pCmd->channel = pSwitchChannelCmd->channelNumber;
pCmd->switchTime = pSwitchChannelCmd->switchTime;
pCmd->txSuspend = pSwitchChannelCmd->txFlag;
pCmd->flush = pSwitchChannelCmd->flush;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CHANNEL_SWITCH, (TI_CHAR *)pCmd, sizeof(*pCmd), fCb, hCb, NULL);
}
/****************************************************************************
* cmdBld_CmdIeNoiseHistogram ()
****************************************************************************
* DESCRIPTION: Send NOISE_HISTOGRAM Command
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeNoiseHistogram (TI_HANDLE hCmdBld, TNoiseHistogram *pNoiseHistParams, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
NoiseHistRequest_t AcxCmd_NoiseHistogram;
NoiseHistRequest_t *pCmd = &AcxCmd_NoiseHistogram;
os_memoryZero(pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
pCmd->mode = ENDIAN_HANDLE_WORD((TI_UINT16)pNoiseHistParams->cmd);
pCmd->sampleIntervalUSec = ENDIAN_HANDLE_WORD(pNoiseHistParams->sampleInterval);
os_memoryCopy (pCmdBld->hOs, (void *)&(pCmd->thresholds[0]), (void *)&(pNoiseHistParams->ranges[0]), MEASUREMENT_NOISE_HISTOGRAM_NUM_OF_RANGES);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_NOISE_HIST, (TI_CHAR *)pCmd, sizeof(*pCmd), fCb, hCb, NULL);
}
/* \fn cmdBld_CmdIeRemSta
*
* \brief Build and send CMD_REMOVE_STA to the FW via Cmd Mailbox
*/
TI_STATUS cmdBld_CmdIeRemSta (TI_HANDLE hCmdBld, TI_UINT8 uHlid, TI_UINT8 uReasonOpcode,
TI_BOOL bSendDeauth, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
RemoveStation_t cmdRemSta;
RemoveStation_t *pCmd = &cmdRemSta;
os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
pCmd->HLID = uHlid;
pCmd->reasonOpcode = uReasonOpcode;
pCmd->sendDeauthFlag = bSendDeauth;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_REMOVE_STA, (void *)pCmd,
sizeof(*pCmd), fCb, hCb, NULL);
}
void FW_debugSendGeneralTestCmd(TI_HANDLE hTWD, void *pParam)
{
TTwd *pTWD = (TTwd *)hTWD;
FWDebugTestCmdParamter_t Cfg;
unsigned char Len;
Len = *(unsigned char *)pParam;
os_memoryCopy(pTWD->hOs, Cfg.buf,(unsigned long*)pParam + sizeof(TI_UINT8),Len * 4 );
Cfg.len = Len;
/* Set information element header */
Cfg.EleHdr.id = CMD_TEST;
Cfg.EleHdr.len = sizeof(Cfg) - sizeof(EleHdrStruct);
cmdQueue_SendCommand (pTWD->hCmdQueue, CMD_CONFIGURE, (void*)&Cfg, sizeof(Cfg), NULL, NULL, NULL);
}
/****************************************************************************
* cmdBld_ItrIeDataFilterStatistics()
****************************************************************************
* DESCRIPTION: Get the ACX GWSI counters
*
* INPUTS:
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ItrIeDataFilterStatistics (TI_HANDLE hCmdBld,
void *fCb,
TI_HANDLE hCb,
void *pCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ACXDataFilteringStatistics_t acx;
ACXDataFilteringStatistics_t * pCfg = &acx;
/* Set information element header */
pCfg->EleHdr.id = ACX_GET_DATA_FILTER_STATISTICS;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
/* Send the interrogation command */
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_INTERROGATE, pCfg, sizeof(*pCfg), fCb, hCb, pCb);
}
/****************************************************************************
* cmdBld_CmdIeConfigureTemplateFrame()
****************************************************************************
* DESCRIPTION: Generic function which sets the Fw with a template frame according
* to the given template type.
*
* INPUTS: templateType - CMD_BEACON, CMD_PROBE_REQ, CMD_PROBE_RESP etc.
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeConfigureTemplateFrame (TI_HANDLE hCmdBld,
TTemplateParams *pTemplate,
TI_UINT16 uFrameSize,
TemplateType_e eTemplateType,
TI_UINT8 uIndex,
void * fCb,
TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
PktTemplate_t AcxCmd_PktTemplate;
PktTemplate_t *pCmd = &AcxCmd_PktTemplate;
/* If the frame size is too big - we truncate the frame template */
if (uFrameSize > MAX_TEMPLATES_SIZE) {
/* Report as error only if this is the actual template and not just a space holder */
/* Truncate length to the template size limit */
uFrameSize = MAX_TEMPLATES_SIZE;
}
/* if pTemplate is NULL than it means that we just want to reserve place in Fw, and there is no need to copy */
if (pTemplate != NULL) {
os_memoryCopy(pCmdBld->hOs, (void *)&pCmd->templateStart, (void *)(pTemplate->Buffer), uFrameSize);
pCmd->templateTxAttribute.enabledRates = pTemplate->uRateMask;
}
pCmd->len = ENDIAN_HANDLE_WORD(uFrameSize);
pCmd->index = uIndex;
pCmd->templateType = eTemplateType;
pCmd->templateTxAttribute.shortRetryLimit = 2;
pCmd->templateTxAttribute.longRetryLimit = 2;
#ifdef TI_DBG
if (pCmdBld->uDbgTemplatesRateMask != 0) {
pCmd->templateTxAttribute.enabledRates = pCmdBld->uDbgTemplatesRateMask;
}
#endif
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_SET_TEMPLATE,
(TI_CHAR *)pCmd,
sizeof (PktTemplate_t),
fCb,
hCb,
NULL);
}
static void TWD_PrintMemRegs(TI_HANDLE hTWD, TI_UINT32 address, TI_UINT32 len,
readWrite_MemoryType_e memType)
{
TTwd *pTWD = (TTwd *) hTWD;
ReadWriteCommand_t AcxCmd_ReadMemory;
ReadWriteCommand_t *pCmd = &AcxCmd_ReadMemory;
os_memoryZero(pTWD->hOs, (void *)pCmd, sizeof(*pCmd));
switch (memType) {
case TNETW_INTERNAL_RAM:
pCmd->addr = (TI_UINT32) ENDIAN_HANDLE_LONG(address);
pCmd->size = ENDIAN_HANDLE_LONG(len);
break;
case TNETW_MAC_REGISTERS:
pCmd->addr =
(TI_UINT32)
ENDIAN_HANDLE_LONG(((address & 0xFFFF) | REGISTERS_BASE));
pCmd->size = 4;
break;
case TNETW_PHY_REGISTERS:
pCmd->addr =
(TI_UINT32)
ENDIAN_HANDLE_LONG(((address & 0xFFFF) |
BB_REGISTER_ADDR_BASE));
pCmd->size = 4;
break;
default:
WLAN_OS_REPORT(("Wrong memory type %d\n\n", memType));
return;
}
os_memoryZero(pTWD->hOs, (void *)&pTWD->tPrintRegsBuf,
sizeof(pTWD->tPrintRegsBuf));
cmdQueue_SendCommand(pTWD->hCmdQueue,
CMD_READ_MEMORY,
(char *)pCmd,
sizeof(*pCmd),
(void *)TWD_PrintMemRegsCB,
hTWD, &pTWD->tPrintRegsBuf);
}
/****************************************************************************
* cmdBld_CmdIeFwDisconnect()
****************************************************************************
* DESCRIPTION: Construct the Disconnect command fileds and send it to the mailbox
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeFwDisconnect (TI_HANDLE hCmdBld, TI_UINT32 uConfigOptions, TI_UINT32 uFilterOptions, DisconnectType_e uDisconType, TI_UINT16 uDisconReason, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
DisconnectParameters_t AcxCmd_Disconnect;
AcxCmd_Disconnect.rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG(uConfigOptions);
AcxCmd_Disconnect.rxFilter.FilterOptions = ENDIAN_HANDLE_LONG(uFilterOptions);
AcxCmd_Disconnect.disconnectReason = ENDIAN_HANDLE_LONG(uDisconReason);
AcxCmd_Disconnect.disconnectType = uDisconType;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_DISCONNECT,
(void *)&AcxCmd_Disconnect,
sizeof(AcxCmd_Disconnect),
fCb,
hCb,
NULL);
}
/****************************************************************************
* cmdBld_CmdIeEnableRx()
****************************************************************************
* DESCRIPTION: Construct the EnableRx command fileds and send it to the mailbox
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeEnableRx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TI_UINT8 aEnableRx_buf[4];
aEnableRx_buf[0] = DB_DEFAULT_CHANNEL (hCmdBld);
aEnableRx_buf[1] = 0; /* padding */
aEnableRx_buf[2] = 0; /* padding */
aEnableRx_buf[3] = 0; /* padding */
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_ENABLE_RX,
(TI_CHAR *)aEnableRx_buf,
sizeof(aEnableRx_buf),
fCb,
hCb,
NULL);
}
/****************************************************************************
* cmdBld_CmdIeEnableTx()
****************************************************************************
* DESCRIPTION: Construct the EnableTx command fileds and send it to the mailbox
* Note: This Enable_TX command is used also for changing the serving
* channel.
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeEnableTx (TI_HANDLE hCmdBld, TI_UINT8 channel, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
TI_UINT8 aEnableTx_buf[4];
aEnableTx_buf[0] = channel;
aEnableTx_buf[1] = 0; /* padding */
aEnableTx_buf[2] = 0; /* padding */
aEnableTx_buf[3] = 0; /* padding */
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_ENABLE_TX,
(TI_CHAR *)aEnableTx_buf,
sizeof(aEnableTx_buf),
fCb,
hCb,
NULL);
}
TI_STATUS cmdBld_CmdIeBssStart (TI_HANDLE hCmdBld, BssStartCmd_t *pBssStartParams, void* fCB, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
BssStartCmd_t tCmdBssStart;
BssStartCmd_t *pCmd = &tCmdBssStart ;
TI_UINT8 tmpSsid[33] = {0}; /* For debug only - Remove later!!*/
os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
pCmd->bssIndex = pBssStartParams->bssIndex;
pCmd->beaconInterval = ENDIAN_HANDLE_WORD(pBssStartParams->beaconInterval);
pCmd->dtimInterval = pBssStartParams->dtimInterval;
pCmd->agingPeriod = ENDIAN_HANDLE_WORD(pBssStartParams->agingPeriod);
pCmd->channelNumber = pBssStartParams->channelNumber;
pCmd->band = pBssStartParams->band;
pCmd->broadcastHLID = pBssStartParams->broadcastHLID;
pCmd->globalHLID = pBssStartParams->globalHLID;
pCmd->basicRateSet = ENDIAN_HANDLE_LONG(pBssStartParams->basicRateSet);
pCmd->beaconExpiry = pBssStartParams->beaconExpiry;
os_memoryCopy(pCmdBld->hOs, &pCmd->ssid, &pBssStartParams->ssid, sizeof(SSID_t));
os_memoryCopy(pCmdBld->hOs, pCmd->bssid, pBssStartParams->bssid, MAC_ADDR_LEN);
os_memoryCopy(pCmdBld->hOs, &tmpSsid, &pBssStartParams->ssid.ssid, pBssStartParams->ssid.ssidLength);
tmpSsid[pBssStartParams->ssid.ssidLength]= '\0';
WLAN_OS_REPORT(("\n%s: ------------------------------------------->\n", __FUNCTION__));
WLAN_OS_REPORT(("ssid=%s len=%d bssid=%02X:%02X:%02X:%02X:%02X:%02X Indx=%d\n", tmpSsid, pCmd->ssid.ssidLength,
pCmd->bssid[0],pCmd->bssid[1],pCmd->bssid[2],pCmd->bssid[3],pCmd->bssid[4],pCmd->bssid[5], pCmd->bssIndex));
WLAN_OS_REPORT(("beacon=%d dtim=%d aging=%d chan=%d band=%d\n",
pCmd->beaconInterval, pCmd->dtimInterval, pCmd->agingPeriod, pCmd->channelNumber, pCmd->band));
WLAN_OS_REPORT(("brdcstHLID=%d globalHLID=%d ssidType=%d basicRates=0x%04x beacon expiry=%d\n",
pCmd->broadcastHLID, pCmd->globalHLID, pCmd->ssid.ssidType, (TI_UINT32)pCmd->basicRateSet, pCmd->beaconExpiry));
WLAN_OS_REPORT(("%s: <--------------------------------------------\n", __FUNCTION__));
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_BSS_START,
(void *)pCmd,
sizeof(*pCmd),
fCB,
hCb,
NULL);
}
/****************************************************************************
* cmdBld_ItrIeNoiseHistogramResults()
****************************************************************************
* DESCRIPTION: Get the Noise Histogram Measurement Results.
*
* INPUTS:
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ItrIeNoiseHistogramResults (TI_HANDLE hCmdBld,
TInterrogateCmdCbParams noiseHistCBParams)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
NoiseHistResult_t results;
NoiseHistResult_t *pCfg = &results;
/* Set information element header*/
pCfg->EleHdr.id = ACX_NOISE_HIST;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_INTERROGATE,
pCfg,
sizeof(*pCfg),
noiseHistCBParams.fCb,
noiseHistCBParams.hCb,
noiseHistCBParams.pCb);
}
/****************************************************************************
* cmdBld_ItrIeTfsDtim ()
****************************************************************************
* DESCRIPTION: Get the Tsf and Dtim counter from Fw
*
* INPUTS:
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ItrIeTfsDtim (TI_HANDLE hCmdBld,
TInterrogateCmdCbParams mediumUsageCBParams)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ACX_fwTSFInformation_t fwTsfDtimMib;
ACX_fwTSFInformation_t *pCfg = &fwTsfDtimMib;
/* Set information element header*/
pCfg->EleHdr.id = ACX_TSF_INFO;
pCfg->EleHdr.len = sizeof(ACX_fwTSFInformation_t) - sizeof(EleHdrStruct);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_INTERROGATE,
pCfg,
sizeof(*pCfg),
mediumUsageCBParams.fCb,
mediumUsageCBParams.hCb,
mediumUsageCBParams.pCb);
}
/****************************************************************************
* cmdBld_ItrIeMediumOccupancy ()
****************************************************************************
* DESCRIPTION: Get the Medium Occupancy.
*
* INPUTS:
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_ItrIeMediumOccupancy (TI_HANDLE hCmdBld,
TInterrogateCmdCbParams mediumUsageCBParams)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ACXMediumUsage_t medium;
ACXMediumUsage_t *pCfg = &medium;
/* Set information element header */
pCfg->EleHdr.id = ACX_MEDIUM_USAGE;
pCfg->EleHdr.len = sizeof(*pCfg) - sizeof(EleHdrStruct);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_INTERROGATE,
pCfg,
sizeof(*pCfg),
mediumUsageCBParams.fCb,
mediumUsageCBParams.hCb,
mediumUsageCBParams.pCb);
}
/* \fn cmdBld_CmdIeAddSta
*
* \brief Build and send CMD_ADD_STA to the FW via Cmd Mailbox
*/
TI_STATUS cmdBld_CmdIeAddSta (TI_HANDLE hCmdBld, TTwdAddStaParams *addStaParams, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
AddStation_t cmdAddSta;
AddStation_t *pCmd = &cmdAddSta;
os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
pCmd->BSSIndex = addStaParams->uBssIndex;
pCmd->HLID = addStaParams->uHlid;
pCmd->AID = addStaParams->uAid;
os_memoryCopy(pCmdBld->hOs,pCmd->macAddress, addStaParams->aMacAddr, MAC_ADDR_SIZE);
pCmd->WMM = addStaParams->bWme;
pCmd->SPLen = addStaParams->uSPLen;
os_memoryCopy(pCmdBld->hOs,pCmd->PSDType, addStaParams->aPSDType, sizeof(pCmd->PSDType));
pCmd->supportedRates = addStaParams->uSupRates;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_ADD_STA, (void *)pCmd,
sizeof(*pCmd), fCb, hCb, NULL);
}
/****************************************************************************
* cmdBld_CmdIeBssStop()
****************************************************************************
****************************************************************************/
TI_STATUS cmdBld_CmdIeBssStop (TI_HANDLE hCmdBld, TI_UINT8 bssIdx, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
BssStartCmd_t Cmd_BssStart;
BssStartCmd_t *pCmd = &Cmd_BssStart;
os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
pCmd->bssIndex = bssIdx;
WLAN_OS_REPORT(("\n <<<<<<<<<<<<<< Send cmdBld_CmdIeBssStop (index=%d) >>>>>>>>>>>>>>>>>>> \n", pCmd->bssIndex));
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_BSS_STOP,
(void *)pCmd,
sizeof(*pCmd),
fCb,
hCb,
NULL);
}
/****************************************************************************
* cmdBld_CmdIeSetPsMode()
****************************************************************************
* DESCRIPTION: send Command for Power Management configuration
* to the mailbox
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeSetPsMode (TI_HANDLE hCmdBld, TPowerSaveParams* powerSaveParams, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
PSModeParameters_t Cmd_PowerMgmtCnf;
PSModeParameters_t * pCmd = &Cmd_PowerMgmtCnf;
os_memoryZero(pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
if (powerSaveParams->ps802_11Enable) {
pCmd->mode = 1;
} else {
pCmd->mode = 0;
}
pCmd->hangOverPeriod = powerSaveParams->hangOverPeriod;
pCmd->needToSendNullData = powerSaveParams->needToSendNullData;
pCmd->rateToTransmitNullData = ENDIAN_HANDLE_LONG(powerSaveParams->NullPktRateModulation);
pCmd->numberOfRetries = powerSaveParams->numNullPktRetries;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_SET_PS_MODE, (TI_CHAR *)pCmd, sizeof(*pCmd), fCb, hCb, NULL);
}
/****************************************************************************
* cmdBld_CmdIeApDiscovery()
****************************************************************************
* DESCRIPTION: send Command for AP Discovery
* to the mailbox
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeApDiscovery (TI_HANDLE hCmdBld, TApDiscoveryParams *pApDiscoveryParams, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
ApDiscoveryParameters_t Cmd_ApDiscovery;
ApDiscoveryParameters_t *pCmd = &Cmd_ApDiscovery;
os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
pCmd->txPowerAttenuation = pApDiscoveryParams->txPowerDbm;
pCmd->numOfProbRqst = pApDiscoveryParams->numOfProbRqst;
pCmd->scanDuration = ENDIAN_HANDLE_LONG(pApDiscoveryParams->scanDuration);
pCmd->scanOptions = ENDIAN_HANDLE_WORD(pApDiscoveryParams->scanOptions);
pCmd->txdRateSet = ENDIAN_HANDLE_LONG(pApDiscoveryParams->txdRateSet);
pCmd->rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG(pApDiscoveryParams->ConfigOptions);
pCmd->rxFilter.FilterOptions = ENDIAN_HANDLE_LONG(pApDiscoveryParams->FilterOptions);
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_AP_DISCOVERY,
(void *)pCmd,
sizeof(*pCmd),
fCb,
hCb,
NULL);
}
/****************************************************************************
* cmdBld_CmdIeHealthCheck()
****************************************************************************
* DESCRIPTION:
*
* INPUTS:
*
* OUTPUT:
*
* RETURNS:
****************************************************************************/
TI_STATUS cmdBld_CmdIeHealthCheck (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_HEALTH_CHECK, NULL, 0, fCb, hCb, NULL);
}
/****************************************************************************
* cmdBld_CmdIeApDiscoveryStop()
****************************************************************************
* DESCRIPTION: send Command for stoping AP Discovery
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeApDiscoveryStop (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_STOP_AP_DISCOVERY, 0, 0, fCb, hCb, NULL);
}
/* \fn cmdBld_CmdIeNop
*
* \brief Send CMD_NOP to TWD command queue
*/
TI_STATUS cmdBld_CmdIeNop (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_NOP, NULL, 0, fCb, hCb, NULL);
}
/****************************************************************************
* cmdBld_CmdIeSwitchChannelCancel ()
****************************************************************************
* DESCRIPTION: Send CMD_SWITCH_CHANNEL_CANCEL Command
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeSwitchChannelCancel (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_STOP_CHANNEL_SWICTH, 0, 0, fCb, hCb, NULL);
}
/****************************************************************************
* cmdBld_CmdIeDisableTx()
****************************************************************************
* DESCRIPTION: Construct the DisableTx command fileds and send it to the mailbox
*
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeDisableTx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
{
TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_DISABLE_TX, NULL, 0, fCb, hCb, NULL);
}
/****************************************************************************
* cmdBld_BitIeTestCmd()
****************************************************************************
* DESCRIPTION:
* INPUTS: None
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS cmdBld_CmdIeTest (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb, TTestCmd* pTestCmd)
{
TCmdBld *pCmdBld = (TI_HANDLE)hCmdBld;
TI_UINT32 paramLength;
TI_BOOL bIsCBfuncNecessary = TI_TRUE;
if (NULL == pTestCmd) {
TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, " pTestCmd_Buf = NULL!!!\n");
return TI_NOK;
}
if ( (TestCmdID_enum)pTestCmd->testCmdId < MAX_TEST_CMD_ID ) {
bIsCBfuncNecessary = TI_TRUE;
} else {
TRACE1(pCmdBld->hReport, REPORT_SEVERITY_WARNING, " Unsupported testCmdId (%d)\n", pTestCmd->testCmdId);
}
if (bIsCBfuncNecessary && fCb == NULL) {
return TI_OK;
}
switch( pTestCmd->testCmdId ) {
case TEST_CMD_PD_BUFFER_CAL:
paramLength = sizeof(TTestCmdPdBufferCal);
break;
case TEST_CMD_P2G_CAL:
paramLength = sizeof(TTestCmdP2GCal);
break;
case TEST_CMD_RX_STAT_GET:
paramLength = sizeof(RadioRxStatistics);
break;
/* packet */
case TEST_CMD_FCC:
paramLength = sizeof(TPacketParam);
break;
/* tone */
case TEST_CMD_TELEC:
paramLength = sizeof(TToneParam);
break;
case TEST_CMD_PLT_TEMPLATE:
paramLength = sizeof(TTxTemplate);
break;
/* channel tune */
case TEST_CMD_CHANNEL_TUNE:
paramLength = sizeof(TTestCmdChannel);
break;
case TEST_CMD_GET_FW_VERSIONS:
paramLength = sizeof(TFWVerisons);
break;
case TEST_CMD_INI_FILE_RADIO_PARAM:
paramLength = sizeof(IniFileRadioParam);
break;
case TEST_CMD_INI_FILE_GENERAL_PARAM:
paramLength = sizeof(IniFileGeneralParam);
break;
case TEST_CMD_PLT_GAIN_ADJUST:
paramLength = sizeof(uint32);
break;
case TEST_CMD_RUN_CALIBRATION_TYPE:
paramLength = sizeof(TTestCmdRunCalibration);
break;
case TEST_CMD_TX_GAIN_ADJUST:
paramLength = sizeof(TTxGainAdjust);
break;
case TEST_CMD_TEST_TONE:
paramLength = sizeof(TestToneParams_t);
break;
case TEST_CMD_SET_EFUSE:
paramLength = sizeof(EfuseParameters_t);
break;
case TEST_CMD_GET_EFUSE:
paramLength = sizeof(EfuseParameters_t);
break;
case TEST_CMD_RX_PLT_CAL:
paramLength = sizeof(RadioRxPltCal);
break;
case TEST_CMD_UPDATE_PD_REFERENCE_POINT:
paramLength = sizeof(TTestCmdUpdateReferncePoint);
break;
case TEST_CMD_UPDATE_PD_BUFFER_ERRORS:
paramLength = sizeof(TTestCmdPdBufferErrors);
break;
case TEST_CMD_POWER_MODE:
paramLength = sizeof(TTestCmdPowerMode);
break;
case TEST_CMD_STOP_TX:
case TEST_CMD_RX_STAT_STOP:
case TEST_CMD_RX_STAT_START:
case TEST_CMD_RX_STAT_RESET:
case TEST_CMD_RX_PLT_ENTER:
case TEST_CMD_RX_PLT_EXIT:
paramLength = 0;
break;
default:
paramLength = sizeof(pTestCmd->testCmd_u);
}
return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
CMD_TEST,
(void *)pTestCmd,
paramLength + RESEARVED_SIZE_FOR_RESPONSE,
fCb,
hCb,
(void*)pTestCmd);
}
