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