/*

 * TWDriverCtrl.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  TWDriver.c 

 *  \brief TI WLAN Hardware Access Driver, Parameters control

 *

 *  \see   TWDriver.h 

 */

#define __FILE_ID__  FILE_ID_118

#include "TWDriver.h"

#include "tidef.h"

#include "report.h"

#include "txHwQueue_api.h"

#include "txXfer_api.h"

#include "txResult_api.h"

#include "eventMbox_api.h" 

#include "TWDriver.h"

#include "TWDriverInternal.h"

#include "FwEvent_api.h"

#include "CmdBld.h"

#include "RxQueue_api.h"

TI_STATUS TWD_SetParam (TI_HANDLE hTWD, TTwdParamInfo *pParamInfo)

{

    TTwd           *pTWD = (TTwd *)hTWD;

    TWlanParams    *pWlanParams = &DB_WLAN(pTWD->hCmdBld);

    TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetParam: paramType=0x%X\n", pParamInfo->paramType);

    switch (pParamInfo->paramType)

    {

        case TWD_RTS_THRESHOLD_PARAM_ID:

            if  (pParamInfo->content.halCtrlRtsThreshold > TWD_RTS_THRESHOLD_MAX)

            {

                TRACE1(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD########TWD_RTS_THRESHOLD_PARAM: Value out of permitted range 0x%x\n", pParamInfo->content.halCtrlRtsThreshold);

                return (PARAM_VALUE_NOT_VALID);

            }

            if (cmdBld_CfgRtsThreshold (pTWD->hCmdBld, pParamInfo->content.halCtrlRtsThreshold, NULL, NULL) == TI_OK)

            {

                TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD########TWD_RTS_THRESHOLD_PARAM 0x%x\n", pParamInfo->content.halCtrlRtsThreshold);

                pWlanParams->RtsThreshold = pParamInfo->content.halCtrlRtsThreshold;

            }

            break;

        case TWD_CTS_TO_SELF_PARAM_ID:

            return cmdBld_CfgCtsProtection (pTWD->hCmdBld, pParamInfo->content.halCtrlCtsToSelf, NULL, NULL);

        case TWD_RX_TIME_OUT_PARAM_ID:

            if (cmdBld_CfgServicePeriodTimeout (pTWD->hCmdBld, &pParamInfo->content.halCtrlRxTimeOut, NULL, NULL) == TI_OK)

            {

                pWlanParams->rxTimeOut.psPoll = pParamInfo->content.halCtrlRxTimeOut.psPoll;

                pWlanParams->rxTimeOut.UPSD   = pParamInfo->content.halCtrlRxTimeOut.UPSD;  

            }

            break;

        case TWD_FRAG_THRESHOLD_PARAM_ID:

            if (pParamInfo->content.halCtrlFragThreshold < TWD_FRAG_THRESHOLD_MIN ||

                pParamInfo->content.halCtrlFragThreshold > TWD_FRAG_THRESHOLD_MAX)

                return PARAM_VALUE_NOT_VALID;

            cmdBld_CfgFragmentThreshold (pTWD->hCmdBld, pParamInfo->content.halCtrlFragThreshold, NULL, NULL);

            break;

        case TWD_MAX_RX_MSDU_LIFE_TIME_PARAM_ID:

            cmdBld_CfgRxMsduLifeTime (pTWD->hCmdBld, pParamInfo->content.halCtrlMaxRxMsduLifetime, NULL, NULL);

            break;

        case TWD_ACX_STATISTICS_PARAM_ID:

            if (cmdBld_CfgStatisitics (pTWD->hCmdBld, NULL, NULL) != TI_OK)

                return TI_NOK;

            break;

        case TWD_LISTEN_INTERVAL_PARAM_ID:

            if (pParamInfo->content.halCtrlListenInterval < TWD_LISTEN_INTERVAL_MIN ||

                pParamInfo->content.halCtrlListenInterval > TWD_LISTEN_INTERVAL_MAX)

                return PARAM_VALUE_NOT_VALID;

            pWlanParams->ListenInterval = (TI_UINT8)pParamInfo->content.halCtrlListenInterval;

            break;

        case TWD_AID_PARAM_ID:

            pWlanParams->Aid = pParamInfo->content.halCtrlAid;

            /* Configure the ACXAID info element*/

            if (cmdBld_CfgAid (pTWD->hCmdBld, pParamInfo->content.halCtrlAid, NULL, NULL) != TI_OK)

               return TI_NOK;

            break;

        case TWD_RSN_HW_ENC_DEC_ENABLE_PARAM_ID:

            TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD########HW_ENC_DEC_ENABLE %d\n", pParamInfo->content.rsnHwEncDecrEnable);

            /* Set the Encryption/Decryption on the HW*/

            if (cmdBld_CfgHwEncDecEnable (pTWD->hCmdBld, pParamInfo->content.rsnHwEncDecrEnable, NULL, NULL) != TI_OK)

                return (TI_NOK);

            break;

        case TWD_RSN_KEY_ADD_PARAM_ID:

            TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD########KEY_ADD\n");

            if (cmdBld_CmdAddKey (pTWD->hCmdBld,

                                  (TSecurityKeys *) pParamInfo->content.configureCmdCBParams.pCb,

                                  TI_FALSE,

                                  pParamInfo->content.configureCmdCBParams.fCb, 

                                  pParamInfo->content.configureCmdCBParams.hCb) != TI_OK)

                return TI_NOK;

            break;

        case TWD_RSN_KEY_REMOVE_PARAM_ID:

            TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD########KEY_REMOVE\n");

            if (cmdBld_CmdRemoveKey (pTWD->hCmdBld, 

                                     (TSecurityKeys *) pParamInfo->content.configureCmdCBParams.pCb,

                                     pParamInfo->content.configureCmdCBParams.fCb, 

                                     pParamInfo->content.configureCmdCBParams.hCb) != TI_OK)

                return TI_NOK;

            break;

        case TWD_RSN_DEFAULT_KEY_ID_PARAM_ID:

            if (*((TI_UINT8 *)pParamInfo->content.configureCmdCBParams.pCb) > MAX_DEFAULT_KEY_ID)

                return PARAM_VALUE_NOT_VALID;

            TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD########DEFAULT_KEY_ID %d\n", (TI_UINT8)pParamInfo->content.rsnDefaultKeyID);

			if (cmdBld_CmdSetWepDefaultKeyId (pTWD->hCmdBld,

									  *((TI_UINT8 *)pParamInfo->content.interogateCmdCBParams.pCb),

									  pParamInfo->content.interogateCmdCBParams.fCb, 

									  pParamInfo->content.interogateCmdCBParams.hCb) != TI_OK) 

                return TI_NOK;

            break;

        case TWD_RSN_SECURITY_MODE_PARAM_ID:

            TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD########SECURITY_MODE_SET %d\n", pParamInfo->content.rsnEncryptionStatus);

            if (cmdBld_CfgSecureMode (pTWD->hCmdBld, (ECipherSuite)pParamInfo->content.rsnEncryptionStatus, NULL, NULL) != TI_OK)

                return TI_NOK;

            break;

#ifdef XCC_MODULE_INCLUDED

        case TWD_RSN_XCC_SW_ENC_ENABLE_PARAM_ID:

            TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD: XCC_SW_ENC_ENABLE %d\n", pParamInfo->content.rsnXCCSwEncFlag);

            /* when SW encryption is ON, HW encryption should be turned OFF and vice versa */

            TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD: Set HwEncDecrEnable to %d\n", !pParamInfo->content.rsnXCCSwEncFlag);

            /* Set the Encryption/Decryption on the HW*/

            if (cmdBld_CfgHwEncDecEnable (pTWD->hCmdBld, !pParamInfo->content.rsnXCCSwEncFlag, NULL, NULL) != TI_OK)

                return TI_NOK;

            break;

             /* not supported - CKIP*/

        case TWD_RSN_XCC_MIC_FIELD_ENABLE_PARAM_ID:

            break;

#endif /* XCC_MODULE_INCLUDED*/

        case TWD_TX_POWER_PARAM_ID:

            TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_TX_POWER_PARAM_ID %d\n", pParamInfo->content.halCtrlTxPowerDbm);

			if (pWlanParams->TxPowerDbm == pParamInfo->content.halCtrlTxPowerDbm)

			{	/* Save up time if we set the same value */

				return PARAM_ALREADY_CONFIGURED;

			}

            pWlanParams->TxPowerDbm = pParamInfo->content.halCtrlTxPowerDbm;

            /* Configure the wlan hardware */

            if (cmdBld_CfgTxPowerDbm (pTWD->hCmdBld, pWlanParams->TxPowerDbm, NULL, NULL) != TI_OK)

                return TI_NOK;

            break;

        case TWD_SG_ENABLE_PARAM_ID:

            return cmdBld_CfgSgEnable (pTWD->hCmdBld, 

                                       (ESoftGeminiEnableModes)pParamInfo->content.SoftGeminiEnable, 

                                       NULL, 

                                       NULL);

        case TWD_SG_CONFIG_PARAM_ID:

            return cmdBld_CfgSg (pTWD->hCmdBld, &pParamInfo->content.SoftGeminiParam, NULL, NULL);

        case TWD_FM_COEX_PARAM_ID:

            return cmdBld_CfgFmCoex (pTWD->hCmdBld, &pParamInfo->content.tFmCoexParams, NULL, NULL);

        /*

         *  TX Parameters 

         */ 

        case TWD_TX_RATE_CLASS_PARAM_ID:

            return cmdBld_CfgTxRatePolicy (pTWD->hCmdBld, pParamInfo->content.pTxRatePlicy, NULL, NULL);

        case TWD_QUEUES_PARAM_ID:

            return cmdBld_CfgTid (pTWD->hCmdBld, pParamInfo->content.pQueueTrafficParams, NULL, NULL);

        case TWD_CLK_RUN_ENABLE_PARAM_ID:

            TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_SetParam: CLK_RUN_ENABLE %d\n", pParamInfo->content.halCtrlClkRunEnable);

            /* Set the Encryption/Decryption on the HW*/

            if (cmdBld_CfgClkRun (pTWD->hCmdBld, pParamInfo->content.halCtrlClkRunEnable, NULL, NULL) != TI_OK)

                return TI_NOK;

            break;

        case TWD_COEX_ACTIVITY_PARAM_ID:

            cmdBld_CfgCoexActivity (pTWD->hCmdBld, pParamInfo->content.tTwdParamsCoexActivityTable.entry, NULL, NULL);

            break;

        case TWD_DCO_ITRIM_PARAMS_ID:

            cmdBld_CfgDcoItrimParams (pTWD->hCmdBld, pParamInfo->content.tDcoItrimParams.enable, 

                                      pParamInfo->content.tDcoItrimParams.moderationTimeoutUsec, NULL, NULL);

            break;

        default:

            TRACE1(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_SetParam - ERROR - Param is not supported, 0x%x\n", pParamInfo->paramType);

            return PARAM_NOT_SUPPORTED;

    }

    return TI_OK;

}

TI_STATUS TWD_GetParam (TI_HANDLE hTWD, TTwdParamInfo *pParamInfo)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_GetParam: called\n");

    return cmdBld_GetParam (pTWD->hCmdBld, pParamInfo);

}

TI_STATUS TWD_CfgRx (TI_HANDLE hTWD, TI_UINT32 uRxConfigOption, TI_UINT32 uRxFilterOption)

{

    TTwd     *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgRx: called\n");

    return cmdBld_CfgRx (pTWD->hCmdBld, uRxConfigOption, uRxFilterOption, NULL, NULL);

}

TI_STATUS TWD_CfgArpIpAddrTable (TI_HANDLE hTWD, TIpAddr tIpAddr, TI_BOOL bEnabled, EIpVer eIpVer)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgArpIpAddrTable: called\n");

    return cmdBld_CfgArpIpAddrTable (pTWD->hCmdBld, tIpAddr, bEnabled, eIpVer, NULL, NULL);

}

