diff -r 000000000000 -r 10c42ec6c05f TWD/TWDriver/TWDriver.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/TWD/TWDriver/TWDriver.c Tue Jun 29 12:34:26 2010 +0100 @@ -0,0 +1,1827 @@ +/* + * TWDriver.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 + * + * \see TWDriver.h + */ + +#define __FILE_ID__ FILE_ID_117 +#include "report.h" +#include "TWDriver.h" +#include "MacServices_api.h" +#include "txCtrlBlk_api.h" +#include "txHwQueue_api.h" +#include "txXfer_api.h" +#include "txResult_api.h" +#include "rxXfer_api.h" +#include "TwIf.h" +#include "FwEvent_api.h" +#include "CmdMBox_api.h" +#include "CmdQueue_api.h" +#include "eventMbox_api.h" +#include "fwDebug_api.h" +#include "osApi.h" +#include "TWDriverInternal.h" +#include "HwInit_api.h" +#include "CmdBld.h" +#include "RxQueue_api.h" + + + +void TWD_CheckSRConfigParams(TTwd *pTWD, ACXSmartReflexConfigParams_t *tSmartReflexParams); + + +#define TWD_CB_MODULE_OWNER_MASK 0xff00 +#define TWD_CB_TYPE_MASK 0x00ff + +#define FREF_CLK_FREQ_MASK 0x7 + + + + +TI_HANDLE TWD_Create (TI_HANDLE hOs) +{ + TTwd *pTWD; + + /* Allocate the TNETW_Driver module */ + pTWD = (TTwd *)os_memoryAlloc (hOs, sizeof(TTwd),MemoryNormal); + if (pTWD == NULL) + { + return NULL; + } + + os_memoryZero (hOs, pTWD, sizeof(TTwd)); + + pTWD->hOs = hOs; + + /* Create TwIf module */ + pTWD->hTwIf = twIf_Create (hOs); + if (pTWD->hTwIf == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"twIf_Create failed\n"); + WLAN_OS_REPORT(("twIf_Create failed\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + /* Create command builder module */ + pTWD->hCmdBld = cmdBld_Create (hOs); + if (pTWD->hCmdBld == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"cmdBld_Create failed\n"); + WLAN_OS_REPORT(("cmdBld_Create failed\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + /* Create the MAC Services module */ + pTWD->hMacServices = MacServices_create (hOs); + if (pTWD->hMacServices == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD MacServices_create failed!!!\n"); + WLAN_OS_REPORT(("TWD MacServices_create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + /* Create the Ctrl module */ + pTWD->hCmdQueue = cmdQueue_Create (hOs); + if (pTWD->hCmdQueue == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD cmdQueue_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD cmdQueue_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + /* + * Create the FW-Transfer modules: + */ + + pTWD->hTxXfer = txXfer_Create (hOs); + if (pTWD->hTxXfer == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD txXfer_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD txXfer_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + pTWD->hTxResult = txResult_Create (hOs); + if (pTWD->hTxResult == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD txResult_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD txResult_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + pTWD->hRxXfer = rxXfer_Create (hOs); + if (pTWD->hRxXfer == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD rxXfer_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD rxXfer_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + pTWD->hFwEvent = fwEvent_Create (hOs); + if (pTWD->hFwEvent == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD fwEvent_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD fwEvent_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + pTWD->hEventMbox = eventMbox_Create (hOs); + if (pTWD->hEventMbox == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD eventMbox_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD eventMbox_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + +#ifdef TI_DBG + pTWD->hFwDbg = fwDbg_Create (hOs); + if (pTWD->hFwDbg == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD fwDbg_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD fwDbg_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } +#endif /* TI_DBG */ + + pTWD->hCmdMbox = cmdMbox_Create (hOs); + if (pTWD->hCmdMbox == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"TWD cmdMbox_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD cmdMbox_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + pTWD->hRxQueue = RxQueue_Create (hOs); + if (pTWD->hRxQueue == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD RxQueue_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD RxQueue_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + + /* + * Create the Data-Services modules: + */ + + pTWD->hTxCtrlBlk = txCtrlBlk_Create (hOs); + if (pTWD->hTxCtrlBlk == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD txCtrlBlk_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD txCtrlBlk_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + pTWD->hTxHwQueue = txHwQueue_Create (hOs); + if (pTWD->hTxHwQueue == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE, "TWD txHwQueue_Create failed!!!\n"); + WLAN_OS_REPORT(("TWD txHwQueue_Create failed!!!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + pTWD->hHwInit = hwInit_Create (hOs); + if (pTWD->hHwInit == NULL) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"wInit_Create failed!\n"); + WLAN_OS_REPORT (("wInit_Create failed!\n")); + TWD_Destroy ((TI_HANDLE)pTWD); + return NULL; + } + + WLAN_INIT_REPORT (("TWD_Create: CREATED !!!\n")); + + return (TI_HANDLE)pTWD; +} + +TI_STATUS TWD_Destroy (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + WLAN_INIT_REPORT(("TWD_Destroy: called\n")); + if (pTWD == NULL) + { + return TI_NOK; + } + + if (pTWD->hTwIf != NULL) + { + twIf_Destroy (pTWD->hTwIf); + pTWD->hTwIf = NULL; + } + + /* Free the Command Builder */ + if (pTWD->hCmdBld != NULL) + { + cmdBld_Destroy (pTWD->hCmdBld); + pTWD->hCmdBld = NULL; + } + WLAN_INIT_REPORT(("TWD_Destroy: Command Builder released\n")); + + /* Free the MAC Services */ + if (pTWD->hMacServices != NULL) + { + MacServices_destroy(pTWD->hMacServices); + pTWD->hMacServices = NULL; + } + WLAN_INIT_REPORT(("TWD_Destroy: Mac Services released\n")); + + /* + * Free the Ctrl modules + */ + if (pTWD->hCmdQueue != NULL) + { + cmdQueue_Destroy(pTWD->hCmdQueue); + pTWD->hCmdQueue = NULL; + } + + /* + * Free the FW-Transfer modules: + */ + if (pTWD->hTxXfer != NULL) + { + txXfer_Destroy (pTWD->hTxXfer); + pTWD->hTxXfer = NULL; + } + + if (pTWD->hTxResult != NULL) + { + txResult_Destroy (pTWD->hTxResult); + pTWD->hTxResult = NULL; + } + + if (pTWD->hRxXfer != NULL) + { + rxXfer_Destroy (pTWD->hRxXfer); + pTWD->hRxXfer = NULL; + } + + if (pTWD->hEventMbox != NULL) + { + eventMbox_Destroy (pTWD->hEventMbox); + pTWD->hEventMbox = NULL; + } + +#ifdef TI_DBG + if (pTWD->hFwDbg != NULL) + { + fwDbg_Destroy (pTWD->hFwDbg); + pTWD->hFwDbg = NULL; + } +#endif /* TI_DBG */ + + if (pTWD->hFwEvent != NULL) + { + fwEvent_Destroy (pTWD->hFwEvent); + pTWD->hFwEvent = NULL; + } + + if (pTWD->hCmdMbox != NULL) + { + cmdMbox_Destroy (pTWD->hCmdMbox); + pTWD->hCmdMbox = NULL; + } + + if (pTWD->hRxQueue != NULL) + { + RxQueue_Destroy (pTWD->hRxQueue); + pTWD->hRxQueue = NULL; + } + + /* + * Free the Data-Services modules: + */ + + if (pTWD->hTxCtrlBlk != NULL) + { + txCtrlBlk_Destroy (pTWD->hTxCtrlBlk); + pTWD->hTxCtrlBlk = NULL; + } + + if (pTWD->hTxHwQueue != NULL) + { + txHwQueue_Destroy (pTWD->hTxHwQueue); + pTWD->hTxHwQueue = NULL; + } + + if (pTWD->hHwInit != NULL) + { + hwInit_Destroy (pTWD->hHwInit); + pTWD->hHwInit = NULL; + } + + os_memoryFree (pTWD->hOs, (TI_HANDLE)pTWD, sizeof(TTwd)); + + WLAN_INIT_REPORT(("TWD_Destroy pTNETW_Driver released!!!\n")); + + return TI_OK; +} + + +/** + * \brief HW Init Callback + * + * \param hTWD - TWD module object handle + * \return void + * + * \par Description + * Static CB function + * Called during TWD Module Init by hwInit_Init in order to complete the HW Configuration init + * + * \sa TWD_InitHw + */ +static void TWD_InitHwCb (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_InitHwCb: call fInitHwCb CB. In std drvMain_InitHwCb()\n"); + + hwInit_InitPolarity(pTWD->hHwInit); + +} + +void TWD_Init (TI_HANDLE hTWD, + TI_HANDLE hReport, + TI_HANDLE hUser, + TI_HANDLE hTimer, + TI_HANDLE hContext, + TI_HANDLE hTxnQ, + TTwdCallback fInitHwCb, + TTwdCallback fInitFwCb, + TTwdCallback fConfigFwCb, + TTwdCallback fStopCb, + TTwdCallback fInitFailCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + pTWD->bInitSuccess = TI_FALSE; + pTWD->bRecoveryEnabled = TI_FALSE; + pTWD->hReport = hReport; + pTWD->hUser = hUser; + pTWD->hTimer = hTimer; + pTWD->hContext = hContext; + pTWD->hTxnQ = hTxnQ; + pTWD->fInitHwCb = fInitHwCb; + pTWD->fInitFwCb = fInitFwCb; + pTWD->fConfigFwCb = fConfigFwCb; + pTWD->fStopCb = fStopCb; + pTWD->fInitFailCb = fInitFailCb; + + TRACE1(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_Init: %x\n", hTWD); + + /* FwEvent should be configured first */ + fwEvent_Init (pTWD->hFwEvent, hTWD); + + eventMbox_Config (pTWD->hEventMbox, pTWD->hTwIf, pTWD->hReport, pTWD->hFwEvent, pTWD->hCmdBld); + + cmdQueue_Init (pTWD->hCmdQueue, + pTWD->hCmdMbox, + pTWD->hReport, + pTWD->hTwIf, + pTWD->hTimer); + + /* Configure Command Builder */ + cmdBld_Config (pTWD->hCmdBld, + pTWD->hReport, + (void *)TWD_FinalizeDownload, + hTWD, + pTWD->hEventMbox, + pTWD->hCmdQueue, + pTWD->hTwIf); + + hwInit_Init (pTWD->hHwInit, + pTWD->hReport, + hTWD, + hTWD, + (TFinalizeCb)TWD_FinalizeDownload, + TWD_InitHwCb); + + /* + * Initialize the FW-Transfer modules + */ + txXfer_Init (pTWD->hTxXfer, pTWD->hReport, pTWD->hTwIf); + + txResult_Init (pTWD->hTxResult, pTWD->hReport, pTWD->hTwIf); + + rxXfer_Init (pTWD->hRxXfer, pTWD->hFwEvent, pTWD->hReport, pTWD->hTwIf, pTWD->hRxQueue); + + RxQueue_Init (pTWD->hRxQueue, pTWD->hReport); + + #ifdef TI_DBG + fwDbg_Init (pTWD->hFwDbg, pTWD->hReport, pTWD->hTwIf); + #endif /* TI_DBG */ + + /* Initialize the MAC Services */ + MacServices_init (pTWD->hMacServices, + pTWD->hReport, + hTWD, + pTWD->hCmdBld, + pTWD->hEventMbox, + pTWD->hTimer); + + /* + * Initialize the Data-Services modules + */ + txCtrlBlk_Init (pTWD->hTxCtrlBlk, pTWD->hReport, pTWD->hContext); + txHwQueue_Init (pTWD->hTxHwQueue, pTWD->hReport); + + /* Initialize the TwIf module */ + twIf_Init (pTWD->hTwIf, pTWD->hReport, pTWD->hContext, pTWD->hTxnQ, (TRecoveryCb)TWD_StopComplete, hTWD); +} + + TI_STATUS TWD_InitHw (TI_HANDLE hTWD, + TI_UINT8 *pbuf, + TI_UINT32 length) +{ + TTwd *pTWD = (TTwd *)hTWD; + TI_STATUS eStatus; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_InitHw: called\n"); + + hwInit_SetNvsImage (pTWD->hHwInit, pbuf, length); + + /* + * Update the TwIf that the HW is awake + * This will protect the initialization process from going to sleep + * After the firmware initializations completed (TWD_EnableExternalEvents), the sleep will be enabled + */ + twIf_Awake (pTWD->hTwIf); + twIf_HwAvailable (pTWD->hTwIf); + + /* This initiates the HW init sequence */ + eStatus = hwInit_Boot(pTWD->hHwInit); + if (eStatus == TXN_STATUS_ERROR) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR , "TWD_InitHw: hwInit_Boot failed\n"); + return TI_NOK; + } + + return TI_OK; +} + +TI_STATUS TWD_BusOpen (TI_HANDLE hTWD, void* pParams) +{ + TTwd *pTWD = (TTwd *)hTWD; + TI_STATUS uStatus; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_BusOpen: called\n"); + + /*uStatus = TNETWIF_Open(pTWD->hTNETWIF, pParams);*/ + uStatus = TI_OK; + + return uStatus; +} + +TI_STATUS TWD_BusClose (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + TI_STATUS uStatus; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_BusClose: called\n"); + + /*uStatus = TNETWIF_Close(pTWD->hTNETWIF);*/ + uStatus = TI_OK; + + return uStatus; +} + +TI_STATUS TWD_InitFw (TI_HANDLE hTWD, TFileInfo *pFileInfo) +{ + TTwd *pTWD = (TTwd *)hTWD; + TI_STATUS status; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_InitFw: called\n"); + + /* check Parameters */ + if (( pTWD == NULL ) || ( pFileInfo == NULL )) + { + return (TI_NOK); + } + + hwInit_SetFwImage (pTWD->hHwInit, pFileInfo); + + /* This will initiate the download to the FW */ + status = hwInit_LoadFw(pTWD->hHwInit); + + if (status == TXN_STATUS_ERROR) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR , "TWD_InitFw: failed to initialize FW\n"); + + return TI_NOK; + } + + return TI_OK; +} + +/** + * \brief Propagate interrogate results + * + * \param hTWD - TWD module object handle + * \param status - callback status + * \return TI_OK on success or TI_NOK on failure + * + * \par Description + * Static CB function + * Propagate interrogate results between TX and RX modules + * Called by TWD_ConfigFw + * + * \sa + */ +static TI_STATUS TWD_ConfigFwCb (TI_HANDLE hTWD, TI_STATUS status) +{ + TTwd *pTWD = (TTwd *)hTWD; + TDmaParams *pDmaParams = &DB_DMA(pTWD->hCmdBld); + + /* + * Store the addresses of the cyclic buffer (Rx/Tx) + * and the path status and control (Tx/Rx) in the corresponding modules + */ + txResult_setHwInfo (pTWD->hTxResult, pDmaParams); + + RxXfer_ReStart (pTWD->hRxXfer); + txXfer_Restart (pTWD->hTxXfer); + + rxXfer_SetRxDirectAccessParams (pTWD->hRxXfer, pDmaParams); + + /* Provide number of HW Tx-blocks and descriptors to Tx-HW-Queue module */ + txHwQueue_SetHwInfo (pTWD->hTxHwQueue, pDmaParams); + + /* If the configure complete function was registered, we call it here - end of TWD_Configure stage */ + if (pTWD->fConfigFwCb) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_ConfigFwCb: call TWD_OWNER_SELF_CONFIG CB. In std drvMain_ConfigFwCb()\n"); + + pTWD->fConfigFwCb (pTWD->hUser, TI_OK); + } + + return TI_OK; +} + + +TI_STATUS TWD_SetDefaults (TI_HANDLE hTWD, TTwdInitParams *pInitParams) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TWlanParams *pWlanParams = &DB_WLAN(pTWD->hCmdBld); + TKeepAliveList *pKlvParams = &DB_KLV(pTWD->hCmdBld); + IniFileRadioParam *pRadioParams = &DB_RADIO(pTWD->hCmdBld); + IniFileGeneralParam *pGenParams = &DB_GEN(pTWD->hCmdBld); + TRateMngParams *pRateMngParams = &DB_RM(pTWD->hCmdBld); + TSmartReflexParams *pSmartReflex = &DB_SR(pTWD->hCmdBld); + TI_UINT32 k, uIndex; + int iParam; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_SetDefaults: called\n"); + + pTWD->bRecoveryEnabled = pInitParams->tGeneral.halCtrlRecoveryEnable; + + pWlanParams->PacketDetectionThreshold = pInitParams->tGeneral.packetDetectionThreshold; + pWlanParams->qosNullDataTemplateSize = pInitParams->tGeneral.qosNullDataTemplateSize; + pWlanParams->PsPollTemplateSize = pInitParams->tGeneral.PsPollTemplateSize; + pWlanParams->probeResponseTemplateSize = pInitParams->tGeneral.probeResponseTemplateSize; + pWlanParams->probeRequestTemplateSize = pInitParams->tGeneral.probeRequestTemplateSize; + pWlanParams->beaconTemplateSize = pInitParams->tGeneral.beaconTemplateSize; + pWlanParams->nullTemplateSize = pInitParams->tGeneral.nullTemplateSize; + pWlanParams->disconnTemplateSize = pInitParams->tGeneral.disconnTemplateSize; + /* Beacon broadcast options */ + pWlanParams->BcnBrcOptions.BeaconRxTimeout = pInitParams->tGeneral.BeaconRxTimeout; + pWlanParams->BcnBrcOptions.BroadcastRxTimeout = pInitParams->tGeneral.BroadcastRxTimeout; + pWlanParams->BcnBrcOptions.RxBroadcastInPs = pInitParams->tGeneral.RxBroadcastInPs; + pWlanParams->ConsecutivePsPollDeliveryFailureThreshold = pInitParams->tGeneral.ConsecutivePsPollDeliveryFailureThreshold; + + pWlanParams->RxDisableBroadcast = pInitParams->tGeneral.halCtrlRxDisableBroadcast; + pWlanParams->calibrationChannel2_4 = pInitParams->tGeneral.halCtrlCalibrationChannel2_4; + pWlanParams->calibrationChannel5_0 = pInitParams->tGeneral.halCtrlCalibrationChannel5_0; + + /* Not used but need by Palau */ + pWlanParams->RtsThreshold = pInitParams->tGeneral.halCtrlRtsThreshold; + pWlanParams->CtsToSelf = CTS_TO_SELF_DISABLE; + + pWlanParams->WiFiWmmPS = pInitParams->tGeneral.WiFiWmmPS; + + pWlanParams->MaxTxMsduLifetime = pInitParams->tGeneral.halCtrlMaxTxMsduLifetime; + pWlanParams->MaxRxMsduLifetime = pInitParams->tGeneral.halCtrlMaxRxMsduLifetime; + + pWlanParams->rxTimeOut.psPoll = pInitParams->tGeneral.rxTimeOut.psPoll; + pWlanParams->rxTimeOut.UPSD = pInitParams->tGeneral.rxTimeOut.UPSD; + + /* RSSI/SNR Weights for Average calculations */ + pWlanParams->tRssiSnrWeights.rssiBeaconAverageWeight = pInitParams->tGeneral.uRssiBeaconAverageWeight; + pWlanParams->tRssiSnrWeights.rssiPacketAverageWeight = pInitParams->tGeneral.uRssiPacketAverageWeight; + pWlanParams->tRssiSnrWeights.snrBeaconAverageWeight = pInitParams->tGeneral.uSnrBeaconAverageWeight ; + pWlanParams->tRssiSnrWeights.snrPacketAverageWeight = pInitParams->tGeneral.uSnrPacketAverageWeight ; + + /* PM config params */ + pWlanParams->uHostClkSettlingTime = pInitParams->tGeneral.uHostClkSettlingTime; + pWlanParams->uHostFastWakeupSupport = pInitParams->tGeneral.uHostFastWakeupSupport; + + /* No used */ + pWlanParams->FragmentThreshold = pInitParams->tGeneral.halCtrlFragThreshold; + pWlanParams->ListenInterval = (TI_UINT8)pInitParams->tGeneral.halCtrlListenInterval; + pWlanParams->RateFallback = pInitParams->tGeneral.halCtrlRateFallbackRetry; + pWlanParams->MacClock = pInitParams->tGeneral.halCtrlMacClock; + pWlanParams->ArmClock = pInitParams->tGeneral.halCtrlArmClock; + + /* Data interrupts pacing */ + pWlanParams->TxCompletePacingThreshold = pInitParams->tGeneral.TxCompletePacingThreshold; + pWlanParams->TxCompletePacingTimeout = pInitParams->tGeneral.TxCompletePacingTimeout; + pWlanParams->RxIntrPacingThreshold = pInitParams->tGeneral.RxIntrPacingThreshold; + pWlanParams->RxIntrPacingTimeout = pInitParams->tGeneral.RxIntrPacingTimeout; + + /* Configure ARP IP */ + + pWlanParams->isArpIpFilteringEnabled = pInitParams->tArpIpFilter.isFilterEnabled; + IP_COPY (pWlanParams->arp_IP_addr, pInitParams->tArpIpFilter.addr); + + /* Configure address group */ + pWlanParams->numGroupAddrs = pInitParams->tMacAddrFilter.numOfMacAddresses; + pWlanParams->isMacAddrFilteringnabled = pInitParams->tMacAddrFilter.isFilterEnabled; + + for (k = 0; k < pWlanParams->numGroupAddrs; k++) + { + MAC_COPY (pWlanParams->aGroupAddr[k], pInitParams->tMacAddrFilter.macAddrTable[k]); + } + + + /* CoexActivity Table */ + TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetDefaults: coex numOfElements %d\n", pInitParams->tGeneral.halCoexActivityTable.numOfElements); + + pWlanParams->tWlanParamsCoexActivityTable.numOfElements = 0; + for (iParam=0; iParam < (int)pInitParams->tGeneral.halCoexActivityTable.numOfElements; iParam++) + { + TCoexActivity *pSaveCoex = &pWlanParams->tWlanParamsCoexActivityTable.entry[0]; + TCoexActivity *pParmCoex = &pInitParams->tGeneral.halCoexActivityTable.entry[0]; + int i, saveIndex; + + /* Check if to overwrite existing entry or put on last index */ + for (i=0; itWlanParamsCoexActivityTable.numOfElements; + pWlanParams->tWlanParamsCoexActivityTable.numOfElements++; + } + else + { + /* overwrite existing */ + saveIndex = i; + } + + TRACE4(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetDefaults: save coex Param %d in index %d, %d %d\n", iParam, saveIndex, pParmCoex[iParam].coexIp, pParmCoex[iParam].activityId); + + pSaveCoex[saveIndex].coexIp = pParmCoex[iParam].coexIp; + pSaveCoex[saveIndex].activityId = pParmCoex[iParam].activityId; + pSaveCoex[saveIndex].defaultPriority = pParmCoex[iParam].defaultPriority; + pSaveCoex[saveIndex].raisedPriority = pParmCoex[iParam].raisedPriority; + pSaveCoex[saveIndex].minService = pParmCoex[iParam].minService; + pSaveCoex[saveIndex].maxService = pParmCoex[iParam].maxService; + } + + /* configure keep-alive default mode to enabled */ + pKlvParams->enaDisFlag = TI_TRUE; + for (uIndex = 0; uIndex < KLV_MAX_TMPL_NUM; uIndex++) + { + pKlvParams->keepAliveParams[ uIndex ].enaDisFlag = TI_FALSE; + } + + /* Configure the Tx-HW-Queue module */ + txHwQueue_Config (pTWD->hTxHwQueue, pInitParams); + + /* Configure the MAC services */ + MacServices_config (pTWD->hMacServices, pInitParams); + + /* + * 802.11n + */ + pWlanParams->tTwdHtCapabilities.b11nEnable = pInitParams->tGeneral.b11nEnable; + /* Configure HT capabilities setting */ + pWlanParams->tTwdHtCapabilities.uChannelWidth = CHANNEL_WIDTH_20MHZ; + pWlanParams->tTwdHtCapabilities.uRxSTBC = RXSTBC_SUPPORTED_ONE_SPATIAL_STREAM; + pWlanParams->tTwdHtCapabilities.uMaxAMSDU = MAX_MSDU_3839_OCTETS; + pWlanParams->tTwdHtCapabilities.uMaxAMPDU = MAX_MPDU_8191_OCTETS; + pWlanParams->tTwdHtCapabilities.uAMPDUSpacing = AMPDU_SPC_16_MICROSECONDS; + pWlanParams->tTwdHtCapabilities.aRxMCS[0] = (MCS_SUPPORT_MCS_0 | + MCS_SUPPORT_MCS_1 | + MCS_SUPPORT_MCS_2 | + MCS_SUPPORT_MCS_3 | + MCS_SUPPORT_MCS_4 | + MCS_SUPPORT_MCS_5 | + MCS_SUPPORT_MCS_6 | + MCS_SUPPORT_MCS_7); + os_memoryZero (pTWD->hOs, pWlanParams->tTwdHtCapabilities.aRxMCS + 1, RX_TX_MCS_BITMASK_SIZE - 1); + pWlanParams->tTwdHtCapabilities.aTxMCS[0] = (MCS_SUPPORT_MCS_0 | + MCS_SUPPORT_MCS_1 | + MCS_SUPPORT_MCS_2 | + MCS_SUPPORT_MCS_3 | + MCS_SUPPORT_MCS_4 | + MCS_SUPPORT_MCS_5 | + MCS_SUPPORT_MCS_6 | + MCS_SUPPORT_MCS_7); + os_memoryZero (pTWD->hOs, pWlanParams->tTwdHtCapabilities.aTxMCS + 1, RX_TX_MCS_BITMASK_SIZE - 1); + pWlanParams->tTwdHtCapabilities.uRxMaxDataRate = MCS_HIGHEST_SUPPORTED_RECEPTION_DATA_RATE_IN_MBIT_S; + pWlanParams->tTwdHtCapabilities.uPCOTransTime = PCO_TRANS_TIME_NO_TRANSITION; + pWlanParams->tTwdHtCapabilities.uHTCapabilitiesBitMask = (CAP_BIT_MASK_GREENFIELD_FRAME_FORMAT | + CAP_BIT_MASK_SHORT_GI_FOR_20MHZ_PACKETS); + pWlanParams->tTwdHtCapabilities.uMCSFeedback = MCS_FEEDBACK_NO; + + os_memoryCopy(pTWD->hOs, (void*)pRadioParams, (void*)&pInitParams->tIniFileRadioParams, sizeof(IniFileRadioParam)); + os_memoryCopy(pTWD->hOs, (void*)pGenParams, (void*)&pInitParams->tPlatformGenParams, sizeof(IniFileGeneralParam)); + + os_memoryCopy (pTWD->hOs, + (void*)&(pWlanParams->tFmCoexParams), + (void*)&(pInitParams->tGeneral.tFmCoexParams), + sizeof(TFmCoexParams)); + + /* Rate management params */ + pRateMngParams->rateMngParams.InverseCuriosityFactor[0] = pInitParams->tRateMngParams.InverseCuriosityFactor[0]; + pRateMngParams->rateMngParams.InverseCuriosityFactor[1] = pInitParams->tRateMngParams.InverseCuriosityFactor[1]; + pRateMngParams->rateMngParams.MaxPer = pInitParams->tRateMngParams.MaxPer; + pRateMngParams->rateMngParams.PerAdd = pInitParams->tRateMngParams.PerAdd; + pRateMngParams->rateMngParams.PerAddShift = pInitParams->tRateMngParams.PerAddShift; + pRateMngParams->rateMngParams.PerAlphaShift = pInitParams->tRateMngParams.PerAlphaShift; + pRateMngParams->rateMngParams.PerBeta1Shift = pInitParams->tRateMngParams.PerBeta1Shift; + pRateMngParams->rateMngParams.PerBeta2Shift = pInitParams->tRateMngParams.PerBeta2Shift; + pRateMngParams->rateMngParams.PerTh1 = pInitParams->tRateMngParams.PerTh1; + pRateMngParams->rateMngParams.PerTh2 = pInitParams->tRateMngParams.PerTh2; + pRateMngParams->rateMngParams.RateCheckDown = pInitParams->tRateMngParams.RateCheckDown; + pRateMngParams->rateMngParams.RateCheckUp = pInitParams->tRateMngParams.RateCheckUp; + /* RATE_MNG_MAX_RETRY_POLICY_PARAMS_LEN */ + for (uIndex = 0; uIndex < 13; uIndex++) + { + pRateMngParams->rateMngParams.RateRetryPolicy[uIndex] = pInitParams->tRateMngParams.RateRetryPolicy[uIndex]; + } + pRateMngParams->rateMngParams.RateRetryScore = pInitParams->tRateMngParams.RateRetryScore; + pRateMngParams->rateMngParams.TxFailHighTh = pInitParams->tRateMngParams.TxFailHighTh; + pRateMngParams->rateMngParams.TxFailLowTh = pInitParams->tRateMngParams.TxFailLowTh; + pRateMngParams->rateMngParams.PerWeightShift[0] = pInitParams->tRateMngParams.PerWeightShift[0]; + pRateMngParams->rateMngParams.PerWeightShift[1] = pInitParams->tRateMngParams.PerWeightShift[1]; + pRateMngParams->rateMngParams.TpWeightShift[0] = pInitParams->tRateMngParams.TpWeightShift[0]; + pRateMngParams->rateMngParams.TpWeightShift[1] = pInitParams->tRateMngParams.TpWeightShift[1]; + + /* DCO Itrim params */ + pWlanParams->dcoItrimEnabled = pInitParams->tDcoItrimParams.enable; + pWlanParams->dcoItrimModerationTimeoutUsec = pInitParams->tDcoItrimParams.moderationTimeoutUsec; + + /* + * Updating uSwallowPeriod depending on Fref: + * if Fref 26, 52 then uSwallowPeriod = 5 + * Else use default. + */ + if (((pGenParams->RefClk & FREF_CLK_FREQ_MASK) == 1) || ((pGenParams->RefClk & FREF_CLK_FREQ_MASK) == 3)) + { + pWlanParams->tFmCoexParams.uSwallowPeriod = 5; + } + + pSmartReflex->tSmartReflexState = pInitParams->tSmartReflexState; + os_memoryCopy(pTWD->hOs, (void*)&pSmartReflex->tSmartReflexParams, (void*)&pInitParams->tSmartReflexParams, sizeof(ACXSmartReflexConfigParams_t)); + os_memoryCopy(pTWD->hOs, (void*)&pSmartReflex->tSmartReflexDebugParams, (void*)&pInitParams->tSmartReflexDebugParams, sizeof(ACXSmartReflexDebugParams_t)); + + return TI_OK; +} + + +TI_STATUS TWD_ConfigFw (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_ConfigFw: called\n"); + + /* + * Configure the WLAN firmware after config all the hardware objects + */ + if (cmdBld_ConfigFw (pTWD->hCmdBld, (void *)TWD_ConfigFwCb, hTWD) != TI_OK) + { + return TI_NOK; + } + + return TI_OK; +} + +void TWD_FinalizeDownload (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT , "TWD_FinalizeDownload: called\n"); + + if ( pTWD == NULL ) + { + return; + } + /* Here at the end call the Initialize Complete callback that will release the user Init semaphore */ + TRACE0(pTWD->hReport, REPORT_SEVERITY_INIT, "Before sending the Init Complet callback !!!!!\n"); + + /* Sign that init has succeeded */ + pTWD->bInitSuccess = TI_TRUE; + + /* Call user application configuration callback */ + if (pTWD->fInitFwCb) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_FinalizeDownload: call fInitFwCb CB. In std drvMain_InitFwCb()\n"); + + (*pTWD->fInitFwCb) (pTWD->hUser, TI_OK); + } +} + +void TWD_FinalizeOnFailure (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_FinalizeOnFailure: called\n"); + + /* Call the upper layer callback for init failure case */ + if (pTWD->fInitFailCb) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_FinalizeOnFailure: call fInitFailCb CB. In std drvMain_InitFailCb()\n"); + + pTWD->fInitFailCb (pTWD->hUser, TI_OK); + } +} + +TI_STATUS TWD_CheckMailboxCb (TI_HANDLE hTWD, TI_UINT16 uMboxStatus, void *pItrParamBuf) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CheckMailboxCb: called\n"); + + if (uMboxStatus != TI_OK) + { + ++pTWD->uNumMboxFailures; + TRACE1(pTWD->hReport, REPORT_SEVERITY_WARNING, "TWD_CheckMailboxCb: Periodic intorregate check - Command mailbox failure was occur \n errors failure # %d", pTWD->uNumMboxFailures); + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_CheckMailboxCb: call TWD_INT_EVENT_FAILURE CB. In std healthMonitor_sendFailureEvent()\n"); + + /* Indicating Upper Layer about Mbox Error */ + pTWD->fFailureEventCb (pTWD->hFailureEventCb, MBOX_FAILURE); + } + + return TI_OK; +} +#ifdef RS_OVER_TWD +extern void (*gBusTxn_ErrorCb)(TI_HANDLE , int); +extern void *gBusTxn_ErrorHndle; +#endif + +/** + * \brief Registers TWD Module Callbacks + * + * \param hTWD - TWD module object handle + * \param uCallBackID - Registered Callback ID + * \param fCb - Pointer to Input Registered CB function + * \param hCb - Handle to Input Registered CB parameters + * \return void + * + * \par Description + * Static CB function + * This CB Registers TWD CB functions for future use: + * CB which handles failure to the CMD Queue, MAC Service and TwIf + * CB which handles Command Complete for the CMD Queue + * Called by TWD_RegisterCb + * + * \sa TWD_RegisterCb + */ +static void TWD_RegisterOwnCb (TI_HANDLE hTWD, TI_UINT32 uCallBackID, void *fCb, TI_HANDLE hCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_RegisterOwnCB: callback ID=0x%x\n", uCallBackID); + + switch (uCallBackID) + { + case TWD_INT_EVENT_FAILURE: + /* Save Health-Moitor callback */ + pTWD->fFailureEventCb = (TFailureEventCb)fCb; + pTWD->hFailureEventCb = hCb; + + /* Register For Error Of Mailbox in case of timeout */ + cmdQueue_RegisterForErrorCb (pTWD->hCmdQueue, (void *)TWD_CheckMailboxCb, hTWD); + + /* Forward the Health-Moitor callback to the MAC-Services modules */ + MacServices_registerFailureEventCB(pTWD->hMacServices, fCb, hCb); + + /* Forward the Health-Moitor callback to the TwIf for bus errors */ + twIf_RegisterErrCb (pTWD->hTwIf, fCb, hCb); + break; + + case TWD_INT_COMMAND_COMPLETE: + cmdQueue_RegisterCmdCompleteGenericCb (pTWD->hCmdQueue, fCb, hCb); + break; + + default: + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_RegisterOwnCb - Illegal value\n"); + } +} + +TI_STATUS TWD_RegisterCb (TI_HANDLE hTWD, TI_UINT32 event, TTwdCB *fCb, void *pData) +{ + TTwd *pTWD = (TTwd *)hTWD; + TI_UINT32 uModuleId = event & TWD_CB_MODULE_OWNER_MASK; + TI_UINT32 uCallbackId = event & TWD_CB_TYPE_MASK; + + if ((fCb == NULL) || (pData == NULL)) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_Register_CB: Invalid NULL Parameter\n"); + } + + TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: (Value = 0x%x)\n", event); + + /* First detect which module is the owner */ + + switch (uModuleId) + { + case TWD_OWNER_TX_HW_QUEUE: + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_TX_HW_QUEUE\n"); + txHwQueue_RegisterCb (pTWD->hTxHwQueue, uCallbackId, fCb, pData); + break; + + case TWD_OWNER_DRIVER_TX_XFER: + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_DRIVER_TX_XFER\n"); + txXfer_RegisterCb (pTWD->hTxXfer, uCallbackId, fCb, pData); + break; + + case TWD_OWNER_TX_RESULT: + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_TX_RESULT\n"); + txResult_RegisterCb (pTWD->hTxResult, uCallbackId, fCb, pData); + break; + + case TWD_OWNER_RX_XFER: + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_RX_XFER\n"); + rxXfer_Register_CB(pTWD->hRxXfer, uCallbackId, fCb, pData); + break; + + case TWD_OWNER_RX_QUEUE: + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_RX_QUEUE\n"); + RxQueue_Register_CB(pTWD->hRxQueue, uCallbackId, fCb, pData); + break; + + case TWD_OWNER_SELF: + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_SELF\n"); + TWD_RegisterOwnCb (hTWD, uCallbackId, fCb, pData); + break; + + case TWD_OWNER_MAC_SERVICES: + switch (uCallbackId) + { + case TWD_OWN_EVENT_SCAN_CMPLT: + MacServices_scanSRV_registerScanCompleteCB (pTWD->hMacServices, (TScanSrvCompleteCb)fCb, pData); + break; + default: + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_Register_CB: TWD_OWNER_MAC_SERVICES - Illegal value\n"); + } + break; + + case TWD_OWNER_SELF_CONFIG: + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_Register_CB: TWD_OWNER_SELF_CONFIG\n"); + pTWD->fConfigFwCb = (TTwdCallback)fCb; + break; + + default: + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_Register_CB - Illegal value\n"); + } + + return TI_OK; +} + +TI_STATUS TWD_ExitFromInitMode (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_ExitFromInitMode: called\n"); + + /* Notify Event MailBox about init complete */ + eventMbox_InitComplete (pTWD->hEventMbox); + + /* Enable Mailbox */ + cmdQueue_EnableMbox (pTWD->hCmdQueue); + + return TI_OK; +} + + +#ifdef TI_DBG +TI_STATUS TWD_PrintTxInfo (TI_HANDLE hTWD, ETwdPrintInfoType ePrintInfo) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_PrintTxInfo: called\n"); + + switch (ePrintInfo) + { + case TWD_PRINT_TX_CTRL_BLK_TBL: + txCtrlBlk_PrintTable (pTWD->hTxCtrlBlk); + break; + + case TWD_PRINT_TX_HW_QUEUE_INFO: + txHwQueue_PrintInfo (pTWD->hTxHwQueue); + break; + + case TWD_PRINT_TX_XFER_INFO: + TRACE0(pTWD->hReport, REPORT_SEVERITY_CONSOLE,"No TxXfer information to show\n"); + WLAN_OS_REPORT(("No TxXfer information to show\n")); + break; + + case TWD_PRINT_TX_RESULT_INFO: + txResult_PrintInfo (pTWD->hTxResult); + break; + + case TWD_CLEAR_TX_RESULT_INFO: + txResult_ClearInfo (pTWD->hTxResult); + break; + + default: + TRACE1(pTWD->hReport, REPORT_SEVERITY_ERROR, ": invalid print info request code: %d\n", ePrintInfo); + } + + return TI_OK; +} + +#endif /* TI_DBG */ + +TI_STATUS TWD_InterruptRequest (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_InterruptRequest: called\n"); + + fwEvent_InterruptRequest (pTWD->hFwEvent); + + return TI_OK; +} + +TI_STATUS TWD_RegisterEvent (TI_HANDLE hTWD, TI_UINT32 event, void *fCb, TI_HANDLE hCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_RegisterEvent: called\n"); + + return eventMbox_RegisterEvent (pTWD->hEventMbox, event, fCb, hCb); +} + +TI_STATUS TWD_DisableEvent (TI_HANDLE hTWD, TI_UINT32 event) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_DisableEvent: called\n"); + + return eventMbox_MaskEvent (pTWD->hEventMbox, event, NULL, NULL); +} + +TI_STATUS TWD_EnableEvent (TI_HANDLE hTWD, TI_UINT32 event) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_EnableEvent: called\n"); + + return eventMbox_UnMaskEvent (pTWD->hEventMbox, event, NULL, NULL); +} + +void TWD_StopComplete (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopComplete: called\n"); + + + /* reinit last ELP mode flag in recovery */ + cmdBld_Restart(pTWD->hCmdBld); + + /* Call upper layer callback */ + if (pTWD->fStopCb) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopComplete: call fStopCb CB. In std drvMain_TwdStopCb()\n"); + + (*pTWD->fStopCb) (pTWD->hUser, TI_OK); + } +} + +TI_STATUS TWD_Stop (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + ETxnStatus status; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_Stop: called\n"); + + fwEvent_Stop (pTWD->hFwEvent); + + + /* close all BA sessions */ + TWD_CloseAllBaSessions(hTWD); + + cmdMbox_Restart (pTWD->hCmdMbox); + cmdQueue_Restart (pTWD->hCmdQueue); + cmdQueue_DisableMbox (pTWD->hCmdQueue); + eventMbox_Stop (pTWD->hEventMbox); + MacServices_restart (pTWD->hMacServices); + + status = twIf_Restart(pTWD->hTwIf); + + /* Call user stop callback */ + if (status != TXN_STATUS_PENDING) + { + TWD_StopComplete (hTWD); + } + + return TI_OK; +} + +void TWD_EnableExternalEvents (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_EnableExternalEvents: called\n"); + + /* + * Enable sleep after all firmware initializations completed + * The awake was in the TWD_initHw phase + */ + twIf_Sleep (pTWD->hTwIf); + + fwEvent_EnableExternalEvents (pTWD->hFwEvent); +} + +TI_BOOL TWD_RecoveryEnabled (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_RecoveryEnabled: called\n"); + + return pTWD->bRecoveryEnabled; +} + +TI_UINT32 TWD_GetMaxNumberOfCommandsInQueue (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_GetMaxNumberOfCommandsInQueue: called\n"); + + return cmdQueue_GetMaxNumberOfCommands (pTWD->hCmdQueue); +} + +TI_STATUS TWD_SetPsMode (TI_HANDLE hTWD, + E80211PsMode ePsMode, + TI_BOOL bSendNullDataOnExit, + TI_HANDLE hPowerSaveCompleteCb, + TPowerSaveCompleteCb fPowerSaveCompleteCb, + TPowerSaveResponseCb fPowerSaveResponseCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetPsMode: called\n"); + + return MacServices_powerSrv_SetPsMode (pTWD->hMacServices, + ePsMode, + bSendNullDataOnExit, + hPowerSaveCompleteCb, + fPowerSaveCompleteCb, + fPowerSaveResponseCb); +} + +TI_BOOL TWD_GetPsStatus (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_GetPsStatus: called\n"); + + return MacServices_powerSrv_getPsStatus (pTWD->hMacServices); +} + +TI_STATUS TWD_SetNullRateModulation (TI_HANDLE hTWD, TI_UINT16 rate) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_SetRateModulation: called\n"); + + MacServices_powerSrv_SetRateModulation (pTWD->hMacServices, rate); + + return TI_OK; +} + +void TWD_UpdateDtimTbtt (TI_HANDLE hTWD, TI_UINT8 uDtimPeriod, TI_UINT16 uBeaconInterval) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_UpdateDtimTbtt: called\n"); + + MacServices_scanSrv_UpdateDtimTbtt (pTWD->hMacServices, uDtimPeriod, uBeaconInterval); +} + +TI_STATUS TWD_StartMeasurement (TI_HANDLE hTWD, + TMeasurementRequest *pMsrRequest, + TI_UINT32 uTimeToRequestExpiryMs, + TCmdResponseCb fResponseCb, + TI_HANDLE hResponseCb, + TMeasurementSrvCompleteCb fCompleteCb, + TI_HANDLE hCompleteCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StartMeasurement: called\n"); + + return MacServices_measurementSRV_startMeasurement (pTWD->hMacServices, + pMsrRequest, + uTimeToRequestExpiryMs, + fResponseCb, + hResponseCb, + fCompleteCb, + hCompleteCb); +} + +TI_STATUS TWD_StopMeasurement (TI_HANDLE hTWD, + TI_BOOL bSendNullData, + TCmdResponseCb fResponseCb, + TI_HANDLE hResponseCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopMeasurement: called\n"); + + return MacServices_measurementSRV_stopMeasurement (pTWD->hMacServices, + bSendNullData, + fResponseCb, + hResponseCb); +} + +TI_STATUS TWD_RegisterScanCompleteCb (TI_HANDLE hTWD, + TScanSrvCompleteCb fScanCompleteCb, + TI_HANDLE hScanCompleteCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_RegisterScanCompleteCb: called\n"); + + MacServices_scanSRV_registerScanCompleteCB (pTWD->hMacServices, + fScanCompleteCb, + hScanCompleteCb); + + return TI_OK; +} + +#ifdef TI_DBG +TI_STATUS TWD_PrintMacServDebugStatus (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_PrintMacServDebugStatus: called\n"); + + MacServices_scanSrv_printDebugStatus (pTWD->hMacServices); + + return TI_OK; +} +#endif + +TI_STATUS TWD_Scan (TI_HANDLE hTWD, + TScanParams *pScanParams, + EScanResultTag eScanTag, + TI_BOOL bHighPriority, + TI_BOOL bDriverMode, + TI_BOOL bScanOnDriverModeError, + E80211PsMode ePsRequest, + TI_BOOL bSendNullData, + TCmdResponseCb fResponseCb, + TI_HANDLE hResponseCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_Scan: called\n"); + + return MacServices_scanSRV_scan (pTWD->hMacServices, + pScanParams, + eScanTag, + bHighPriority, + bDriverMode, + bScanOnDriverModeError, + ePsRequest, + bSendNullData, + fResponseCb, + hResponseCb); +} + +TI_STATUS TWD_StopScan (TI_HANDLE hTWD, + EScanResultTag eScanTag, + TI_BOOL bSendNullData, + TCmdResponseCb fScanCommandResponseCb, + TI_HANDLE hCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopScan: called\n"); + + return MacServices_scanSRV_stopScan (pTWD->hMacServices, + eScanTag, + bSendNullData, + fScanCommandResponseCb, + hCb); +} + +TI_STATUS TWD_StopScanOnFWReset (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopScanOnFWReset: called\n"); + + return MacServices_scanSRV_stopOnFWReset (pTWD->hMacServices); +} + +TI_STATUS TWD_StartConnectionScan (TI_HANDLE hTWD, + TPeriodicScanParams *pPeriodicScanParams, + EScanResultTag eScanTag, + TI_UINT32 uPassiveScanDfsDwellTimeMs, + TCmdResponseCb fResponseCb, + TI_HANDLE hResponseCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StartConnectionScan: called\n"); + + return cmdBld_StartPeriodicScan (pTWD->hCmdBld, pPeriodicScanParams, eScanTag, uPassiveScanDfsDwellTimeMs, + (void*)fResponseCb, hResponseCb); +} + +TI_STATUS TWD_StopPeriodicScan (TI_HANDLE hTWD, + EScanResultTag eScanTag, + TCmdResponseCb fResponseCb, + TI_HANDLE hResponseCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_StopPeriodicScan: called\n"); + + return cmdBld_StopPeriodicScan (pTWD->hCmdBld, eScanTag, (void*)fResponseCb, hResponseCb); +} + +TI_STATUS TWD_readMem (TI_HANDLE hTWD, TFwDebugParams* pMemDebug, void* fCb, TI_HANDLE hCb) +{ + TTwd * hReport = ((TTwd *)hTWD)->hReport; + TRACE0(hReport, REPORT_SEVERITY_INFORMATION , "TWD_readMem: called\n"); + + if ((hTWD == NULL) || + (pMemDebug == NULL) ) + { + return (TI_NOK); + } + if (fwDbg_ReadAddr(((TTwd *)hTWD)->hFwDbg,pMemDebug->addr,pMemDebug->length,pMemDebug->UBuf.buf8,(TFwDubCallback)fCb,hCb) == TI_NOK) + { + TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_CONSOLE ,"TWD_readMem Error: fwDbg_handleCommand failed\n"); + WLAN_OS_REPORT(("TWD_readMem Error: fwDbg_handleCommand failed\n")); + return TI_NOK; + } + + return(TI_OK); +} + +TI_STATUS TWD_writeMem (TI_HANDLE hTWD, TFwDebugParams* pMemDebug, void* fCb, TI_HANDLE hCb) +{ + TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_INFORMATION , "TWD_writeMem: called\n"); + + if ((hTWD == NULL) || + (pMemDebug == NULL) ) + { + return (TI_NOK); + } + + if (fwDbg_WriteAddr(((TTwd *)hTWD)->hFwDbg,pMemDebug->addr,pMemDebug->length,pMemDebug->UBuf.buf8,(TFwDubCallback)fCb,hCb) == TI_NOK) + { + TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_CONSOLE ,"TWD_writeMem Error: fwDbg_handleCommand failed\n"); + WLAN_OS_REPORT(("TWD_writeMem Error: fwDbg_handleCommand failed\n")); + return TI_NOK; + } + + return(TI_OK); +} + +TI_BOOL TWD_isValidMemoryAddr (TI_HANDLE hTWD, TFwDebugParams* pMemDebug) +{ + TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_INFORMATION , "TWD_isValidMemoryAddr: called\n"); + + if ((hTWD == NULL) || + (pMemDebug == NULL) ) + { + return TI_FALSE; + } + + return fwDbg_isValidMemoryAddr(((TTwd *)hTWD)->hFwDbg,pMemDebug->addr,pMemDebug->length); +} + +TI_BOOL TWD_isValidRegAddr (TI_HANDLE hTWD, TFwDebugParams* pMemDebug) +{ + TRACE0(((TTwd *)hTWD)->hReport, REPORT_SEVERITY_INFORMATION , "TWD_isValidRegAddr: called\n"); + + if ((hTWD == NULL) || + (pMemDebug == NULL) ) + { + return TI_FALSE; + } + + return fwDbg_isValidRegAddr(((TTwd *)hTWD)->hFwDbg,pMemDebug->addr,pMemDebug->length); +} + +/** + * \brief Set Template Frame + * + * \param hTWD - TWD module object handle + * \param pMib - Pointer to Input MIB Structure + * \return TI_OK on success or TI_NOK on failure + * + * \par Description + * Static function + * Configure/Interrogate/Modulate the Frame Rate if needed (according to Templete Type) + * and then write the MIB TemplateFrame to the FW + * + * \sa + */ +static TI_STATUS TWD_WriteMibTemplateFrame (TI_HANDLE hTWD, TMib* pMib) +{ + TTwd *pTWD = (TTwd *)hTWD; + TSetTemplate tSetTemplate; + EHwRateBitFiled uHWRate; + TI_UINT32 uDrvRateMask = RATE_TO_MASK(pMib->aData.TemplateFrame.Rate); + + cmdBld_ConvertAppRatesBitmap (uDrvRateMask, 0, &uHWRate); + + /* + * Construct the template MIB element + */ + switch(pMib->aData.TemplateFrame.FrameType) + { + case TEMPLATE_TYPE_BEACON: + tSetTemplate.type = BEACON_TEMPLATE; + break; + + case TEMPLATE_TYPE_PROBE_REQUEST: + tSetTemplate.type = PROBE_REQUEST_TEMPLATE; + tSetTemplate.eBand = RADIO_BAND_2_4_GHZ; /* needed for GWSI, if so band must also be passed to choose correct template (G or A) */ + break; + + case TEMPLATE_TYPE_NULL_FRAME: + tSetTemplate.type = NULL_DATA_TEMPLATE; + MacServices_powerSrv_SetRateModulation (pTWD->hMacServices, (TI_UINT16)uDrvRateMask); + break; + + case TEMPLATE_TYPE_PROBE_RESPONSE: + tSetTemplate.type = PROBE_RESPONSE_TEMPLATE; + break; + + case TEMPLATE_TYPE_QOS_NULL_FRAME: + + if (IS_HT_FRAME(((dot11_header_t *)(pMib->aData.TemplateFrame.Data))->fc)) + { + pMib->aData.TemplateFrame.Data[1] = pMib->aData.TemplateFrame.Data[1] & 0x7F; + pMib->aData.TemplateFrame.Length = pMib->aData.TemplateFrame.Length - HT_CONTROL_SIZE; + } + tSetTemplate.type = QOS_NULL_DATA_TEMPLATE; + break; + + case TEMPLATE_TYPE_PS_POLL: + tSetTemplate.type = PS_POLL_TEMPLATE; + break; + + default: + TRACE1(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_WriteMibTemplateFrame - ERROR - template is not supported, %d\n", pMib->aData.TemplateFrame.FrameType); + return PARAM_NOT_SUPPORTED; + } + + tSetTemplate.len = pMib->aData.TemplateFrame.Length; + tSetTemplate.ptr = (TI_UINT8 *) &(pMib->aData.TemplateFrame.Data); + tSetTemplate.uRateMask = uHWRate; + + return TWD_CmdTemplate (hTWD, &tSetTemplate, NULL, NULL); +} + +/** + * \brief Set Beacon Filter IE Table + * + * \param hTWD - TWD module object handle + * \param pMib - Pointer to Input MIB Structure + * \return TI_OK on success or TI_NOK on failure + * + * \par Description + * Static function + * Configure the MIB Beacon Filter IE table + * + * \sa + */ +static TI_STATUS TWD_WriteMibBeaconFilterIETable (TI_HANDLE hTWD, TMib *pMib) +{ + TTwd *pTWD = (TTwd *)hTWD; + TI_UINT8 numOf221IE = 0; + TI_UINT8 i = 0; + TI_UINT8 IETableLen = 0; + TI_UINT8 numOfIEs = 0; + TI_UINT8 *IETable = NULL; + + numOfIEs = pMib->aData.BeaconFilter.iNumberOfIEs; + IETable = pMib->aData.BeaconFilter.iIETable; + /* Find the actual IETableLen */ + for (i = 0; i < numOfIEs; i++) + { + if (IETable[IETableLen] == 0xdd) + { + IETableLen += 8; + numOf221IE++; + } + else + { + IETableLen += 2; + } + } + + TRACE4(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_WriteMibBeaconFilterIETable: IETable=0x%x Num Of IE=%d ( including %d 221 ) - Table Len=%d\n", IETable, numOfIEs, numOf221IE, IETableLen); + + return TWD_CfgBeaconFilterTable (hTWD, numOfIEs, IETable, IETableLen); +} + +/** + * \brief Set Tx Rate Policy + * + * \param hTWD - TWD module object handle + * \param pMib - Pointer to Input MIB Structure + * \return TI_OK on success or TI_NOK on failure + * + * \par Description + * Static function + * Coordinates between legacy TxRatePolicy implementation and the MIB format: + * Converts the pGwsi_txRatePolicy back to command builder commands. + * Activates the TWD_set function. + * + * \sa + */ +static TI_STATUS TWD_WriteMibTxRatePolicy (TI_HANDLE hTWD, TMib* pMib) +{ + TTwd *pTWD = (TTwd *)hTWD; + +#ifdef TI_DBG + if (NULL == pMib) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "ERROR: TWD_WriteMibTxRatePolicy pMib=NULL !!!"); + return PARAM_VALUE_NOT_VALID; + } +#endif /* TI_DBG */ + + return cmdBld_CfgTxRatePolicy (pTWD->hCmdBld, &pMib->aData.txRatePolicy, NULL, NULL); +} + +TI_STATUS TWD_WriteMib (TI_HANDLE hTWD, TMib *pMib) +{ + TTwd *pTWD = (TTwd *)hTWD; + +#ifdef TI_DBG + TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_WriteMib :pMib %p:\n",pMib); + + TRACE1(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_WriteMib :aMib %x:\n",pMib->aMib); + + TRACE_INFO_HEX(pTWD->hReport, (TI_UINT8*)pMib, TI_MIN (sizeof(TMib), pMib->Length)); +#endif /* TI_DBG */ + + if (NULL == pMib) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_WriteMib :pMib = NULL !!\n"); + return PARAM_VALUE_NOT_VALID; + } + + switch (pMib->aMib) + { + case MIB_dot11MaxReceiveLifetime: + return cmdBld_CfgRxMsduLifeTime (pTWD->hCmdBld, pMib->aData.MaxReceiveLifeTime * 1024, (void *)NULL, (void *)NULL); + + case MIB_ctsToSelf: + return cmdBld_CfgCtsProtection (pTWD->hCmdBld, (TI_UINT8)pMib->aData.CTSToSelfEnable, (void *)NULL, (TI_HANDLE)NULL); + + case MIB_dot11GroupAddressesTable: + { + if (NULL == pMib->aData.GroupAddressTable.aGroupTable) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_WriteMib(MIB_dot11GroupAddressesTable) :GroupTable = NULL !!\n"); + return PARAM_VALUE_NOT_VALID; + } + + return TWD_CfgGroupAddressTable (hTWD, + pMib->aData.GroupAddressTable.nNumberOfAddresses, + pMib->aData.GroupAddressTable.aGroupTable, + pMib->aData.GroupAddressTable.bFilteringEnable); + } + + case MIB_arpIpAddressesTable: + { + TIpAddr IpAddress; + + IP_COPY (IpAddress, pMib->aData.ArpIpAddressesTable.addr); + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "TWD_WriteMib(MIB_arpIpAddressesTable) IpAddress:\n"); + TRACE_INFO_HEX(pTWD->hReport, (TI_UINT8*)&IpAddress, 4); + + return cmdBld_CfgArpIpAddrTable (pTWD->hCmdBld, + IpAddress, + (TI_BOOL)pMib->aData.ArpIpAddressesTable.FilteringEnable, + IP_VER_4, + NULL, + NULL); + } + + case MIB_templateFrame: + return TWD_WriteMibTemplateFrame (hTWD, pMib); + + case MIB_beaconFilterIETable: + return TWD_WriteMibBeaconFilterIETable (hTWD, pMib); + + case MIB_rxFilter: + { + TI_UINT32 uRxFilter = 0; + TI_UINT8 uMibRxFilter = pMib->aData.RxFilter; + + if (uMibRxFilter & MIB_RX_FILTER_PROMISCOUS_SET) + { + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "\n TWD_WriteMib MIB_rxFilter - RX_CFG_ENABLE_ANY_DEST_MAC\n"); + uRxFilter = RX_CFG_ENABLE_ANY_DEST_MAC; + } + else + { + uRxFilter = RX_CFG_ENABLE_ONLY_MY_DEST_MAC; + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "\n halCtrl_WriteMib MIB_rxFilter - RX_CFG_ENABLE_ONLY_MY_DEST_MAC\n"); + } + + if ((uMibRxFilter & MIB_RX_FILTER_BSSID_SET) != 0) + { + uRxFilter = uRxFilter | RX_CFG_ENABLE_ONLY_MY_BSSID; + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "\n halCtrl_WriteMib MIB_rxFilter - RX_CFG_ENABLE_ONLY_MY_BSSID\n"); + } + else + { + uRxFilter = uRxFilter | RX_CFG_ENABLE_ANY_BSSID; + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION, "\n halCtrl_WriteMib MIB_rxFilter - RX_CFG_ENABLE_ANY_BSSID\n"); + } + + /* + * Activates the TWD_setRxFilters function + */ + return TWD_CfgRx (hTWD, uRxFilter, RX_FILTER_OPTION_DEF); + } + + case MIB_txRatePolicy: + return TWD_WriteMibTxRatePolicy (hTWD, pMib); + + default: + TRACE1(pTWD->hReport, REPORT_SEVERITY_ERROR, "TWD_WriteMib - ERROR - MIB element not supported, %d\n", pMib->aMib); + + return TI_NOK; + + } /* switch */ +} + +TI_STATUS TWD_ReadMib (TI_HANDLE hTWD, TI_HANDLE hCb, void* fCb, void* pCb) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_ReadMib: called\n"); + + return cmdBld_ReadMib (pTWD->hCmdBld, hCb, fCb, pCb); +} + +void TWD_DisableInterrupts(TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_DisableInterrupts: called\n"); + + fwEvent_DisableInterrupts(pTWD->hFwEvent); +} + +void TWD_EnableInterrupts(TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_EnableInterrupts: called\n"); + + fwEvent_EnableInterrupts(pTWD->hFwEvent); +} + +TI_UINT32 TWD_TranslateToFwTime (TI_HANDLE hTWD, TI_UINT32 uHostTime) +{ + TTwd *pTWD = (TTwd *)hTWD; + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_TranslateToFwTime: called\n"); + + return fwEvent_TranslateToFwTime (pTWD->hFwEvent, uHostTime); +} + +void TWD_GetTwdHtCapabilities (TI_HANDLE hTWD, TTwdHtCapabilities **pTwdHtCapabilities) +{ + TTwd *pTWD = (TTwd *)hTWD; + TWlanParams *pWlanParams = &DB_WLAN(pTWD->hCmdBld); + + TRACE0(pTWD->hReport, REPORT_SEVERITY_INFORMATION , "TWD_GetTwdHtCapabilities: called\n"); + + *pTwdHtCapabilities = &(pWlanParams->tTwdHtCapabilities); +} +/** + * \TWD_GetFEMType + * \param hTWD - TWD module object handle + * \return FEM Type + * + * + * */ +TI_UINT8 TWD_GetFEMType (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + IniFileGeneralParam *pGenParams = &DB_GEN(pTWD->hCmdBld); + + return pGenParams->TXBiPFEMManufacturer; + +} + +/** + * \TWD_FinalizeFEMRead + * \param hTWD - TWD module object handle + * \end of Read FEM SM calling InitHW + * + * + * */ +void TWD_FinalizeFEMRead(TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + (*pTWD->fInitHwCb) (pTWD->hUser, TI_OK); +} + + + + +void TWD_FinalizePolarityRead(TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + /* allways read FEM type from Radio Registers */ + hwInit_ReadRadioParams(pTWD->hHwInit); +} + +/** + * \function TWD_rxXfer_Handle + * + * Handle Rx buffers read in case we delayed it from upper layer + * + * \param hTWD - TWD module object handle + * + * \sa + */ +void TWD_rxXfer_Handle (TI_HANDLE hTWD) +{ + TTwd *pTWD = (TTwd *)hTWD; + + rxXfer_Handle (pTWD->hRxXfer); +}