diff -r 000000000000 -r 10c42ec6c05f TWD/Ctrl/CmdBldCmdIE.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TWD/Ctrl/CmdBldCmdIE.c Tue Jun 29 12:34:26 2010 +0100 @@ -0,0 +1,1091 @@ +/* + * CmdBldCmdIE.c + * + * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved. + * All rights reserved. + * + * This program and the accompanying materials are made available under the + * terms of the Eclipse Public License v1.0 or BSD License which accompanies + * this distribution. The Eclipse Public License is available at + * http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name Texas Instruments nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + + +/** \file CmdBldCmdIE.c + * \brief Command builder. Command information elements + * + * \see CmdBldCmdIE.h + */ +#define __FILE_ID__ FILE_ID_94 +#include "osApi.h" +#include "tidef.h" +#include "report.h" +#include "TWDriver.h" +#include "CmdQueue_api.h" +#include "CmdBld.h" + + +/* Local Macros */ + +#define MAC_TO_VENDOR_PREAMBLE(mac) ((mac[0] << 16) | (mac[1] << 8) | mac[2]) + +/******************************************* + * Wlan hardware Test (BIT) + * ================= + * + * Tests description: + * ================== + * FCC = Continuous modulated transmission (should not emit carrier) + * TELEC = Continuous unmodulated carrier transmission (carrier only) + * PER_TX_STOP = Stops the TX test in progress (FCC or TELEC). + * ReadRegister = Read a register value. + * WriteRegister = Sets a register value. +* +* Rx PER test +* ======== +* PerRxStart = Start or resume the PER measurement. This function will put the device in promiscuous mode, and resume counters update. +* PerRxStop = Stop Rx PER measurements. This function stop counters update and make it is safe to read the PER test result. +* PerRxGetResults = Get the last Rx PER test results. +* PerRxClear = Clear the Rx PER test results. + */ + +enum +{ +/* 0 */ TEST_MOD_QPSK, +/* 1 */ TEST_MOD_CCK, +/* 2 */ TEST_MOD_PBCC, + TEST_MOD_NUMOF +}; + +enum +{ +/* 0 */ TEST_MOD_LONG_PREAMBLE, +/* 1 */ TEST_MOD_SHORT_PREAMBLE +}; + +enum +{ +/* 0 */ TEST_BAND_2_4GHZ, +/* 1 */ TEST_BAND_5GHZ, +/* 2 */ TEST_BAND_4_9GHZ +}; + + +enum +{ + MOD_PBCC = 1, + MOD_CCK, + MOD_OFDM +}; + + +#define TEST_MOD_MIN_GAP 200 +#define TEST_MOD_MIN_TX_BODYLEN 0 +#define TEST_MOD_MAX_TX_BODYLEN 2304 + +#define TEST_RX_CAL_SAFE_TIME 5000 /*uSec*/ + +#define TEST_MOD_IS_GAP_OK(gap) ((gap) >= TEST_MOD_MIN_GAP) + +#define TEST_MOD_IS_TX_BODYLEN_OK(len) \ + (INRANGE((len), TEST_MOD_MIN_TX_BODYLEN, TEST_MOD_MAX_TX_BODYLEN) && \ + (((len) & 3) == 0) ) + +#define TEST_MOD_IS_PREAMBLE_OK(p) \ + INRANGE((p), TEST_MOD_LONG_PREAMBLE, TEST_MOD_SHORT_PREAMBLE) + + +#define RESEARVED_SIZE_FOR_RESPONSE 4 + + +/**************************************************************************** + * cmdBld_CmdIeStartBss() + **************************************************************************** + * DESCRIPTION: Construct the StartBss command fileds and send it to the mailbox + * + * INPUTS: None + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeStartBss (TI_HANDLE hCmdBld, BSS_e BssType, void *fJoinCompleteCb, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + StartJoinRequest_t AcxCmd_StartBss; + StartJoinRequest_t *pCmd = &AcxCmd_StartBss; + TSsid *pSsid = &DB_BSS(hCmdBld).tSsid; + TBssInfoParams *pBssInfoParams = &DB_BSS(hCmdBld); + TI_UINT8 *BssId; + TI_UINT8 *cmdBssId; + EHwRateBitFiled HwBasicRatesBitmap; + TI_UINT32 i; + + os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(StartJoinRequest_t)); + + /* + * Set RxCfg and RxFilterCfg values + */ + pCmd->rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG (DB_WLAN(hCmdBld).RxConfigOption); + pCmd->rxFilter.FilterOptions = ENDIAN_HANDLE_LONG (DB_WLAN(hCmdBld).RxFilterOption); + pCmd->beaconInterval = ENDIAN_HANDLE_WORD (DB_BSS(hCmdBld).BeaconInterval); + pCmd->dtimInterval = DB_BSS(hCmdBld).DtimInterval; + pCmd->channelNumber = DB_BSS(hCmdBld).RadioChannel; + pCmd->bssType = BssType; + /* Add radio band */ + pCmd->bssType |= DB_WLAN(hCmdBld).RadioBand << 4; + /* Bits 0-2: Tx-Session-Count. bit 7: indicates if to flush the Tx queues */ + pCmd->ctrl = pBssInfoParams->Ctrl; + + /* + * BasicRateSet + * The wlan hardware uses pHwMboxCmd field to determine the rate at which to transmit + * control frame responses (such as ACK or CTS frames) + */ + cmdBld_ConvertAppRatesBitmap (pBssInfoParams->BasicRateSet, 0, &HwBasicRatesBitmap); + pCmd->basicRateSet = ENDIAN_HANDLE_LONG(HwBasicRatesBitmap); + + /* BSS ID - reversed order (see wlan hardware spec) */ + BssId = DB_BSS(hCmdBld).BssId; + cmdBssId = (TI_UINT8*)&pCmd->bssIdL; + for (i = 0; i < MAC_ADDR_LEN; i++) + cmdBssId[i] = BssId[MAC_ADDR_LEN - 1 - i]; + + /* SSID string */ + pCmd->ssidLength = pSsid->len; + os_memoryCopy (pCmdBld->hOs, (void *)pCmd->ssidStr, (void *)pSsid->str, pSsid->len); + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_START_JOIN, + (TI_CHAR *)pCmd, + sizeof(*pCmd), + fJoinCompleteCb, + 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 uChannelNumber; + + uChannelNumber = DB_DEFAULT_CHANNEL (hCmdBld); + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_ENABLE_RX, + (TI_CHAR *)&uChannelNumber, + sizeof(TI_UINT8), + 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; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_ENABLE_TX, + (TI_CHAR *)&channel, + sizeof(TI_UINT8), + fCb, + hCb, + NULL); +} + + +/**************************************************************************** + * cmdBld_CmdIeDisableRx() + **************************************************************************** + * DESCRIPTION: Construct the DisableRx command fileds and send it to the mailbox + * + * INPUTS: None + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeDisableRx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_DISABLE_RX, NULL, 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_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) + { + TRACE3(pCmdBld->hReport, REPORT_SEVERITY_ERROR, ": Frame size (=%d) of CmdType (=%d) is bigger than MAX_TEMPLATES_SIZE(=%d) !!!\n", uFrameSize, eTemplateType, MAX_TEMPLATES_SIZE); + + 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 = 10; + pCmd->templateTxAttribute.longRetryLimit = 10; + +#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); +} + + +/**************************************************************************** + * cmdBld_CmdIeSetKey() + **************************************************************************** + * DESCRIPTION: Construct the SetKey command fileds and send it to the mailbox + * + * INPUTS: + * Action - add/remove key + * MacAddr - relevant only for mapping keys + * KeySize - key size + * KeyType - default/mapping/TKIP + * KeyId - relevant only for default keys + * Key - key data + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeSetKey (TI_HANDLE hCmdBld, + TI_UINT32 action, + TI_UINT8 *pMacAddr, + TI_UINT32 uKeySize, + TI_UINT32 uKeyType, + TI_UINT32 uKeyId, + TI_UINT8 *pKey, + TI_UINT32 uSecuritySeqNumLow, + TI_UINT32 uSecuritySeqNumHigh, + void *fCb, + TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + SetKey_t AcxCmd_SetKey; + SetKey_t *pCmd = &AcxCmd_SetKey; + + os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd)); + + MAC_COPY (pCmd->addr, pMacAddr); + + if (uKeySize > MAX_KEY_SIZE) + { + os_memoryCopy (pCmdBld->hOs, (void *)pCmd->key, (void *)pKey, MAX_KEY_SIZE); + } + else + { + os_memoryCopy (pCmdBld->hOs, (void *)pCmd->key, (void *)pKey, uKeySize); + } + + pCmd->action = ENDIAN_HANDLE_WORD((TI_UINT16)action); + pCmd->keySize = (TI_UINT8)uKeySize; + pCmd->type = (TI_UINT8)uKeyType; + pCmd->id = (TI_UINT8)uKeyId; + pCmd->ssidProfile = 0; + + /* + * Preserve TKIP/AES security sequence number after recovery. + * Note that our STA Tx is currently using only one sequence-counter + * for all ACs (unlike the Rx which is separated per AC). + */ + pCmd->AcSeqNum16[0] = ENDIAN_HANDLE_WORD((TI_UINT16)uSecuritySeqNumLow); + pCmd->AcSeqNum16[1] = 0; + pCmd->AcSeqNum16[2] = 0; + pCmd->AcSeqNum16[3] = 0; + + pCmd->AcSeqNum32[0] = ENDIAN_HANDLE_LONG(uSecuritySeqNumHigh); + pCmd->AcSeqNum32[1] = 0; + pCmd->AcSeqNum32[2] = 0; + pCmd->AcSeqNum32[3] = 0; + + +TRACE6(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "Addr: %02x:%02x:%02x:%02x:%02x:%02x\n", pCmd->addr[0],pCmd->addr[1],pCmd->addr[2],pCmd->addr[3],pCmd->addr[4],pCmd->addr[5]); + +TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "Action=%x,keySize=0x%x,type=%x, id=%x, ssidProfile=%x, AcSeqNum16[0]=%x, AcSeqNum32[0]=%x\n", pCmd->action,pCmd->keySize, pCmd->type,pCmd->id,pCmd->ssidProfile,pCmd->AcSeqNum16[0],pCmd->AcSeqNum32[0] ); + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_SET_KEYS, (char *)pCmd, sizeof(*pCmd), fCb, hCb, NULL); +} + + +/**************************************************************************** + * cmdBld_CmdIeStartScan () + **************************************************************************** + * DESCRIPTION: Send SCAN Command + * + * INPUTS: None + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeStartScan (TI_HANDLE hCmdBld, ScanParameters_t* pScanParams, void *fScanResponseCb, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_SCAN, + (TI_CHAR *)pScanParams, + sizeof(ScanParameters_t), + fScanResponseCb, + hCb, + NULL); +} + +/**************************************************************************** + * cmdBld_CmdIeStartSPSScan () + **************************************************************************** + * DESCRIPTION: Send SPS SCAN Command + * + * INPUTS: None + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeStartSPSScan (TI_HANDLE hCmdBld, ScheduledScanParameters_t* pScanParams, void* fScanResponseCb, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_SPS_SCAN, + (TI_CHAR *)pScanParams, + sizeof(ScheduledScanParameters_t), + fScanResponseCb, + hCb, + NULL); +} + + +/**************************************************************************** + * cmdBld_CmdIeStopScan () + **************************************************************************** + * DESCRIPTION: Construct the STOP_SCAN command fields and send it to the + * mailbox + * + * INPUTS: None + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeStopScan (TI_HANDLE hCmdBld, void *fScanResponseCb, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CmdIeStopScan: -------------- \n"); + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_STOP_SCAN, 0, 0, fScanResponseCb, hCb, NULL); +} + + +/**************************************************************************** + * cmdBld_CmdIeStopSPSScan () + **************************************************************************** + * DESCRIPTION: Construct the STOP_SPS_SCAN command fields and send it to the + * mailbox + * + * INPUTS: None + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeStopSPSScan (TI_HANDLE hCmdBld, void* fScanResponseCB, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CmdIeStopSPSScan: -------------- \n"); + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_STOP_SPS_SCAN, 0, 0, fScanResponseCB, hCb, NULL); +} + + +TI_STATUS cmdBld_CmdIeSetSplitScanTimeOut (TI_HANDLE hCmdBld, TI_UINT32 uTimeOut, void *fCB, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + enhancedTriggerTO_t Cmd_enhancedTrigger; + enhancedTriggerTO_t *pCmd = &Cmd_enhancedTrigger; + +TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CmdIeSetSplitScanTimeOut: uTimeOut=%d -------------- \n", uTimeOut); + + pCmd->slicedScanTimeOut = uTimeOut; + + return cmdQueue_SendCommand(pCmdBld->hCmdQueue, CMD_TRIGGER_SCAN_TO, (char *)pCmd, sizeof(*pCmd), fCB, hCb, NULL); +} + +/** + * \fn cmdBld_CmdIeScanSsidList + * \brief Sets SSID list for periodic scan + * + * Sets SSID list for periodic scan + * + * \param hCmdBld - handle to command builder object + * \param pSsidList - command data + * \param fScanResponseCB - command complete function callback + * \param hCb - command complete callback handle + * \return TI_OK on success, any other code on error + * \sa cmdBld_CmdIePeriodicScanParams, cmdBld_CmdIeStartPeriodicScan, cmdBld_CmdIeStopPeriodicScan + */ +TI_STATUS cmdBld_CmdIeScanSsidList (TI_HANDLE hCmdBld, ConnScanSSIDList_t *pSsidList, + void* fScanResponseCB, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_CONNECTION_SCAN_SSID_CFG, + (char *)pSsidList, + sizeof(ConnScanSSIDList_t), + fScanResponseCB, + hCb, + NULL); +} + +/** + * \fn cmdBld_CmdIePeriodicScanParams + * \brief Sets periodic scan parameters + * + * Sets periodic scan parameters + * + * \param hCmdBld - handle to command builder object + * \param pPeriodicScanParams - command data + * \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_CmdIeStartPeriodicScan, cmdBld_CmdIeStopPeriodicScan + */ +TI_STATUS cmdBld_CmdIePeriodicScanParams (TI_HANDLE hCmdBld, ConnScanParameters_t *pPeriodicScanParams, + void* fScanResponseCB, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_CONNECTION_SCAN_CFG, + (char *)pPeriodicScanParams, + sizeof(ConnScanParameters_t), + fScanResponseCB, + hCb, + NULL); +} + +/** + * \fn cmdBld_CmdIeStartPeriodicScan + * \brief Starts a periodic scan operation + * + * Starts a periodic scan operation + * + * \param hCmdBld - handle to command builder object + * \param pPeriodicScanStart - command data + * \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_CmdIeStopPeriodicScan + */ +TI_STATUS cmdBld_CmdIeStartPeriodicScan (TI_HANDLE hCmdBld, PeriodicScanTag* pPeriodicScanStart, + void* fScanResponseCB, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_START_PERIODIC_SCAN, + pPeriodicScanStart, sizeof (PeriodicScanTag), + fScanResponseCB, + hCb, + NULL); +} + +/** + * \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_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); +} + + +/**************************************************************************** + * 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_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_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_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_CmdIeMeasurement() + **************************************************************************** + * DESCRIPTION: send Command for measurement configuration + * to the mailbox + * + * INPUTS: None + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeMeasurement (TI_HANDLE hCmdBld, + TMeasurementParams *pMeasurementParams, + void *fMeasureResponseCb, + TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + MeasurementParameters_t Cmd_MeasurementParam; + MeasurementParameters_t *pCmd = &Cmd_MeasurementParam; + + os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd)); + + pCmd->band = pMeasurementParams->band; + pCmd->channel = pMeasurementParams->channel; + pCmd->duration = ENDIAN_HANDLE_LONG(pMeasurementParams->duration); + pCmd->rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG(pMeasurementParams->ConfigOptions); + pCmd->rxFilter.FilterOptions = ENDIAN_HANDLE_LONG(pMeasurementParams->FilterOptions); + pCmd->scanTag = (TI_UINT8)pMeasurementParams->eTag; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_MEASUREMENT, + (TI_CHAR *)pCmd, + sizeof(*pCmd), + fMeasureResponseCb, + hCb, + NULL); +} + + +/**************************************************************************** + * cmdBld_CmdIeMeasurementStop() + **************************************************************************** + * DESCRIPTION: send Command for stoping measurement + * + * INPUTS: None + * + * OUTPUT: None + * + * RETURNS: TI_OK or TI_NOK + ****************************************************************************/ +TI_STATUS cmdBld_CmdIeMeasurementStop (TI_HANDLE hCmdBld, void* fMeasureResponseCb, TI_HANDLE hCb) +{ + TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; + + return cmdQueue_SendCommand (pCmdBld->hCmdQueue, + CMD_STOP_MEASUREMENT, + 0, + 0, + fMeasureResponseCb, + 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_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); +} + + +/**************************************************************************** + * 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_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_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_FREE_RUN_RSSI: + paramLength = sizeof(TTestCmdFreeRSSI); + 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); +}