/** @ingroup Misc

 * \brief  Configure ARP IP Filter

 * 

 * \param hTWD 			- TWD module object handle

 * \param  bEnabled   	- Indicates if ARP filtering is Enabled (1) or Disabled (0)

 * \return TI_OK on success or TI_NOK on failure

 * 

 * \par Description

 * 

 * \sa

 */ 

TI_STATUS TWD_CfgArpIpFilter (TI_HANDLE hTWD, TI_BOOL bEnabled)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgArpIpFilter: called\n");

    return cmdBld_CfgArpIpFilter (pTWD->hCmdBld, bEnabled, NULL, NULL);

}

TI_STATUS TWD_CmdSetSplitScanTimeOut  ( TI_HANDLE hTWD, TI_UINT32 uTimeOut )

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CmdSetSplitScanTimeOut: called\n");

    return cmdBld_CmdSetSplitScanTimeOut (pTWD->hCmdBld, uTimeOut);

}

TI_STATUS TWD_CmdJoinBss (TI_HANDLE hTWD, TJoinBss *pJoinBssParams)

{

    TTwd      *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CmdJoinBss: called\n");

    return cmdBld_CmdJoinBss (pTWD->hCmdBld, pJoinBssParams, NULL, NULL);

}

TI_STATUS TWD_CfgKeepAlive (TI_HANDLE hTWD, TKeepAliveParams *pKeepAliveParams)

