/*

 * 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