{

    TTwd      *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgKeepAlive: called\n");

    return cmdBld_CfgKeepAlive (pTWD->hCmdBld, pKeepAliveParams, NULL, NULL);

}

TI_STATUS TWD_CfgKeepAliveEnaDis(TI_HANDLE hTWD, TI_UINT8 enaDisFlag)

{

    TTwd      *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgKeepAliveEnaDis: called\n");

    return cmdBld_CfgKeepAliveEnaDis (pTWD->hCmdBld, enaDisFlag, NULL, NULL);

}

TI_STATUS TWD_CmdTemplate (TI_HANDLE hTWD, TSetTemplate *pTemplateParams, void *fCb, TI_HANDLE hCb)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CmdTemplate: called\n");

    return cmdBld_CmdTemplate (pTWD->hCmdBld, pTemplateParams, fCb, hCb);

}

TI_STATUS TWD_CfgSlotTime (TI_HANDLE hTWD, ESlotTime eSlotTimeVal)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgSlotTime: called\n");

    return cmdBld_CfgSlotTime (pTWD->hCmdBld, eSlotTimeVal, NULL, NULL);

}

TI_STATUS TWD_CfgPreamble (TI_HANDLE hTWD, EPreamble ePreamble)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgPreamble: called\n");

    return cmdBld_CfgPreamble (pTWD->hCmdBld, (Preamble_e)ePreamble, NULL, NULL);

}

TI_STATUS TWD_CfgPacketDetectionThreshold (TI_HANDLE hTWD, TI_UINT32 threshold)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgPacketDetectionThreshold: called\n");

    return cmdBld_CfgPacketDetectionThreshold (pTWD->hCmdBld, threshold, NULL, NULL);

}

TI_STATUS TWD_CmdDisableTx (TI_HANDLE hTWD)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CmdDisableTx: called\n");

    return cmdBld_CmdDisableTx (pTWD->hCmdBld, NULL, NULL);

}

TI_STATUS TWD_CmdEnableTx (TI_HANDLE hTWD, TI_UINT8 channel)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CmdEnableTx: called\n");

    return cmdBld_CmdEnableTx (pTWD->hCmdBld, channel, NULL, NULL);

}

TI_STATUS TWD_CmdSetStaState (TI_HANDLE hTWD, TI_UINT8 staState, void *fCb, TI_HANDLE hCb)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetStaState: %d\n", staState);

    return cmdBld_CmdSetStaState (pTWD->hCmdBld, staState, fCb, hCb);

}

TI_STATUS TWD_ItrRoammingStatisitics (TI_HANDLE hTWD, void *fCb, TI_HANDLE hCb, void * pCb)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_ItrRoammingStatisitics: called\n");

    return cmdBld_ItrRoamimgStatisitics (pTWD->hCmdBld, fCb, hCb, pCb);

}

/** @ingroup UnKnown

 * \brief	Interrogate Error Count

 * 

 * \param  hTWD     	- TWD module object handle

 * \param  fCb          - Pointer to Command CB Function

 * \param  hCb          - Handle to Command CB Function Obj Parameters

 * \param  pCb          - Pointer to read parameters

 * \return TI_OK on success or TI_NOK on failure

 * 

 * \par Description

 * Interrogate ACX Error counter

 * 

 * \sa

 */ 

TI_STATUS TWD_ItrErrorCnt (TI_HANDLE hTWD, void *fCb, TI_HANDLE hCb, void *pCb)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_ItrErrorCnt: called\n");

    return cmdBld_ItrErrorCnt (pTWD->hCmdBld, fCb, hCb, pCb);

}

TI_STATUS TWD_CmdNoiseHistogram (TI_HANDLE hTWD, TNoiseHistogram *pNoiseHistParams)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CmdNoiseHistogram: called\n");

    return cmdBld_CmdNoiseHistogram (pTWD->hCmdBld, pNoiseHistParams, NULL, NULL);

}

TI_STATUS TWD_CfgBeaconFilterOpt (TI_HANDLE hTWD, TI_UINT8 uBeaconFilteringStatus, TI_UINT8 uNumOfBeaconsToBuffer)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgBeaconFilterOpt: called\n");

    return cmdBld_CfgBeaconFilterOpt (pTWD->hCmdBld, uBeaconFilteringStatus, uNumOfBeaconsToBuffer, NULL, NULL);

}

TI_STATUS TWD_SetRateMngDebug(TI_HANDLE hTWD, RateMangeParams_t *pRateMngParams)

{

  TTwd   *pTWD = (TTwd *)hTWD;

   TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetRateMngDebug: called\n");

   return cmdBld_CfgRateMngDbg (pTWD->hCmdBld, pRateMngParams, NULL, NULL);

}

TI_STATUS TWD_CfgBeaconFilterTable (TI_HANDLE hTWD, TI_UINT8 uNumOfIe, TI_UINT8 *pIeTable, TI_UINT8 uIeTableSize)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgBeaconFilterTable: called\n");

    return cmdBld_CfgBeaconFilterTable (pTWD->hCmdBld, uNumOfIe, pIeTable, uIeTableSize, NULL, NULL);

}

TI_STATUS TWD_CfgWakeUpCondition (TI_HANDLE hTWD, TPowerMgmtConfig *pPowerMgmtConfig)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgWakeUpCondition: called\n");

    return cmdBld_CfgWakeUpCondition (pTWD->hCmdBld, pPowerMgmtConfig, NULL, NULL);

}

TI_STATUS TWD_CfgBcnBrcOptions (TI_HANDLE hTWD, TPowerMgmtConfig *pPowerMgmtConfig)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgBcnBrcOptions: called\n");

    return cmdBld_CfgBcnBrcOptions (pTWD->hCmdBld, pPowerMgmtConfig, NULL, NULL);

}

TFwInfo * TWD_GetFWInfo (TI_HANDLE hTWD)

{

    TTwd *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_GetFWInfo: called\n");

    return cmdBld_GetFWInfo (pTWD->hCmdBld);

}

TI_STATUS TWD_CmdSwitchChannel (TI_HANDLE hTWD, TSwitchChannelParams *pSwitchChannelCmd)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CmdSwitchChannel: called\n");

    return cmdBld_CmdSwitchChannel (pTWD->hCmdBld, pSwitchChannelCmd, NULL, NULL);

}

TI_STATUS TWD_CmdSwitchChannelCancel (TI_HANDLE hTWD, TI_UINT8 channel)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CmdSwitchChannelCancel: called\n");

    return cmdBld_CmdSwitchChannelCancel (pTWD->hCmdBld, channel, NULL, NULL);

}

TI_STATUS TWD_CfgMaxTxRetry (TI_HANDLE hTWD, TRroamingTriggerParams *pRoamingTriggerCmd)

{

    TTwd   *pTWD = (TTwd *)hTWD;

    TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CfgMaxTxRetry: called\n");

    return cmdBld_CfgMaxTxRetry (pTWD->hCmdBld, pRoamingTriggerCmd, NULL, NULL);

}

TI_STATUS TWD_CfgConnMonitParams (TI_HANDLE hTWD, TRroamingTriggerParams *pRoamingTriggerCmd)