--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/platforms/os/Symbian/WVSS/src/wha/TIWha.cpp Tue Jun 29 12:34:26 2010 +0100
@@ -0,0 +1,4387 @@
+/*
+ * TIWha.cpp
+ *
+ * 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 TIWha.cpp
+ * \brief Interface between the Symbian to the WVSS WLAN WL6.1 Driver
+ *
+ * \see
+*/
+
+#include "TIWha.h"
+#include "TIWhaAdaptCb.h"
+#include "wlanhwbusaccesslayer.h"
+#ifdef GEM_SUPPORT
+#include "TIWhaGemDef.h"
+#endif /* GEM_SUPPORT */
+
+/* The fw that we are using in case it isn't contained in aData */
+#include "wilink6_firmware.h"
+
+#ifdef WLAN_SDIO
+#include "SdioClient.h"
+#endif //WLAN_SDIO
+
+
+const TInt KWlanDriverMajorVersion = 1;
+const TInt KWlanDriverMinorVersion = 0;
+const TInt KWlanDriverBuildVersion = 0;
+const TUint KWlanUnitsAllowedMask = 0x0000000F;
+
+
+/*******************************************************************************
+ * stuff for C file linking. *
+ *******************************************************************************/
+
+extern "C"
+{
+#include "tidef.h"
+#include "report.h"
+#include "timer.h"
+#include "TWDriver.h"
+#include "version.h"
+#include "osApi.h"
+#include "context.h"
+#include "public_commands.h"
+//#include "public_radio.h"
+#include "TxnQueue.h"
+#include "BusDrv.h"
+#define __FILE_ID__ FILE_ID_144
+}
+
+#define MAX_NUM_OF_TX_QUEUES 4
+#define TX_TOTAL_OFFSET_BEFORE_DATA (WSPI_PAD_LEN_WRITE + TX_DESCRIPTOR_SIZE)
+
+/* Stalling the CPU of OAMP3430 for 2Ms */
+#define STALL_ON_CPU 2000
+
+/* In case of a KFailed we use the Assert() function as indicated in the spec, but return KSuccess */
+#define ASSERT_MI2(hrep,mib,exp,file,func,line) \
+ if ((exp) != WHA::KSuccess) { \
+ TRACE2(hrep, REPORT_SEVERITY_ERROR , " failed, mib=%d, file=, line=%d\n", mib, line); \
+ MWlanOsa::Assert( (const TInt8 *)file, line, EFalse ); \
+ return WHA::KSuccess; \
+ }
+
+#define ASSERT_MIB(hrep,mib,exp) \
+ ASSERT_MI2(hrep,mib,exp, __FUNCTION__,__FUNCTION__,__LINE__)
+
+
+#define ASSERT_ER2(hrep,fmsg,par,line) \
+ TRACE1(hrep, REPORT_SEVERITY_ERROR, fmsg, par); \
+ //MWlanOsa::Assert( (const TInt8 *)file, line, EFalse );
+
+#define ASSERT_ERR(hrep,fmsg,par) \
+ ASSERT_ER2(hrep,fmsg,par,__LINE__)
+
+
+#define FREF_CLK_FREQ_MASK 0x7
+
+
+/************************************************************************************/
+
+/**
+* \fn Create
+* \brief static create
+*
+* Just call constructor
+*
+* \note
+* return handle to TIWha class.
+* \sa
+*/
+WHA::Wha* WHA::Wha::Create(MWlanOsa& aOsa, WlanHpa& aHpa, const SHwBusAccessLayer& aTransPortLayer)
+{
+ return new TIWha (aOsa, aHpa, *(aTransPortLayer.iSpia));
+}
+
+
+/**
+* \fn Destroy
+* \brief static destroy
+*
+* Just call destructor
+*
+* \note
+* \sa
+*/
+void WHA::Wha::Destroy(Wha* aWha)
+{
+ delete aWha;
+}
+
+/**
+* \fn TIWha
+* \brief Constructor
+*
+* This method is the default constructor,all modules mamory alocation
+* and software configuration (not sending any thing via BUS to the firmware)
+*
+* \note
+* return handle to TIWha class.
+* \sa
+*/
+TIWha::TIWha(MWlanOsa& aOsa, WlanHpa& aHpa, WlanSpia& aSpia)
+: Wha(aOsa, aHpa, aSpia) /* Construct the base class */
+{
+ /* Before initializing the report module, we should use the WLAN_OS_REPORT macro */
+ WLAN_INIT_REPORT (("TIWha constructor ++\n"));
+ WLAN_INIT_REPORT(("Driver Version : %s\n", SW_VERSION_STR));
+
+ /* tOsContext (hOS is made of MWlanOsa and WlanSpia */
+ iTwdCtrl.tOsContext.hOsa = &aOsa;
+ iTwdCtrl.tOsContext.hSpia = &aSpia;
+ iTwdCtrl.tOsContext.hHpa = &aHpa;
+
+ /* Nullify handles to mark that it wasn't created yet */
+ iTwdCtrl.hTWD = NULL;
+ iTwdCtrl.hReport = NULL;
+ iTwdCtrl.hReport = NULL;
+ iTwdCtrl.hContext = NULL;
+ iTiWlanHpaCb = NULL;
+ /* indicate that no error indication was called */
+ bErrorIndication = TI_FALSE;
+
+ bConnectionTimerRunning = TI_FALSE;
+ /* indicate that TIWha::Release() should be called directly if we have error indication */
+ bCallRelease = TI_TRUE;
+ bFreeDriver = TI_FALSE;
+ bRxMemFailTimerRunning = TI_FALSE;
+ uRxMemFailCount = 0;
+
+ bFailureIndication = TI_FALSE;
+
+ /* Initilaize Timer handle */
+ readDot11StationIdMibTmr = NULL;
+
+ /* Set the join flag to false */
+ bJoined = 0;
+
+ iConnectionCounter = 0;
+
+ #ifdef HT_SUPPORT
+ /* Reset the BA Vectors */
+ iTxBlockAckUsageLast = 0;
+ iRxBlockAckUsageLast = 0;
+ #endif
+
+
+ pFailureDfcClient = new TIFailureDfcClient(*iTwdCtrl.tOsContext.hOsa);
+ if (pFailureDfcClient == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR: CreateDriver TIFailureDfcClient failure\n"));
+ }
+
+ pConnectDfcClient = new TIConnectDfcClient(*iTwdCtrl.tOsContext.hOsa);
+ if (pConnectDfcClient == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR: CreateDriver TIConnectDfcClient failure\n"));
+ }
+
+ WLAN_INIT_REPORT (("TIWha constructor -- \n"));
+}
+
+
+TIWha::TIWha()
+: Wha (*iTwdCtrl.tOsContext.hOsa,*iTwdCtrl.tOsContext.hHpa,*iTwdCtrl.tOsContext.hSpia)
+{
+ iVersion = TVersion( KWlanDriverMajorVersion,
+ KWlanDriverMinorVersion,KWlanDriverBuildVersion );
+ iUnitsMask = KWlanUnitsAllowedMask;
+ bDriverCreated = TI_TRUE;
+/* Nullify handles to mark that it wasn't created yet */
+ iTwdCtrl.hTWD = NULL;
+ iTwdCtrl.hReport = NULL;
+ iTwdCtrl.hReport = NULL;
+ iTwdCtrl.hContext = NULL;
+ iTiWlanHpaCb = NULL;
+ /* indicate that no error indication was called */
+ bErrorIndication = TI_FALSE;
+
+ bConnectionTimerRunning = TI_FALSE;
+ /* indicate that TIWha::Release() should be called directly if we have error indication */
+ bCallRelease = TI_TRUE;
+ bFreeDriver = TI_FALSE;
+ bRxMemFailTimerRunning = TI_FALSE;
+ uRxMemFailCount = 0;
+
+ bFailureIndication = TI_FALSE;
+
+ /* Initilaize Timer handle */
+ readDot11StationIdMibTmr = NULL;
+
+ /* Set the join flag to false */
+ bJoined = 0;
+
+ iConnectionCounter = 0;
+
+ #ifdef HT_SUPPORT
+ /* Reset the BA Vectors */
+ iTxBlockAckUsageLast = 0;
+ iRxBlockAckUsageLast = 0;
+ #endif
+
+ WLAN_INIT_REPORT (("TIWha constructor -- \n"));
+}
+
+
+/**
+* \fn CreateDriver
+* \brief Create driver modules
+*
+* Create 'report', 'context', 'TWD', 'HpaCb'
+*
+* \note In case of failure, The modules will be released later in DestroyDriver();
+* \sa
+*/
+TI_STATUS TIWha::CreateDriver()
+{
+ WLAN_INIT_REPORT (("CreateDriver ++\n"));
+
+
+ /* Create utils and TWD */
+ iTwdCtrl.hReport = report_Create ((TI_HANDLE)&iTwdCtrl.tOsContext);
+ if (iTwdCtrl.hReport == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR: CreateDriver report_Create failure\n"));
+ return TI_NOK;
+ }
+ InitReportParamTable ();
+ report_SetDefaults (iTwdCtrl.hReport, &(iTwdCtrl.report_init));
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, "CreateDriver");
+
+ /* Create context module */
+ iTwdCtrl.hContext = context_Create ((TI_HANDLE)&iTwdCtrl.tOsContext);
+ if (iTwdCtrl.hContext == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR:CreateDriver context_Create failure\n"));
+ return TI_NOK;
+ }
+
+ /* Create Timer module */
+ iTwdCtrl.hTimer = tmr_Create ((TI_HANDLE)&iTwdCtrl.tOsContext);
+ if (iTwdCtrl.hTimer == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR:CreateDriver tmr_Create failure\n"));
+ return TI_NOK;
+ }
+
+ /* Create TxnQ */
+ iTwdCtrl.hTxnQ = txnQ_Create ((TI_HANDLE)&iTwdCtrl.tOsContext);
+ if (iTwdCtrl.hTxnQ == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR:CreateDriver txnQ_Create failure\n"));
+ return TI_NOK;
+ }
+
+ /* Create TWD */
+ iTwdCtrl.hTWD = TWD_Create ((TI_HANDLE)&iTwdCtrl.tOsContext);
+ if (iTwdCtrl.hTWD == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR:CreateDriver TWD_Create failure\n"));
+ return TI_NOK;
+ }
+
+ /* Create HpaCb */
+ iTiWlanHpaCb = new TIWlanHpaCB (iTwdCtrl.hTWD);
+ if (iTiWlanHpaCb == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR:CreateDriver new TIWlanHpaCB failure\n"));
+ return TI_NOK;
+ }
+
+ return TI_OK;
+}
+
+/**
+* \fn DestroyDriver
+* \brief destroy driver modules
+*
+* Destroy 'report', 'context', 'TWD', 'HpaCb' only if it is not NULL
+*
+* \sa
+*/
+void TIWha::DestroyDriver()
+{
+ WLAN_OS_REPORT(("DestroyDriver\n"));
+
+ /* Delete TWD and utils */
+ if (iTwdCtrl.hTWD != NULL)
+ {
+ TWD_Destroy (iTwdCtrl.hTWD);
+ /* Avoid future destroy of TWD */
+ iTwdCtrl.hTWD = NULL;
+ }
+
+ if (iTwdCtrl.hTxnQ)
+ {
+ txnQ_Destroy(iTwdCtrl.hTxnQ);
+ iTwdCtrl.hTxnQ = NULL;
+ }
+
+ if (iTwdCtrl.hContext != NULL)
+ {
+ context_Destroy (iTwdCtrl.hContext);
+ /* Avoid future destroy of context */
+ iTwdCtrl.hContext = NULL;
+ }
+ if (iTwdCtrl.hTimer != NULL)
+ {
+ tmr_Destroy (iTwdCtrl.hTimer);
+ /* Avoid future destroy of timer */
+ iTwdCtrl.hTimer = NULL;
+ }
+ if (iTiWlanHpaCb != NULL)
+ {
+ delete iTiWlanHpaCb;
+ /* Avoid future destroy of HpaCb */
+ iTiWlanHpaCb = NULL;
+ }
+ if (iTwdCtrl.hReport != NULL)
+ {
+ report_Unload (iTwdCtrl.hReport);
+ /* Avoid future destroy of report */
+ iTwdCtrl.hReport = NULL;
+ }
+
+ if (readDot11StationIdMibTmr != NULL)
+ {
+ os_timerDestroy(0,readDot11StationIdMibTmr);
+ readDot11StationIdMibTmr = NULL;
+ }
+
+ if (hConnectionTimer != NULL)
+ {
+ os_timerDestroy(0,hConnectionTimer);
+ hConnectionTimer = NULL;
+ }
+
+ if (hInitializeTimer != NULL)
+ {
+ os_timerDestroy(0,hInitializeTimer);
+ hInitializeTimer = NULL;
+ }
+
+ if (hRxMemFailTimer != NULL)
+ {
+ os_timerDestroy(0,hRxMemFailTimer);
+ hRxMemFailTimer = NULL;
+ }
+
+}
+
+/**
+* \fn ~TIWha
+* \brief destructor
+*
+*
+* \note Release is called here if it was not called from UMAC
+* \param
+* \return
+* \sa
+*/
+TIWha::~TIWha()
+{
+ /* Delete iFailureDfcClient */
+ if (pFailureDfcClient != NULL)
+ {
+ /* Either succeeds or has no effect */
+ pFailureDfcClient->pFailureDfc->Dequeue();
+ /* Osa owns this. Will be deleted there. */
+ pFailureDfcClient->pFailureDfc = NULL;
+
+ delete pFailureDfcClient;
+ }
+
+ /* Delete iConnectDfcClient */
+ if (pConnectDfcClient != NULL)
+ {
+ /* Either succeeds or has no effect */
+ pConnectDfcClient->pConnectDfc->Dequeue();
+ /* Osa owns this. Will be deleted there. */
+ pConnectDfcClient->pConnectDfc = NULL;
+
+ delete pConnectDfcClient;
+ }
+
+ WLAN_INIT_REPORT(("~TIWha\n"));
+}
+
+/**
+* \fn Initialize
+* \brief Initialize the WLAN driver (memory allocation and modules software init. )
+*
+* \note
+* Downloads the firmware code to the WLAN device.
+* /param aData - firmware data
+* /param aLength - length of the data in bytes
+* /return
+*/
+void TIWha::Initialize(const void* aData, TUint32 aLength)
+{
+ iData = aData;
+ iLength = aLength;
+
+ WLAN_INIT_REPORT (("Initialize ++ \n"));
+ #ifdef TI_TEST
+ iQueueId = WHA::ELegacy;
+ #endif /* TI_TEST*/
+
+ /* configure HPA polarity according to CHIP configuration */
+ #ifdef USE_IRQ_ACTIVE_HIGH
+ WlanHpa::TConfig tConfig = {WlanHpa::EIsrPolarityHigh};
+ #else
+ WlanHpa::TConfig tConfig = {WlanHpa::EIsrPolarityLow};
+ #endif
+
+ iRxPacketsAllocated = 0;
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, " IRQ is ");
+
+ /* if we were called from failure indication then we don't reconfigure the HPA */
+ if (bFailureIndication == TI_FALSE )
+ {
+ ((WlanHpa*)iTwdCtrl.tOsContext.hHpa)->Configure(tConfig);
+ }
+
+
+ /* Power up the chip */
+ ((WlanHpa*)iTwdCtrl.tOsContext.hHpa)->PowerOnDevice();
+#ifdef WLAN_SDIO
+ os_StalluSec ((TI_HANDLE)&iTwdCtrl.tOsContext, 200000 );
+#endif
+
+ /* Create all modules */
+ if ( CreateDriver() != TI_OK)
+ {
+ WLAN_OS_REPORT (("Error on CreateDriver() \n"));
+ InitResponse (WHA::KFailed);
+ }
+
+ /* Attach our client to HPA */
+ ((WlanHpa*)iTwdCtrl.tOsContext.hHpa)->Attach(*iTiWlanHpaCb);
+ /* Configure the context module */
+ context_Init (iTwdCtrl.hContext, (TI_HANDLE)&iTwdCtrl.tOsContext,iTwdCtrl.hReport);
+
+ /* Initialize timer module */
+ tmr_Init (iTwdCtrl.hTimer, (TI_HANDLE)&iTwdCtrl.tOsContext, iTwdCtrl.hReport, iTwdCtrl.hContext);
+
+ hInitializeTimer = os_timerCreate(&iTwdCtrl.tOsContext,(fTimerFunction)TIWhaAdaptCB::InitializeAfterTimer,this);
+
+#ifndef WLAN_SDIO
+ /* Wait some time for the HW to complete initialization */
+ os_timerStart (&iTwdCtrl.tOsContext,hInitializeTimer,200);
+#else
+ InitializeAfterTimer();
+#endif
+}
+
+
+ /**
+ * \fn InitializeAfterTimer
+ * \brief start second part of initialization after timer expired
+ *
+ * \note
+ * \param
+ * \return
+ * \sa
+ */
+void TIWha::InitializeAfterTimer()
+{
+ TI_STATUS status;
+ TUint8* data = (TUint8*)iData;
+ TUint8* pRadio;
+
+ TUint32 nvsLength = 0;
+ TUint32 radioLength = 0;
+
+ /* Create a connection timer that will be triggered after Join command */
+ hConnectionTimer = os_timerCreate(&iTwdCtrl.tOsContext,(fTimerFunction)TIWhaAdaptCB::ConnectionTimeOut,this);
+ if (hConnectionTimer == NULL)
+ {
+ WLAN_OS_REPORT(("Error Failed to create hConnectionTimer"));
+ }
+
+ /* Create a timer for losing context for Station ID Mib */
+ readDot11StationIdMibTmr = os_timerCreate(&iTwdCtrl.tOsContext,(fTimerFunction)TIWhaAdaptCB::ReadDot11StationIdCb,this);
+ if (readDot11StationIdMibTmr == NULL)
+ {
+ WLAN_OS_REPORT(("Error Faild to create readDot11StationIdMibTmr"));
+ }
+
+ /* Create a timer in case RequestForBuffer fails */
+ hRxMemFailTimer = os_timerCreate(&iTwdCtrl.tOsContext,(fTimerFunction)TIWhaAdaptCB::RxMemFailTimerCb,this);
+ if (hRxMemFailTimer == NULL)
+ {
+ WLAN_OS_REPORT(("Error Faild to create hRxMemFailTimer"));
+ }
+
+ /* enable timer operation */
+ tmr_UpdateDriverState (iTwdCtrl.hTimer, TI_TRUE);
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, "init TWD");
+ /*init the txnq */
+
+ txnQ_Init (iTwdCtrl.hTxnQ,
+ (TI_HANDLE)&iTwdCtrl.tOsContext,
+ iTwdCtrl.hReport,
+ iTwdCtrl.hContext);
+
+ /* Next section retrieves the pointer and Lenght of NVS & FW accordingly in th eaData Buf */
+
+ /*
+ aData structue :
+ ____________________________________________________________________________________________
+ | | | | | | |
+ |NVS Len | NVS File | Radio Len | Radio File | FW Len | FW File |
+ |4 Bytes | WiLink6_nvs.h | 4 Bytes | radio_ini.h | 4 Bytes | WiLink6_firmware.h |
+ |_________|_______________|____________|______________|__________|__________________________|
+
+ */
+
+ #ifdef _SYMBIAN_
+ nvsLength = *reinterpret_cast<const TUint32*>(&data[0]);
+ radioLength = *reinterpret_cast<const TUint32*>(&data[sizeof(TUint32) + nvsLength]);
+ TUint32 fwLength = *reinterpret_cast<const TUint32*>(&data[sizeof(TUint32) + nvsLength + sizeof(TUint32) + radioLength]);
+
+ /* in case no fw in aData, use wilink6_firmware */
+ if (fwLength == 0 )
+ {
+ WLAN_OS_REPORT(("TIWha::Initialize:: Taking default fw"));
+ iFwFile.pBuffer = (TI_UINT8*)wilink6_firmware;
+ }
+ else
+ {
+ WLAN_OS_REPORT(("TIWha::Initialize::received fw from LDD, fwLength : %d", fwLength ));
+ /* Update first FW Pointer to be the one residing in the firmware array from the fw1273_chip.h */
+ iFwFile.pBuffer = data + 3*sizeof(TUint32) + nvsLength + radioLength;
+ }
+
+ /* Retrieve NVS pointer & Lenght */
+ ipNVSbuf = data + sizeof(TUint32);
+ iNVSlength = nvsLength;
+
+ /* Copy the content of NVS Buffer for saving the MAC Address and Burst Read to be retrieved back when NVS
+ Array is received back from the FW */
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,iNvsStart,ipNVSbuf,24);
+
+ /* FEM Auto Detection */
+ /* Retrieve Radio pointer */
+ pRadio = data + sizeof(TUint32) + nvsLength + sizeof(TUint32);
+
+ /* save Radio params*/
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iAutoRadioParams.tGeneralParams, pRadio, GENERAL_RADIO_PARAM_LEN);
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iAutoRadioParams.tStatRadioParams, (TUint8*)(pRadio + STATIC_RADIO_PARAM_OFFSET), STATIC_RADIO_PARAM_LEN);
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iAutoRadioParams.tDynRadioParams[0], (TUint8*)(pRadio + FEM0_DYNAMIC_RADIO_PARAM_OFFSET), DYNAMIC_RADIO_PARAM_LEN);
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iAutoRadioParams.tDynRadioParams[1], (TUint8*)(pRadio + FEM1_DYNAMIC_RADIO_PARAM_OFFSET), DYNAMIC_RADIO_PARAM_LEN);
+
+ #else /* Other OS */
+ /* Retrieve FW pointer */
+ iFwFile.pBuffer = (TI_UINT8*)wilink6_firmware;
+
+ /*saving NVS pointer */
+ ipNVSbuf = (uint8*)aData;
+ /* Set NVS length */
+ iNVSlength = aLength;
+
+ /* Copy the content of NVS Buffer frir saving the MACF Address and Burst Read to be retrieved back when NVS
+ Array is receuved back from the FW */
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,iNvsStart,ipNVSbuf,24);
+
+ /* FEM Auto Detection fill radio params */
+ /*FillRadioData();*/
+
+ #endif
+
+ #if TI_DBG
+ WLAN_OS_REPORT(("TIWha::Initialize::nvsLength : %d", nvsLength ));
+ WLAN_OS_REPORT(("TIWha::Initialize::radioLength : %d", radioLength ));
+ #endif
+
+ WLAN_OS_REPORT((" in Initialize calling txnQ_ConnectBus "));
+ /* Configure the bus - in WSPI configuration is done internaly */
+ /* This will download the FW image into part with DMA of 512 bytes each time */
+ BusDrvCfg.tSdioCfg.uBlkSizeShift = SDIO_BLK_SIZE_SHIFT_DEF;
+ status = txnQ_ConnectBus (iTwdCtrl.hTxnQ, &BusDrvCfg,(TTxnDoneCb)TIWhaAdaptCB::ConnectBus,this,NULL,NULL);
+
+ /* If the bus connect is sync, then we should lose the context and call the CB */
+ if (status == TI_OK)
+ {
+ /* Register ConnectDfcClient to handle the connect bus CB from a different context */
+ pConnectDfcClient->pConnectDfc->Enqueue(*pConnectDfcClient ,(TInt)this);
+ }
+ #ifdef OMAP3430_CPU_STALL
+ /* Add a stall to make sure that CPU is not going idle while initializing */
+ os_StalluSec ((TI_HANDLE)&iTwdCtrl.tOsContext, STALL_ON_CPU );
+ #endif
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, "TIWha::Initialize --");
+}
+
+/**
+* \fn Configure
+* \brief Configures the WLAN device after firmware download and basic
+* chip init has taken place
+* \note
+* Method configures the WLAN device after the WHA layer has send the
+* EInitializeResponse event. Only after calling this method,
+* WLAN device is ready for use.
+* Note: the memory supplied by the command is valid to point the
+* corresponding command response event is send
+*
+*
+* /param aData firmware - data. The content is vendor specific.
+* /param aWhaSettings - output data that holds the capabilities
+* of the WLAN vendor specific solution.
+* \return
+* \sa
+*/
+void TIWha::Configure( const WHA::SConfigureData& aData,
+ WHA::SSettings& aWhaSettings)
+{
+ TFwInfo *tChipVer;
+ TI_UINT8 *pMac;
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, "WHA-Configure +");
+
+ /* Enable interrupts on HPA */
+ ((WlanHpa*)iTwdCtrl.tOsContext.hHpa)->EnableIrq();
+
+ TWD_EnableInterrupts (iTwdCtrl.hTWD);
+
+ /* Call the function to fill all the parameters in the NWSA Settings */
+ FillNWSASettings (&aWhaSettings);
+
+ /* Retrieve FW information from TWD */
+ tChipVer= TWD_GetFWInfo (iTwdCtrl.hTWD);
+ pMac = (TI_UINT8 *)tChipVer->macAddress;
+
+ /* Update driver's MAC address */
+ MAC_COPY (iTwdCtrl.pMacAddr, tChipVer->macAddress);
+
+ /*
+ * Exit from init mode should be before smeSM starts. this enable us to send
+ * command to the MboxQueue(that store the command) while the interrupts are masked.
+ * the interrupt would be enable at the end of the init process.
+ */
+ TWD_ExitFromInitMode (iTwdCtrl.hTWD);
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, " TIWha::Configure : Before Config HW");
+ if (TWD_ConfigFw (iTwdCtrl.hTWD) != TI_OK)
+ {
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, " TIWha:: TWD_ConfigFw returned error");
+ ConfigFwCb( WHA::KFailed);
+ return;
+ }
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, "EXIT FROM INIT\n");
+
+ /* Print the driver and firmware version and the mac address */
+ WLAN_OS_REPORT(("\n"));
+ WLAN_OS_REPORT(("--------------------------------------------------------------------\n"));
+ WLAN_OS_REPORT(("Driver Version : %s\n", SW_VERSION_STR));
+ WLAN_OS_REPORT(("Firmware Version: %s\n", tChipVer->fwVer));
+ WLAN_OS_REPORT(("Station ID : %02X-%02X-%02X-%02X-%02X-%02X\n",
+ pMac[0], pMac[1], pMac[2], pMac[3], pMac[4], pMac[5]));
+ WLAN_OS_REPORT(("--------------------------------------------------------------------\n"));
+ WLAN_OS_REPORT(("\n"));
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, "WHA-Configure --");
+}
+
+
+/**
+* \fn Release
+* \brief Destroy TWD and utils
+* \note
+* Any symbian classes (sandbox) will be deleted in the destructor
+*
+* /param aSynchronous - not used
+* \return KSuccess
+* \sa
+*/
+WHA::TStatus TIWha::Release( TBool aSynchronous )
+{
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, "\n");
+
+ /* Power off chip */
+ ((WlanHpa*)iTwdCtrl.tOsContext.hHpa)->PowerOffDevice();
+
+ /* Delete all modules */
+ DestroyDriver();
+
+ return WHA::KSuccess;
+}
+
+/**
+* Note: The WLAN host driver does not issue this command while measure
+* or 802.11 power management mode transition process is in progress.
+* This method commands the WLAN device to start scanning in order to
+* determine the characteristics of the available BSSs and IBSSs to which
+* it may later to elect to join.
+* When the WLAN device receives this command,
+* it goes into a scanning mode.
+* The WHA layer sends the EScanCommandResponse event to inform the
+* WLAN host driver that the WLAN vendor specific
+* solution has accepted the command.
+* For each command there will be both EScanCommandResponse and
+* EScanComplete event regardless the fact if the scan did start or not.
+* If the WLAN device is able to start the scanning process, all beacons
+* and Probe response frames are sent to the WLAN host driver.
+* When the scanning has completed, the WHA layer sends the EScanComplete
+* event to inform the WLAN host driver that the scan process has
+* completed in the WLAN device.
+* Note: while this command is in progress it disables the current Rx
+* frame filtering settings for the duration of the scan.
+* This means that only beacon and probe response frames are forwarded to
+* the WLAN host driver (unless doing a split scan) in depended of the
+* current configuration related to Rx frame handling.
+* Note: scanning must be supported by the WLAN vendor specific solution
+* both in infrastructure and IBSS mode.
+* Although frames can be lost in IBSS mode due to scanning,
+* support for it is required.
+*
+*
+* /param aMaxTransmitRate - specifies the transmission rate of the
+* probe request in case of a active scan
+* Note: just a single rate is selected not multiple as rate fallback
+* is not to be used during the scan process
+* /param aBand - selects the used frequency band.
+* Only 1 band is scanned at a time
+* and 1 bit is used to select the band to be scanned
+* /param aNumOfChannels - number of channels provided in the command
+* /param aChannels - specifies the scanned channels
+* /param aScanType - specifies the scan type:
+* 0 foreground scan
+* 1 background scan
+* 2 forced background scan
+* /param aNumOfProbeRequests - number of probe requests (per SSID)
+* sent to one (1) channel.
+* Zero (0) means that none is send,
+* which means that a passive scan is to be done.
+* Value greater than zero (0) means that an active scan is to be done
+* /param aSplitScan - ETrue if a split scan method is to be used.
+* EFalse if not
+* /param aNumOfSSID - number of SSID provided in the scan command
+* (this is zero (0) in broadcast scan)
+* /param aSsid - Array of the SSID to be probed in scan
+*/
+#ifdef PLT_TESTER
+TTestCmd tTest;
+#endif /* PLT_TESTER */
+void TIWha::Scan( WHA::TRate aMaxTransmitRate,
+ WHA::TBand aBand,
+ TUint8 aNumOfChannels,
+ const WHA::SChannels* aChannels,
+ WHA::TScanType aScanType,
+ TUint8 aNumOfProbeRequests,
+ TBool aSplitScan,
+ TUint8 aNumOfSSID,
+ const WHA::SSSID* aSsid)
+{
+ E80211PsMode PS_mode;
+ TBool bEnterPS; /* whether to enter PS */
+ TBool bScanOnDriverModeError; /* Forced background option */
+
+
+#ifdef PLT_TESTER
+//OpenAllReports();
+WLAN_OS_REPORT(("**************************************\n"));
+WLAN_OS_REPORT(("PLT_TESTER\n"));
+WLAN_OS_REPORT(("**************************************\n"));
+
+ iRealPlt = 0;
+
+ os_printf("************ PLT Test os_printf working ***************\n");
+ PltSm(NULL);
+
+
+return;
+#endif /* PLT_TESTER */
+
+
+
+
+ TRACE4(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "TIWha::Scan: aMaxTransmitRate %d aBand %d aNumOfChannels %d aScanType 0x%x\n", aMaxTransmitRate, aBand, aNumOfChannels, aScanType);
+
+ TRACE4(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "TIWha::Scan: aNumOfProbeRequests %d aSplitScan %d aNumOfSSID %d aSsid.Len %d\n", aNumOfProbeRequests, aSplitScan, aNumOfSSID, aSsid->iSSIDLength);
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "[WLANPDD] WHA-Scan +");
+
+ /*
+ * Configure Scan type:
+ * (aNumOfProbeRequests > 0) ==> Active scan. (TI_TRUE == aSplitScan) ==> Triggered scan
+ */
+ iTwdCtrl.iScanParams.scanType =
+ (aNumOfProbeRequests > 0) ?
+ ((TI_TRUE == aSplitScan) ? SCAN_TYPE_TRIGGERED_ACTIVE : SCAN_TYPE_NORMAL_ACTIVE) :
+ ((TI_TRUE == aSplitScan) ? SCAN_TYPE_TRIGGERED_PASSIVE : SCAN_TYPE_NORMAL_PASSIVE);
+
+ /*
+ * On "split scan" defines the access category for which the Fw waits before scanning the next channel
+ * The default value is any AC. Note: ScanSrv configures TimeOut
+ */
+ iTwdCtrl.iScanParams.Tid = AC_ANY_TID;
+
+ /* Band */
+ iTwdCtrl.iScanParams.band =
+ (aBand == WHA::KBand2dot4GHzMask) ? RADIO_BAND_2_4_GHZ : RADIO_BAND_5_0_GHZ;
+
+ /* Probe requests */
+#ifdef ENHANCE_PROB_SCAN
+ if (aNumOfProbeRequests) {
+ iTwdCtrl.iScanParams.probeReqNumber = aNumOfProbeRequests * PB_FACTOR_FOR_SG;
+ }
+#else
+ iTwdCtrl.iScanParams.probeReqNumber = aNumOfProbeRequests;
+#endif
+ iTwdCtrl.iScanParams.probeRequestRate = (ERateMask)TIWhaUtils::WhaToMaskRate (aMaxTransmitRate);
+
+ /***************** Channels ******************/
+ iTwdCtrl.iScanParams.numOfChannels = aNumOfChannels;
+
+ for (int i = 0; i < aNumOfChannels; i++)
+ {
+ for (int j = 0; j < MAC_ADDR_LEN; j++ )
+ {
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.bssId[j] = 0xFF;
+ }
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.channel = aChannels[i].iChannel;
+#ifdef ENHANCE_PROB_SCAN
+ if (aNumOfProbeRequests) {
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.maxChannelDwellTime = CONVERT_TU_2_MICRO(aChannels[i].iMaxChannelTime * MAX_TIME_FACTOR_FOR_SG);
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.minChannelDwellTime = CONVERT_TU_2_MICRO(aChannels[i].iMinChannelTime * MIN_TIME_FACTOR_FOR_SG);
+ }
+ else {
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.maxChannelDwellTime = CONVERT_TU_2_MICRO(aChannels[i].iMaxChannelTime);
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.minChannelDwellTime = CONVERT_TU_2_MICRO(aChannels[i].iMinChannelTime);
+ }
+#else
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.maxChannelDwellTime = CONVERT_TU_2_MICRO(aChannels[i].iMaxChannelTime);
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.minChannelDwellTime = CONVERT_TU_2_MICRO(aChannels[i].iMinChannelTime);
+#endif
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.earlyTerminationEvent = SCAN_ET_COND_DISABLE;
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.ETMaxNumOfAPframes = 0;
+ (iTwdCtrl.iScanParams.channelEntry[i]).normalChannelEntry.txPowerDbm = DBM2DBMDIV10(aChannels[i].iTxPowerLevel);
+ }
+
+ /* Mix the channel to increase scan result and avoid collisions */
+ if (aNumOfChannels > 4) {
+ int Channelscan = 0;
+ int Channel = 0;
+ int k = 0;
+ while (k < aNumOfChannels/2) {
+ (iTwdCtrl.iScanParams.channelEntry[Channel]).normalChannelEntry.channel = aChannels[Channelscan].iChannel;
+ Channel++;
+ Channelscan += aNumOfChannels/2;
+ if (aNumOfChannels - Channelscan <= 0) {
+ k++;
+ Channelscan = k;
+ }
+ }
+ }
+
+ /* Set SSID if present. This replaces the Template Frame configuration */
+ if ( aNumOfSSID )
+ {
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "TIWha::Scan: aSsid.Len %d\n", aSsid->iSSIDLength);
+
+ iTwdCtrl.iScanParams.desiredSsid.len = aSsid->iSSIDLength;
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void *)iTwdCtrl.iScanParams.desiredSsid.str,
+ (void *)aSsid->iSSID,
+ aSsid->iSSIDLength);
+ }
+ else
+ {
+ iTwdCtrl.iScanParams.desiredSsid.len = 0;
+ }
+
+ /* PS on scan */
+ switch (aScanType)
+ {
+ case WHA::EFgScan:
+ bEnterPS = TI_FALSE;
+ /* Internal TI mode - means "don't care" for the Power save */
+ PS_mode = POWER_SAVE_KEEP_CURRENT;
+ bScanOnDriverModeError = TI_FALSE;
+ break;
+
+ case WHA::EBgScan:
+ bEnterPS = TI_TRUE;
+ PS_mode = POWER_SAVE_ON;
+ bScanOnDriverModeError = TI_FALSE;
+ break;
+
+ case WHA::EForcedBgScan:
+ bEnterPS = TI_TRUE;
+ PS_mode = POWER_SAVE_ON;
+ bScanOnDriverModeError = TI_TRUE;
+ break;
+
+ default:
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "TIWha::Scan aScanType 0x%x:\n",aScanType);
+ /* Use some defaults */
+ bEnterPS = TI_FALSE;
+ PS_mode = POWER_SAVE_KEEP_CURRENT;
+ bScanOnDriverModeError = TI_FALSE;
+ }
+
+ /* Replace the Receive Packet while Scan to all scan resault sent to
+ LDD befor scan complete event sent */
+ TWD_RegisterCb (iTwdCtrl.hTWD,
+ TWD_EVENT_RX_RECEIVE_PACKET,
+ (TTwdCB *)TIWhaAdaptCB::ReceivePacketWhileScan,
+ this);
+ /* Set the Scan result count at the beginning of the scan to large value to continue sending resault
+ till the scan complete arrive from FW and set the correct scan result */
+ aScanResultCount = 0xFFFF;
+ /* Initiate the Sent resault to Zero */
+ SentScanResult = 0;
+
+ /* Perform Scan */
+ TI_STATUS status = TWD_Scan (iTwdCtrl.hTWD,
+ &iTwdCtrl.iScanParams,
+ SCAN_RESULT_TAG_APPLICATION_ONE_SHOT,
+ TI_FALSE,
+ bEnterPS,
+ bScanOnDriverModeError,
+ PS_mode,
+ TI_TRUE,
+ (TCmdResponseCb)TIWhaAdaptCB::ScanResponse,
+ this);
+
+ if (status != TI_OK)
+ {
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "TIWha::Scan returned status = 0x%x:\n", status);
+ }
+}
+
+/**
+* \fn StopScan
+* \brief stop scan
+* \note
+* Any symbian classes (sandbox) will be deleted in the destructor
+*
+* /param aSynchronous - not used
+* \return KSuccess
+* \sa
+*/
+void TIWha::StopScan()
+{
+ TI_STATUS status;
+
+ status = TWD_StopScan (iTwdCtrl.hTWD,
+ SCAN_RESULT_TAG_APPLICATION_ONE_SHOT,
+ TI_FALSE,
+ (TCmdResponseCb)TIWhaAdaptCB::StopScanResponse,
+ this);
+
+ if (status != TI_OK)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Stop scan failure, status=%d\n", status)
+ }
+}
+
+/**
+* \fn Join
+* \brief Join a BSS/IBSS
+*
+* \note
+* \return
+* \sa
+*/
+void TIWha::Join(
+ WHA::TOperationMode aMode,
+ const WHA::TMacAddress& aBSSID,
+ const WHA::SSSID& aSSID,
+ WHA::TBand aBand,
+ WHA::TChannelNumber aChannel,
+ TUint32 aBeaconInterval,
+ WHA::TRate aBasicRateSet,
+ TUint16 aAtimWindow,
+ WHA::TPreamble aPreambleType,
+ TBool aProbeForJoin )
+{
+ TJoinBss joinBssParams;
+ TI_STATUS status;
+
+#ifdef HT_SUPPORT
+ /* Svae the join MAC address for BA use */
+ os_memoryCopy(&iTwdCtrl.tOsContext,iJoinedMacAddress,(void*)(aBSSID.iMacAddress),aBSSID.KMacAddressLength);
+ /* If re-join remove first all BA sessions */
+ if (bJoined) {
+ TWD_CloseAllBaSessions(iTwdCtrl.hTWD);
+ }
+#endif /* HT_SUPPORT */
+
+ WLAN_OS_REPORT(("TWD_JoinBss : bssType = %d beaconInterval = %d channel = %d\n",aMode, (TUint16)aBeaconInterval, aChannel));
+ WLAN_OS_REPORT(("BSSID = %x-%x-%x-%x-%x-%x\n",aBSSID.iMacAddress[0],aBSSID.iMacAddress[1],aBSSID.iMacAddress[2],aBSSID.iMacAddress[3],aBSSID.iMacAddress[4],aBSSID.iMacAddress[5]));
+
+ /* If we are in PS mode, wake up from ELP and exit 802.11 PS mode */
+ if ( TWD_GetPsStatus (iTwdCtrl.hTWD) )
+ {
+ /* Configure H/W to awake */
+ SleepMode (WHA::KAwakeMode, TI_FALSE);
+
+ /* Exit 802.11 PS mode with dummy callbacks */
+ TWD_SetPsMode (iTwdCtrl.hTWD,
+ POWER_SAVE_OFF,
+ TI_FALSE,
+ this,
+ (TPowerSaveCompleteCb)TIWhaAdaptCB::SetPsModeCompleteDummy,
+ (TPowerSaveResponseCb)TIWhaAdaptCB::SetPsModeResponseDummy);
+ }
+
+ /*
+ * Save BSS info parameters
+ */
+ joinBssParams.bssType = (ScanBssType_e)aMode;
+ /* Save bss type for tx packets */
+ iTwdCtrl.bssType = aMode;
+ joinBssParams.pBSSID = (TUint8 *)aBSSID.iMacAddress;
+ joinBssParams.pSSID = (TUint8 *)aSSID.iSSID;
+ joinBssParams.ssidLength = aSSID.iSSIDLength;
+ joinBssParams.beaconInterval = aBeaconInterval;
+ joinBssParams.channel = aChannel;
+#ifndef HT_SUPPORT
+ joinBssParams.basicRateSet = TIWhaUtils::WhaToMaskRate (aBasicRateSet);
+#else
+ joinBssParams.basicRateSet = TIWhaUtils::HTWhaToMaskRate(aBasicRateSet,iMcsRates);
+#endif /* HT_SUPPORT */
+
+ joinBssParams.txSessionCount = 0; /* currently not used - we always use session '0' */
+ /*
+ * ATIM window of IBSS
+ * Note that when ATIM window is zero the
+ * initiated IBSS does not support power-save
+ * Note that PS on IBSS is not supported.
+ */
+
+ /*
+ * DTIM - Temporary value till the Fw will find the right value from the first beacon
+ */
+ joinBssParams.dtimInterval = TIWha_DEFAULT_DTIM_PERIOD;
+
+ /*
+ * Band value is determined out of the channel
+ */
+ if (aBand == WHA::KBand2dot4GHzMask)
+ {
+ joinBssParams.radioBand = RADIO_BAND_2_4_GHZ;
+ }
+ else if (aBand == WHA::KBand5GHzMask)
+ {
+ joinBssParams.radioBand = RADIO_BAND_5_0_GHZ;
+ }
+ else
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Invalid band=%d\n", aBand)
+ }
+
+
+ /* Set preamble MIB. The generic command response will be stopped in TIWhaAdaptCB::CommandResponse */
+ if (aPreambleType == WHA::ELongPreamble)
+ {
+ TWD_CfgPreamble (iTwdCtrl.hTWD, PREAMBLE_LONG );
+ }
+ else
+ {
+ TWD_CfgPreamble (iTwdCtrl.hTWD, PREAMBLE_SHORT );
+ }
+
+
+ /*
+ * Reset both group and pairwise keys to WEP in order to avoid
+ * a scenario which only group or pairwise are actually configured in WEP
+ */
+ iTwdCtrl.ePairwiseKeyMode = TWD_CIPHER_WEP;
+ iTwdCtrl.eGroupKeyMode = TWD_CIPHER_WEP;
+
+ /*
+ * Set new Tx fail low threshold so that FW fall back will start faster
+ * The reason is that at first we start in 54Mbps and we need to drop faster if the AP is far away.
+ * This will change after few seconds with the hConnectionTimer
+ */
+ SetTxFailLowThreshold (TIWHA_TX_FAIL_LOW_TH_FOR_CONNECTION);
+ if (bConnectionTimerRunning)
+ {
+ /* Other join started and ended soon, so just stop the timer before setting it again */
+ os_timerStop(&iTwdCtrl.tOsContext, hConnectionTimer);
+ }
+ bConnectionTimerRunning = TI_TRUE;
+ os_timerStart (&iTwdCtrl.tOsContext, hConnectionTimer, uConnectionApproxTimeMs);
+
+
+ status = TWD_CmdJoinBss (iTwdCtrl.hTWD, &joinBssParams);
+
+ if (status != TI_OK)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Start join failure, status=%d\n", status)
+ }
+
+ /* set the join flag to true */
+ bJoined = 1;
+
+ #ifdef HT_SUPPORT
+ /* Reset the BA Vectors */
+ iTxBlockAckUsageLast = 0;
+ iRxBlockAckUsageLast = 0;
+ #endif
+}
+
+/**
+* \fn SetPsMode
+* \brief SetPsMode
+*
+* \note
+* \return
+* \sa
+*/
+void TIWha::SetPsMode( WHA::TPsMode aPsMode )
+{
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "\n");
+ TI_STATUS status;
+ E80211PsMode ePsMode; /* TWD parameter for power save on/off */
+
+ if (aPsMode == WHA::KPsDisable)
+ {
+ ePsMode = POWER_SAVE_OFF;
+
+ /* Configure H/W to awake, don't wait for a response */
+ SleepMode (WHA::KAwakeMode, FALSE);
+ }
+ else
+ {
+ ePsMode = POWER_SAVE_ON;
+ }
+
+ /* Set 802.11 PS mode */
+ status = TWD_SetPsMode (iTwdCtrl.hTWD,
+ ePsMode,
+ TI_TRUE,
+ this,
+ (TPowerSaveCompleteCb)TIWhaAdaptCB::SetPsModeComplete,
+ (TPowerSaveResponseCb)TIWhaAdaptCB::SetPsModeResponse);
+
+ /* Convert status */
+ switch (status)
+ {
+ case TI_OK:
+ case POWER_SAVE_802_11_PENDING:
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, ": aPsMode 0x%x, status = %d (OK or PENDING)\n", aPsMode, status);
+ break;
+
+ case POWER_SAVE_802_11_SUCCESS:
+ case POWER_SAVE_802_11_IS_CURRENT:
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, ": aPsMode 0x%x, status = %d (IS_CURRENT || SUCCESS)\n", aPsMode, status);
+
+ /* This case will never return a response, that's why we don't 'break' this case */
+
+ default:
+ ASSERT_ERR (iTwdCtrl.hReport, "Set PS mode failure, mode=%d", aPsMode)
+ }
+}
+
+/**
+* \fn SetBssParameters
+* \brief Set AID
+*
+* \note
+* \return
+* \sa
+*/
+void TIWha::SetBssParameters(
+ TUint8 aDTIM,
+ TUint16 aAID )
+{
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "\n");
+
+ TTwdParamInfo tTwdParam;
+ TI_STATUS status;
+
+ /* Set AID */
+ tTwdParam.paramType = TWD_AID_PARAM_ID;
+ tTwdParam.content.halCtrlAid = aAID;
+ status = TWD_SetParam (iTwdCtrl.hTWD, &tTwdParam);
+
+ /* DTIM is calculated in the Fw now, this is a change from WiLink 4.0.4 */
+
+ if (status != TI_OK)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Set BSS parameters failure, status=%d\n", status)
+ }
+
+ /* Send Station connect Signaling to FW for COEX and 11N purpose */
+ TWD_CmdSetStaState(iTwdCtrl.hTWD,1,NULL,NULL);
+
+}
+
+/**
+* \fn Measure
+* \brief Not supported in Symbian
+*
+* \note
+* \return
+* \sa
+*/
+void TIWha::Measure(
+ WHA::TPowerLevel aTxPowerLevel,
+ WHA::TBand aBand,
+ WHA::TChannelNumber aChannel,
+ TUint8 aActivationDelay,
+ TUint8 aMeasurementOffset,
+ TUint8 aNumberOfMeasurementTypes,
+ const WHA::SParameterSet* aParameterSet )
+{
+ ASSERT_ERR (iTwdCtrl.hReport, "%s not supported\n", __FUNCTION__)
+}
+
+/**
+* \fn StopMeasure
+* \brief Not supported in Symbian
+*
+* \note
+* \return
+* \sa
+*/
+void TIWha::StopMeasure()
+{
+ ASSERT_ERR (iTwdCtrl.hReport, "%s not supported\n", __FUNCTION__)
+}
+
+/**
+* \fn ReadMib
+* \brief ReadMib
+*
+*
+* \note
+* \param aMib - ENUM according to wha_types.h in LDD
+* \return
+* \sa
+*/
+void TIWha::ReadMib( WHA::TMib aMib )
+{
+ void *pCb = (void*)iTwdCtrl.readMIBBuf;
+ TMib *pMibBuf = (TMib *)pCb;
+ WHA::TMib prevMib;
+ TI_STATUS status = TI_OK;
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "ReadMIB: aMib %x:\n",aMib);
+
+ prevMib = iTwdCtrl.currentReadMibID;
+ iTwdCtrl.currentReadMibID = aMib;
+
+ switch (aMib)
+ {
+ case WHA::KMibDot11StationId:
+ /*
+ * open a timer since we can't send read mib results in one context
+ */
+ os_timerStart(&iTwdCtrl.tOsContext,readDot11StationIdMibTmr,0);
+
+ return;
+
+ case WHA::KMibStatisticsTable:
+ /*
+ * Retrieve required information from the device
+ */
+ pMibBuf->aMib = MIB_statisticsTable;
+
+ status = TWD_ReadMib (iTwdCtrl.hTWD,
+ this,
+ (void *)TIWhaAdaptCB::ReadMIBResponse,
+ pCb);
+ break;
+
+ case WHA::KMibCountersTable:
+ /*
+ * Retrieve required information from the device.
+ */
+ pMibBuf->aMib = MIB_countersTable;
+ status = TWD_ReadMib (iTwdCtrl.hTWD,
+ this,
+ (void *)TIWhaAdaptCB::ReadMIBResponse,
+ pCb);
+ break;
+
+#if 0 /* Used for debug in WiLink 4.0.4 */
+ case EMIBBtCoexistenceProfile:
+ /*
+ * DEBUG ONLY:
+ */
+ paramInfo.paramType = TWD_SG_CONFIG_PARAM_ID;
+ paramInfo.content.interogateCmdCBParams.pCb = (TI_UINT8*)pCb;
+ paramInfo.content.interogateCmdCBParams.hCb = (TI_HANDLE)this;
+ paramInfo.content.interogateCmdCBParams.fCb = (void *)TIWhaAdaptCB::ReadMIBResponse;
+
+ status = TWD_GetParam (iTwdCtrl.hTWD, ¶mInfo);
+ break;
+
+ case EMIBVersion:
+ /*
+ * Retrieve firmware revision
+ */
+ paramInfo.paramType = TWD_REVISION_PARAM_ID;
+ paramInfo.content.interogateCmdCBParams.pCb = (TI_UINT8*)pCb;
+ paramInfo.content.interogateCmdCBParams.hCb = (TI_HANDLE)this;
+ paramInfo.content.interogateCmdCBParams.fCb = (void *)TIWhaAdaptCB::ReadMIBResponse;
+
+ status = TWD_GetParam (iTwdCtrl.hTWD, ¶mInfo);
+ break;
+#endif
+
+ default:
+ iTwdCtrl.currentReadMibID = prevMib;
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, ": aMib %x: Not supported\n",aMib);
+ }
+
+ if (status != TI_OK)
+ {
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, ": aMib %x: status = %d\n",aMib,status);
+ }
+}
+
+/**
+* \fn WriteMib
+* \brief WriteMib
+*
+*
+* \note
+* \param aMib - ENUM according to wha_types.h in LDD
+* \param aLength - size of aData
+* \param aData - pointer to general data
+* \param aMore - not used
+* \return
+* \sa
+*/
+WHA::TStatus TIWha::WriteMib(
+ WHA::TMib aMib,
+ TUint16 aLength,
+ const void* aData,
+ TBool aMore )
+{
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, " Mib = 0x%x\n",aMib);
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "WriteMIB - aMib = %d, aData\n", aMib);
+
+ switch (aMib)
+ {
+ case WHA::KMibDot11MaxReceiveLifetime:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ Dot11MaxReceiveLifeTime (aData))
+ break;
+
+ case WHA::KMibDot11SlotTime:
+ /*
+ * Converts the WriteMIB back to the correlated whal command
+ * and activate the WHAL Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetSlotTime (aData))
+ break;
+
+ case WHA::KMibDot11GroupAddressesTable:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetDot11GroupAddrTable (aData))
+
+ break;
+
+ case WHA::KMibDot11WepDefaultKeyId:
+ /*
+ * Set the default Key Id
+ */
+
+ /*
+ * NOTE: Setting default key will cause the securityMode to change into WEP
+ */
+ ASSERT_MIB(iTwdCtrl.hReport, aMib,
+ SetDefaultKeyID (aData))
+ break;
+
+ case WHA::KMibDot11CurrentTxPowerLevel:
+
+ /*
+ * NOTE: no assert here. This function may return:
+ * KSuccess - if the same value is already configured
+ * KPending - if operation has succeeded
+ * KFailed - UnKnown error
+ */
+ return SetCurrentTxPowerLevel ( aData);
+
+ case WHA::KMibDot11RTSThreshold:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ Dot11RTSThreshold (aData))
+ break;
+
+ case WHA::KMibCtsToSelf:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ CtsToSelf (aData))
+ break;
+
+ case WHA::KMibArpIpAddressTable:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetArpIpAddrTable (aData))
+ break;
+
+ case WHA::KMibTemplateFrame:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetTemplateFrame (aData))
+ break;
+
+ case WHA::KMibRxFilter:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetRxFilter (aData))
+ break;
+
+ case WHA::KMibBeaconFilterIeTable:
+ /*
+ * Converts the beacon filter IE table configuration
+ * to TWD parameters and sets specific configuration
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetBeaconFilterIETable (aData))
+ break;
+
+ case WHA::KMibBeaconFilterEnable:
+ /*
+ * Converts beacon filtering configuration
+ * to TWD parameters and sets specific configuration
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetBeaconFilterEnable ( aData))
+ break;
+
+ case WHA::KMibSleepMode:
+ /*
+ * Set user sleep mode
+ */
+ iTwdCtrl.sleepMode = *(WHA::TSleepMode *)aData;
+
+ /* If we are in 802.11 PS mode then we should enter new sleepMode (otherwise we just save it) */
+ if (TWD_GetPsStatus (iTwdCtrl.hTWD))
+ {
+ /*
+ * NOTE: no assert here. This function may return:
+ * KSuccess - if the same value is already configured
+ * KPending - if operation has succeeded
+ */
+ return SleepMode ( iTwdCtrl.sleepMode, TI_TRUE);
+ }
+
+ else
+ {
+ return WHA::KSuccess;
+ }
+
+ case WHA::KMibWlanWakeUpInterval:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ WakeUpConditions ( aData))
+
+ break;
+
+ case WHA::KMibBeaconLostCount:
+ /*
+ * Configure the amount of consecutive beacons that can be lost
+ * before the WLAN device should report BSSLost indication to the
+ * WLAN host driver.
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetBeaconLostCount (aData))
+ break;
+
+ case WHA::KMibRcpiThreshold:
+ /*
+ * Configure the threshold value for RCPI indication to the WLAN
+ * host driver. RcpiIndication event is triggered when the RCPI goes
+ * below or over the threshold.
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ SetRcpiThreshold (aData))
+ break;
+
+
+ case WHA::KMibTxRatePolicy:
+ /*
+ * Converts the WriteMIB back to the correlated TWD command
+ * and activate the TWD Set command
+ */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ TxRatePolicy ( aLength, aData))
+ break;
+
+/* SG Mibs should be integrated to Symbian */
+ case 0x110F: /* Should be KMibbtCoexistenceMode */
+
+ /* Call the TWD with the specific mode of Bt */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ btCoexistenceMode ( aLength, aData))
+ break;
+
+ case 0x1110: /* should be KMibbtCoexistenceProfile */
+
+ /* Call the TWD with the parameters of Bt */
+ ASSERT_MIB (iTwdCtrl.hReport, aMib,
+ btCoexistenceProfile ( aLength, aData))
+ break;
+
+#ifdef HT_SUPPORT
+ case WHA::KMibHtCapabilities:
+ /* send the HT Capabilties to FW */
+ SetHTCapabilities ((WHA::ShtCapabilities*)aData);
+ break;
+
+ case WHA::KMibHtBssOperation:
+ /* send the HT Information to FW */
+ SetHTInformation ((WHA::ShtBssOperation*)aData);
+ break;
+
+ case WHA::KMibHtBlockAckConfigure:
+ /* BA Initiator and Receiver to FW */
+ if (ConfigureBA ((WHA::ShtBlockAckConfigure*)aData) == TI_NOK)
+ {
+ /* Return success for not stuck the LDD */
+ /* This value return when ConfigureBA do nothing */
+ return WHA::KSuccess;
+ }
+ break;
+#endif /* HT_SUPPORT */
+
+ case WHA::KMibTxAutoRatePolicy:
+ /* Set the supported rates */
+ TxAutoRatePolicy((WHA::StxAutoRatePolicy*)aData);
+ break;
+
+
+ #ifdef TI_TEST
+ case EMIBPltTest:
+
+ #ifdef PLT_TESTER
+ iRealPlt = 1;
+ #endif
+ os_printf("EMIBPltTest");
+ PltTester(aData);
+ break;
+
+ /* FW statistics */
+ case TWD_FW_PRINT_STATISTICS:
+ TWD_ItrStatistics (iTwdCtrl.hTWD, (void*)TIWhaAdaptCB::StatisticsReadResponse, this, &(((TTwd *)(iTwdCtrl.hTWD))->acxStatistic));
+ break;
+
+ /* Get AVR RSSI */
+ case AVR_RSSI:
+ TWD_ItrRSSI (iTwdCtrl.hTWD, (void*)TIWhaAdaptCB::AvrRssiReadResponse, this, &roamingStatistics);
+ break;
+
+ case QOS_CHANGE_QEUEU: /* change output Queue */
+ ChangeQueue(aData);
+ break;
+
+ case SET_POWER_LEVEL: // KMibDot11PowerSavePowerLevel
+ SetPowerSavePowerLevel((void *)aData);
+ #endif /* TI_TEST */
+
+ default:
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, ": aMib %x: Not supported\n",aMib);
+ return WHA::KSuccess;
+
+ } /* End switch */
+
+ /* Indicate that the WriteMIB will return a Response in a different context */
+ return WHA::KPending;
+}
+
+
+/**
+* \fn SetSlotTime
+*
+* \param aData - TSlotTime
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::SetSlotTime (const void *aData)
+{
+ ESlotTime slot = PHY_SLOT_TIME_LONG;
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "WRITE_MIB,TIWha::, slot time = 0x%x\n", *((WHA::TSlotTime *)aData));
+
+ switch (*((WHA::TSlotTime *)aData))
+ {
+ case WHA::KSlotTime9:
+ slot = PHY_SLOT_TIME_SHORT;
+ break;
+ case WHA::KSlotTime20:
+ slot = PHY_SLOT_TIME_LONG;
+ break;
+ default:
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "TIWha:: recieving slot time = %d !!!\n",*((WHA::TSlotTime *)aData));
+ }
+
+ return (TWD_CfgSlotTime (iTwdCtrl.hTWD, slot) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn Dot11MaxReceiveLifeTime
+*
+* \param aData - TUint32*
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::Dot11MaxReceiveLifeTime (const void *aData)
+{
+ TMib Mib;
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "TIWha::Dot11MaxReceiveLifeTime *aData= 0x%x\n", *(TUint32 *)(aData));
+
+ Mib.aMib = MIB_dot11MaxReceiveLifetime;
+ Mib.aData.MaxReceiveLifeTime = *(TUint32 *)(aData);
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &Mib) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetRxFilter
+*
+*
+* \note - Always filter BSSID
+* \param aData - not used
+* \return
+* \sa
+*/
+WHA::TStatus TIWha::SetRxFilter (const void *aData)
+{
+ TMib Mib;
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SetRxFilter,*aData= 0x%x\n",*(TUint8 *)aData);
+
+ Mib.aMib = MIB_rxFilter;
+ /*
+ * Note that we ignore the requested configuration, since any other configuration is
+ * causing a crash in the LDD. This is agreed with Palau
+ */
+ Mib.aData.RxFilter = MIB_RX_FILTER_BSSID_SET;
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &Mib) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetCurrentTxPowerLevel
+*
+*
+* \note -
+* \param aData -TPowerLevel (Power level in dbm)
+* \return
+* KSuccess - if the same value is already configured
+* KPending - if operation has succeeded
+* KFailed - UnKnown error
+* \sa
+*/
+WHA::TStatus TIWha::SetCurrentTxPowerLevel (const void *aData)
+{
+ TTwdParamInfo param;
+
+ /* Activates the TWD_SetParam function */
+ param.paramType = TWD_TX_POWER_PARAM_ID;
+ param.content.halCtrlTxPowerDbm = DBM2DBMDIV10((*((WHA::TPowerLevel *) aData)));
+
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SetCurrentTxPowerLevel, Dbm = %d Power DBm*10 = %d \n", *((WHA::TPowerLevel *) aData), param.content.halCtrlTxPowerDbm);
+
+ TI_STATUS status = TWD_SetParam (iTwdCtrl.hTWD, ¶m);
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SetCurrentTxPowerLevel, status = %d \n",status);
+
+ switch (status)
+ {
+ case TI_OK: return WHA::KPending;
+ case PARAM_ALREADY_CONFIGURED: return WHA::KSuccess;
+ default:
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR , "SetCurrentTxPowerLevel, returned status = %d Power DBm*10 = %d \n", status, param.content.halCtrlTxPowerDbm);
+ return WHA::KFailed;
+
+ }
+}
+
+/**
+* \fn SetTemplateFrame
+*
+*
+* \note -
+* \param aData - StemplateFrame defined in wha_mib.h inside the LDD
+* \return
+* \sa
+*/
+WHA::TStatus TIWha::SetTemplateFrame (const void *aData)
+{
+ TMib Mib;
+ WHA::StemplateFrame* pMIBTemplateFrame = (WHA::StemplateFrame *)aData;
+
+ TRACE3(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SetTemplateFrame aLength= %d,aRate= %d aType = %d\n", pMIBTemplateFrame->iLength, pMIBTemplateFrame->iInitialTransmitRate, pMIBTemplateFrame->iFrameType);
+
+ Mib.aMib = MIB_templateFrame;
+ Mib.aData.TemplateFrame.FrameType = TIWhaUtils::WhaToTwdFrameType(pMIBTemplateFrame->iFrameType);
+ Mib.aData.TemplateFrame.Rate = (TI_UINT32)TIWhaUtils::WhaToTwdRate (pMIBTemplateFrame->iInitialTransmitRate);
+ Mib.aData.TemplateFrame.Length = pMIBTemplateFrame->iLength;
+
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void *)Mib.aData.TemplateFrame.Data,
+ (void *)pMIBTemplateFrame->iTemplateData,
+ pMIBTemplateFrame->iLength);
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &Mib) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetDot11GroupAddrTable
+*
+* \param aData - *Sdot11GroupAddressesTable
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::SetDot11GroupAddrTable (const void *aData)
+{
+ WHA::Sdot11GroupAddressesTable *pTable = (WHA::Sdot11GroupAddressesTable *)aData;
+ TMib Mib;
+ int i;
+
+ if (NULL == aData)
+ {
+ return WHA::KFailed;
+ }
+
+
+/* TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, TIWLANWHA_MODULE_LOG, MSG_2159, Mib.aMib, *(TUint32 *)(aData));*/
+
+ Mib.aMib = MIB_dot11GroupAddressesTable;
+ Mib.aData.GroupAddressTable.bFilteringEnable = pTable->iEnable;
+ Mib.aData.GroupAddressTable.nNumberOfAddresses = pTable->iNumOfAddrs;
+
+ for (i = 0; i < Mib.aData.GroupAddressTable.nNumberOfAddresses; i++)
+ {
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void *)Mib.aData.GroupAddressTable.aGroupTable[i],
+ (void *)((TI_UINT8*)pTable->iAddrData + i*MAC_ADDR_LEN),
+ MAC_ADDR_LEN);
+ }
+
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SetDot11GroupAddrTable -Enabled=%d-num=%d\n" , Mib.aData.GroupAddressTable.bFilteringEnable, Mib.aData.GroupAddressTable.nNumberOfAddresses);
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &Mib) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetDefaultKeyID
+*
+* \param aData - *Sdot11WepDefaultKeyId
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::SetDefaultKeyID (const void *aData)
+{
+ TTwdParamInfo param;
+
+ // TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, TIWLANWHA_MODULE_LOG, MSG_2161,((WHA::Sdot11WepDefaultKeyId*)aData)->iDot11WepDefaultKeyId);
+
+ /* Set security mode to WEP */
+ param.paramType = TWD_RSN_SECURITY_MODE_PARAM_ID;
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_WEP;
+ TWD_SetParam (iTwdCtrl.hTWD, ¶m);
+
+ param.paramType = TWD_RSN_DEFAULT_KEY_ID_PARAM_ID;
+ param.content.configureCmdCBParams.pCb = (void*)aData;
+ param.content.configureCmdCBParams.fCb = NULL;
+ param.content.configureCmdCBParams.hCb = NULL;
+
+ return (TWD_SetParam (iTwdCtrl.hTWD, ¶m) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn Dot11RTSThreshold
+*
+* \param aData - *Sdot11RTSThreshold
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::Dot11RTSThreshold (const void *aData)
+{
+ TTwdParamInfo param;
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "Dot11RTSThreshold ,*aData= 0x%x\n",((WHA::Sdot11RTSThreshold*)aData)->iDot11RTSThreshold);
+
+ param.paramType = TWD_RTS_THRESHOLD_PARAM_ID;
+ param.content.halCtrlRtsThreshold = ((WHA::Sdot11RTSThreshold*)aData)->iDot11RTSThreshold;
+
+ return (TWD_SetParam (iTwdCtrl.hTWD, ¶m) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn CtsToSelf
+*
+* \param aData - *SctsToSelf
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::CtsToSelf (const void *aData)
+{
+ TMib Mib;
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "CtsToSelf, *aData= 0x%x\n", ((WHA::SctsToSelf *)aData)->iCtsToSelf);
+
+ if (NULL == aData)
+ {
+ return PARAM_VALUE_NOT_VALID;
+ }
+
+ Mib.aMib = MIB_ctsToSelf;
+ Mib.aData.CTSToSelfEnable = (TI_UINT32)((WHA::SctsToSelf *)aData)->iCtsToSelf;
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &Mib) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetArpIpAddrTable
+*
+* \param aData - *SarpIpAddressTable
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::SetArpIpAddrTable (const void *aData)
+{
+ TMib Mib;
+ WHA::SarpIpAddressTable *pTable = (WHA::SarpIpAddressTable *)aData;
+
+ if (NULL == aData)
+ {
+ return PARAM_VALUE_NOT_VALID;
+ }
+
+ Mib.aMib = MIB_arpIpAddressesTable;
+ Mib.aData.ArpIpAddressesTable.FilteringEnable = pTable->iEnable;
+
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ Mib.aData.ArpIpAddressesTable.addr,
+ (void*)&pTable->iIpV4Addr,
+ sizeof(pTable->iIpV4Addr));
+
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SetarpIpAddressesTable,*aData= 0x%x addr = 0x%x\n", pTable->iIpV4Addr, *(TI_UINT32*)Mib.aData.ArpIpAddressesTable.addr);
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &Mib) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetBeaconFilterIETable
+*
+* \param aData - *SbeaconFilterIeTable
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::SetBeaconFilterIETable (const void *aData)
+{
+ WHA::SbeaconFilterIeTable *pTable = (WHA::SbeaconFilterIeTable *)aData;
+ TMib Mib;
+
+ if (NULL == aData)
+ {
+ return WHA::KFailed;
+ }
+
+ Mib.aMib = MIB_beaconFilterIETable;
+ Mib.aData.BeaconFilter.iNumberOfIEs = pTable->iNumofElems;
+
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void *)Mib.aData.BeaconFilter.iIETable,
+ (void *)pTable->iIeTable,
+ sizeof(Mib.aData.BeaconFilter.iIETable));
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &Mib) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetBeaconFilterEnable
+*
+* \param aData - *SbeaconFilterEnable
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::SetBeaconFilterEnable (const void *aData)
+{
+ WHA::SbeaconFilterEnable *pEnable = (WHA::SbeaconFilterEnable *)aData;
+
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SetBeaconFilterEnable, *beaconFilterEnable Data= 0x%x 0x%x\n", pEnable->iEnable, pEnable->iCount);
+
+ return (TWD_CfgBeaconFilterOpt (iTwdCtrl.hTWD, pEnable->iEnable,
+ (TI_UINT8)pEnable->iCount) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SleepMode
+*
+* \param aSleepMode - TSleepMode
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::SleepMode (
+ const WHA::TSleepMode& aSleepMode, /* aSleepMode */
+ TBool bResponse) /* whether Response required */
+{
+ EPowerPolicy powerPolicy;
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SleepMode = %d\n",aSleepMode);
+
+ /* Save response request flag in the context */
+ iTwdCtrl.bResponse = bResponse;
+
+ switch (aSleepMode)
+ {
+ case WHA::KAwakeMode:
+ powerPolicy = POWERAUTHO_POLICY_AWAKE;
+ break;
+ case WHA::KPowerDownMode:
+ powerPolicy = POWERAUTHO_POLICY_ELP;
+ break;
+ case WHA::KLowPowerMode:
+ powerPolicy = POWERAUTHO_POLICY_ELP;
+ break;
+ default:
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "Unknown SleepMode %d, setting to AWAKE\n",aSleepMode);
+ powerPolicy = POWERAUTHO_POLICY_AWAKE;
+ }
+
+/* Currently No support for ELP -- Remove comment when ELP will be added */
+ //#ifndef ELP_ENABLED
+ /* Disabling Low Power (ELP) mode */
+ powerPolicy = POWERAUTHO_POLICY_AWAKE;
+ //#endif
+
+ /* Call the power authentication module to set the new power policy */
+ return (TWD_CfgSleepAuth (iTwdCtrl.hTWD, powerPolicy) == TI_OK) ? WHA::KPending : WHA::KSuccess;
+}
+
+/**
+* \fn WakeUpConditions
+*
+* \param aData - *SwlanWakeUpInterval
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::WakeUpConditions (const void *aData)
+{
+ WHA::SwlanWakeUpInterval *pWakeUp = (WHA::SwlanWakeUpInterval *)aData;
+ TPowerMgmtConfig PowerMgmtConfig;
+
+ PowerMgmtConfig.listenInterval = pWakeUp->iListenInterval;
+ PowerMgmtConfig.tnetWakeupOn = (ETnetWakeOn)pWakeUp->iMode;
+
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "WakeUpConditions ,listenInterval = 0x%x ,iWakeUpMode = 0x%x \n", PowerMgmtConfig.listenInterval, PowerMgmtConfig.tnetWakeupOn);
+
+ return (TWD_CfgWakeUpCondition (iTwdCtrl.hTWD, &PowerMgmtConfig) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetBeaconLostCount
+*
+* \param aData - *SbeaconLostCount
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::SetBeaconLostCount (const void *aData)
+{
+ TRroamingTriggerParams roamingTriggerCmd;
+
+ /* Configure TWD with 'No BSS' thresholds */
+ roamingTriggerCmd.BssLossTimeout = NO_BEACON_DEFAULT_TIMEOUT;
+ roamingTriggerCmd.TsfMissThreshold = (TI_UINT16)((WHA::SbeaconLostCount *)aData)->iLostCount;
+
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "SetBeaconLostCount ,BssLossTimeout = 0x%x ,TsfMissThreshold = 0x%x \n", roamingTriggerCmd.BssLossTimeout, roamingTriggerCmd.TsfMissThreshold);
+
+ return (TWD_CfgConnMonitParams (iTwdCtrl.hTWD, &roamingTriggerCmd) == TI_OK)
+ ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetRcpiThreshold
+*
+* \param aData - *SrcpiThreshold
+* \description - we are supporting RCI
+* \return KSuccess or KFailed
+* \sa
+*/
+
+WHA::TStatus TIWha::SetRcpiThreshold (const void *aData)
+{
+
+ RssiSnrTriggerCfg_t tTriggerCfg;
+ WHA::TRcpi iRCPI = *(WHA::TRcpi *)aData;
+
+ tTriggerCfg.index = TRIGGER_EVENT_LOW_RSSI;
+ if (iRCPI<= TIWha_MIN_RCPI_VAL)
+ {
+ tTriggerCfg.threshold = TIWha_MIN_RSSI_VAL;
+ }
+ else
+ {
+ if (iRCPI >= TIWha_MAX_RCPI_VAL)
+ {
+ tTriggerCfg.threshold = TIWha_MAX_RSSI_VAL;
+ }
+ else
+ {
+ tTriggerCfg.threshold = (iRCPI / 2) + TIWha_MIN_RSSI_VAL;
+ }
+
+ }
+
+ tTriggerCfg.pacing = TRIGGER_LOW_RSSI_PACING;
+ tTriggerCfg.metric = METRIC_EVENT_RSSI_BEACON;
+ tTriggerCfg.type = RX_QUALITY_EVENT_EDGE;
+ tTriggerCfg.direction = RSSI_EVENT_DIR_LOW;
+ tTriggerCfg.hystersis = 3;
+ tTriggerCfg.enable = TI_TRUE;
+
+
+
+ if (TI_OK == TWD_CfgRssiSnrTrigger (iTwdCtrl.hTWD, &tTriggerCfg))
+ {
+ return WHA::KSuccess;
+ }
+ else
+ {
+ return WHA::KFailed;
+ }
+
+
+}
+
+
+/**
+* \fn TxRatePolicy
+*
+* \param aData - *StxRatePolicy
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::TxRatePolicy (
+ TUint32 aLength, /* Specifies the length of the MIB */
+ const void *aData) /* Pointer to the MIB data */
+{
+ TMib Mib;
+ TUint32 i;
+ WHA::StxRatePolicy *pPolicy = (WHA::StxRatePolicy*) aData;
+
+ if (NULL == aData)
+ {
+ return PARAM_VALUE_NOT_VALID;
+ }
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "TxRatePolicy Num of Policies = %d \n",pPolicy->iNumOfPolicyObjects);
+
+ if (pPolicy->iNumOfPolicyObjects > MAX_NUM_OF_TX_RATE_CLASS_POLICIES)
+ {
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "ERROR: Can't configure more than %d Classes",MAX_NUM_OF_TX_RATE_CLASS_POLICIES);
+ }
+
+ Mib.aMib = MIB_txRatePolicy;
+ /* The length field is not in use */
+ Mib.Length = 0;
+ Mib.aData.txRatePolicy.numOfRateClasses = pPolicy->iNumOfPolicyObjects;
+
+ for (i = 0; i < pPolicy->iNumOfPolicyObjects; i++)
+ {
+
+ Mib.aData.txRatePolicy.rateClass[i].txEnabledRates = 0;
+
+ /* MCS rates not support in Symbian structure */
+ (pPolicy->iTxRateClass[i].iTxPolicy54) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_54MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy48) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_48MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy36) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_36MBPS : NULL;
+ /* 33Mbps not support in TWD */
+ (pPolicy->iTxRateClass[i].iTxPolicy24) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_24MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy22) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_22MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy18) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_18MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy12) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_12MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy11) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_11MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy9) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_9MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy6) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_6MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy5_5) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_5_5MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy2) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_2MBPS : NULL;
+ (pPolicy->iTxRateClass[i].iTxPolicy1) ? Mib.aData.txRatePolicy.rateClass[i].txEnabledRates |= HW_BIT_RATE_1MBPS : NULL;
+
+ //os_printf("Policy[%d] is %x ",i,Mib.aData.txRatePolicy.rateClass[i]);
+ Mib.aData.txRatePolicy.rateClass[i].longRetryLimit = pPolicy->iTxRateClass[i].iLongRetryLimit;
+ Mib.aData.txRatePolicy.rateClass[i].shortRetryLimit = pPolicy->iTxRateClass[i].iShortRetryLimit;
+
+ }
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &Mib) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+ /*return WHA::KSuccess;*/
+}
+
+
+/**
+* \fn btCoexistenceMode
+*
+* \param aData - *TBTCoexMode
+* \ indicats 3 operation modes
+ * 0 - Disable
+ * 1 - Enable
+ * 2 - Auto
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::btCoexistenceMode(TUint32 aLength, const void *aData)
+{
+ ESoftGeminiEnableModes *pSGMode = (ESoftGeminiEnableModes*)aData;
+ TTwdParamInfo iParamInfo;
+
+ iParamInfo.paramType = TWD_SG_ENABLE_PARAM_ID;
+ iParamInfo.paramLength = aLength;
+ switch (*pSGMode)
+ {
+ case SG_PROTECTIVE:
+ case SG_OPPORTUNISTIC:
+ iParamInfo.content.SoftGeminiEnable = SG_OPPORTUNISTIC;
+ TWD_SetParam(iTwdCtrl.hTWD,&iParamInfo);
+ break;
+
+ case SG_DISABLE:
+ iParamInfo.content.SoftGeminiEnable = SG_DISABLE;
+ TWD_SetParam(iTwdCtrl.hTWD,&iParamInfo);
+ break;
+
+ default:
+TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "btCoexistenceMode - Value Invalide = %d",*pSGMode);
+ return WHA::KFailed;
+ }
+ return WHA::KSuccess;
+}
+
+/**
+* \fn btCoexistenceProfile
+*
+* \param aData - *ESoftGeminiEnableProfile
+* \ indicats 3 operation modes
+ * 0 - Data-Data
+ * 1 - VOIP-A2DP/Data
+ * 2 - Data -A2DP
+* \return KSuccess or KFailed
+* \sa
+*/
+WHA::TStatus TIWha::btCoexistenceProfile(TUint32 aLength, const void *aData)
+{
+ ESoftGeminiEnableProfile* pSGProfile = (ESoftGeminiEnableProfile*)aData;
+ TTwdParamInfo iParamInfo;
+
+ iParamInfo.paramType = TWD_SG_CONFIG_PARAM_ID;
+ iParamInfo.paramLength = aLength;
+
+
+ switch (*pSGProfile)
+ {
+ case BtCoexProfData:
+ iSgParams.coexParams[SOFT_GEMINI_BT_LOAD_RATIO] = 50;
+ break;
+
+ case BtCoexProfDataLowLatency:
+ iSgParams.coexParams[SOFT_GEMINI_BT_LOAD_RATIO] = 50;
+ break;
+
+ case BtCoexProfA2DP:
+ iSgParams.coexParams[SOFT_GEMINI_BT_LOAD_RATIO] = 71;
+ break;
+
+ default:
+TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "btCoexistenceProfile - Value Invalide = %d",*pSGProfile);
+ return WHA::KFailed;
+ }
+
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iParamInfo.content.SoftGeminiParam,&iSgParams,sizeof(TSoftGeminiParams));
+ TWD_SetParam(iTwdCtrl.hTWD,&iParamInfo);
+ return WHA::KSuccess;
+}
+
+
+/**
+* \fn TConvertTwdHtCapa2SHtCapa
+* \brief Convert the TTwdHtCapabilities structure to WHA::SHtCapabilities structure
+*
+* \param TTwdHtCapabilities
+* \param WHA::SHtCapabilities
+*
+* /note
+*
+* /return none
+*/
+#ifdef HT_SUPPORT
+void TIWha::TConvertTwdHtCapa2SHtCapa (TTwdHtCapabilities* pTwdHtCapabilities,WHA::SHtCapabilities* pHtCapabilities)
+{
+ os_memoryZero (&iTwdCtrl.tOsContext,pHtCapabilities,sizeof(WHA::SHtCapabilities));
+ pHtCapabilities->iHTCapabilitiesBitMask = (
+ #ifdef GREENFIELD_FRAME_SUPPORT
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_GREENFIELD_FRAME_FORMAT) << 2) |
+ #endif
+ #ifdef SHORT_GI_SUPPORT
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_SHORT_GI_FOR_20MHZ_PACKETS) << 2) |
+ #endif
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_SHORT_GI_FOR_40MHZ_PACKETS) << 2) |
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_SUPPORT_FOR_STBC_IN_TRANSMISSION) << 2) |
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_DELAYED_BLOCK_ACK) << 2) |
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_DSSS_CCK_IN_40_MHZ) << 2) |
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_LSIG_TXOP_PROTECTION) << 3) |
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_PCO) << 3) |
+ ((pTwdHtCapabilities->uHTCapabilitiesBitMask & CAP_BIT_MASK_LDPC_CODING) >> 8));
+
+ pHtCapabilities->iRxMaxDataRate = pTwdHtCapabilities->uRxMaxDataRate;
+
+ pHtCapabilities->iChannelWidth = pTwdHtCapabilities->uChannelWidth;
+
+#ifdef RXSTBC_SUPPORT
+ pHtCapabilities->iRxStbc = pTwdHtCapabilities->uRxSTBC;
+#else
+ pHtCapabilities->iRxStbc = RXSTBC_NOT_SUPPORTED;
+#endif
+
+ pHtCapabilities->iMaxAmsdu = pTwdHtCapabilities->uMaxAMSDU;
+
+ pHtCapabilities->iMaxAmpdu = pTwdHtCapabilities->uMaxAMPDU;
+
+ pHtCapabilities->iAmpduSpacing = pTwdHtCapabilities->uAMPDUSpacing;
+
+ //pHtCapabilities->iRxMcs = pTwdHtCapabilities->aRxMCS;
+ os_memoryCopy(&iTwdCtrl.tOsContext,pHtCapabilities->iRxMcs,pTwdHtCapabilities->aRxMCS,sizeof(WHA::THtMcsSet));
+
+ //pHtCapabilities->iTxMcs = pTwdHtCapabilities->aTxMCS;
+
+ os_memoryCopy(&iTwdCtrl.tOsContext,pHtCapabilities->iTxMcs,pTwdHtCapabilities->aTxMCS,sizeof(WHA::THtMcsSet));
+
+ pHtCapabilities->iPcoTransTime = pTwdHtCapabilities->uPCOTransTime;
+
+ pHtCapabilities->iMcsFeedback = pTwdHtCapabilities->uMCSFeedback;
+}
+#endif /* HT_SUPPORT */
+
+/**
+* \fn SetHTCapabilities
+* \brief set the HT capabilities of the AP coming from become/prob resp to FW
+*
+* \param ShtCapabilities
+*
+* /note
+*
+* /return OK for sucsses NOK for failed
+*/
+#ifdef HT_SUPPORT
+WHA::TStatus TIWha::SetHTCapabilities (WHA::ShtCapabilities* pApCapabilities)
+{
+ Tdot11HtCapabilitiesUnparse aHtCapabilitiesUnparse;
+ Tdot11HtCapabilitiesUnparse* pHtCapabilitiesUnparse = &aHtCapabilitiesUnparse;
+
+ os_memoryZero(&iTwdCtrl.tOsContext,pHtCapabilitiesUnparse, sizeof(Tdot11HtCapabilitiesUnparse));
+ /* Etract the HT Capabilities for FW, at this poin we ignore the HT Control field bit
+ since no support in FW */
+ pHtCapabilitiesUnparse->aHtCapabilitiesIe[1] |= (((pApCapabilities->iPeerFeatures & WHA::KGreenfieldFormat) ? HT_CAP_GREENFIELD_FRAME_FORMAT_BITMASK : 0) |
+ ((pApCapabilities->iPeerFeatures & WHA::KShortGiFor20Mhz) ? HT_CAP_SHORT_GI_FOR_20MHZ_BITMASK : 0));
+
+ pHtCapabilitiesUnparse->aHtCapabilitiesIe[0] |= (((pApCapabilities->iPeerFeatures & WHA::KLsigTxopProtection) ? (HT_CAP_LSIG_TXOP_PROTECTION_BITMASK >> 8) : 0) |
+ ((pApCapabilities->iPeerFeatures & WHA::KReverseDirectionResp) ? (HT_EXT_RD_INITIATION_BITMASK >> 8) : 0));
+
+
+ pHtCapabilitiesUnparse->aHtCapabilitiesIe[0] |= ((pApCapabilities->iPeerFeatures & WHA::KHtcField) ? (HT_EXT_HT_CONTROL_FIELDS_BITMASK >> 8) : 0);
+
+ /* Extract the MAX MPDU and MPDU Spacing */
+ pHtCapabilitiesUnparse->aHtCapabilitiesIe[HT_CAP_AMPDU_PARAMETERS_FIELD_OFFSET] = ((pApCapabilities->iMaxAmpduLength) |
+ (pApCapabilities->iAmpduSpacing << 2));
+
+
+ return TWD_CfgSetFwHtCapabilities(iTwdCtrl.hTWD,pHtCapabilitiesUnparse,(pApCapabilities->iHtSupport > 0 ? TI_TRUE : TI_FALSE));
+}
+#endif /* HT_SUPPORT */
+
+
+/**
+* \fn SetHTInformation
+* \brief set the HT Information to FW
+*
+* \param ShtBssOperation
+*
+* /note
+*
+* /return OK for sucsses NOK for failed
+*/
+#ifdef HT_SUPPORT
+WHA::TStatus TIWha::SetHTInformation (WHA::ShtBssOperation* pHtInformarion)
+{
+ Tdot11HtInformationUnparse aHtInformationUnparse;
+ Tdot11HtInformationUnparse* pHtInformationUnparse = &aHtInformationUnparse;
+
+ pHtInformationUnparse->aHtInformationIe[1] = ((pHtInformarion->iInfo & WHA::ShtBssOperation::KRifsPermitted) ? WHA::ShtBssOperation::KRifsPermitted : 0);
+ pHtInformationUnparse->aHtInformationIe[2] = pHtInformarion->iOpMode;
+ pHtInformationUnparse->aHtInformationIe[3] = (((pHtInformarion->iInfo & WHA::ShtBssOperation::KNonGreenfieldPresent) ? HT_INF_NON_GF_PRES_BITMASK : 0));
+
+ pHtInformationUnparse->aHtInformationIe[4] = ((pHtInformarion->iInfo & WHA::ShtBssOperation::KDualCtsProtReq) ? HT_INF_DUAL_BEACON_BITMASK : 0);
+
+ /* Save the MCS rates for use in Join command at basic rates */
+ os_memoryCopy(&iTwdCtrl.tOsContext,iMcsRates,pHtInformarion->iMcsSet,sizeof(WHA::THtMcsSet));
+
+ return TWD_CfgSetFwHtInformation(iTwdCtrl.hTWD,pHtInformationUnparse);
+}
+#endif /* HT_SUPPORT */
+
+
+/**
+* \fn ConfigureBA
+* \brief configure the BA initiator and BA receiver
+*
+* \param ShtBssOperation
+*
+* /note
+*
+* /return OK for sucsses NOK for failed
+*/
+#ifdef HT_SUPPORT
+WHA::TStatus TIWha::ConfigureBA (WHA::ShtBlockAckConfigure* pBABitMask)
+{
+ WHA::TStatus status = TI_NOK;
+ iBACounertRespone = 0;
+#ifndef __AMSDU_MODE__
+
+// Check for which TID is enabled for BA session
+
+#ifdef TX_BA_SUPPORT
+ /* Set all Transmit BA Support */
+ for (int i = 0;i <= MAX_NUM_OF_802_1d_TAGS; i++)
+ {
+ if (((pBABitMask->iTxBlockAckUsage >> i) & 0x1) > ((iTxBlockAckUsageLast >> i) & 0x1))
+ {
+ status = TWD_CfgSetBaInitiator(iTwdCtrl.hTWD,i,TRUE,iJoinedMacAddress,RX_QUEUE_WIN_SIZE,HT_BA_INACTIVITY_TIMEOUT_DEF);
+ iBACounertRespone++;
+ }
+ else {
+ if (((pBABitMask->iTxBlockAckUsage >> i) & 0x1) < ((iTxBlockAckUsageLast >> i) & 0x1))
+ {
+ status = TWD_CfgSetBaInitiator(iTwdCtrl.hTWD,i,FALSE,iJoinedMacAddress,RX_QUEUE_WIN_SIZE,HT_BA_INACTIVITY_TIMEOUT_DEF);
+ iBACounertRespone++;
+ }
+ }
+ }
+ iTxBlockAckUsageLast = pBABitMask->iTxBlockAckUsage;
+#endif
+
+ /* Set all Receive BA */
+
+ for (int i = 0;i <= MAX_NUM_OF_802_1d_TAGS; i++)
+ {
+ if (((pBABitMask->iRxBlockAckUsage >> i) & 0x1) > ((iRxBlockAckUsageLast >> i) & 0x1))
+ {
+ status = TWD_CfgSetBaReceiver(iTwdCtrl.hTWD,i,TRUE,iJoinedMacAddress,RX_QUEUE_WIN_SIZE);
+ iBACounertRespone++;
+ }
+ else {
+ if (((pBABitMask->iRxBlockAckUsage >> i) & 0x1) < ((iRxBlockAckUsageLast >> i) & 0x1))
+ {
+ status = TWD_CfgSetBaReceiver(iTwdCtrl.hTWD,i,FALSE,iJoinedMacAddress,RX_QUEUE_WIN_SIZE);
+ iBACounertRespone++;
+ }
+ }
+ }
+
+
+ /* Save the current BA vectors */
+ iRxBlockAckUsageLast = pBABitMask->iRxBlockAckUsage;
+#endif
+ return status;
+}
+#endif /* HT_SUPPORT */
+
+/**
+* \fn TxAutoRatePolicy
+* \brief Specifies the supported rates
+*
+* \param StxAutoRatePolicy
+*
+* /note
+*
+* /return OK for sucsses NOK for failed
+*/
+WHA::TStatus TIWha::TxAutoRatePolicy (WHA::StxAutoRatePolicy* pTxAutoRatePolicy)
+{
+ iTxRatePolicy.aMib = MIB_txRatePolicy;
+ /* The length field is not in use */
+ iTxRatePolicy.Length = 0;
+ /* we only have 1 policy since FW decide on which rate to use */
+ iTxRatePolicy.aData.txRatePolicy.numOfRateClasses = pTxAutoRatePolicy->iTxRateClassId;
+
+ #ifdef HT_SUPPORT
+ iTxRatePolicy.aData.txRatePolicy.rateClass[pTxAutoRatePolicy->iTxRateClassId - 1].txEnabledRates = TIWhaUtils::HTWhaRateToRatePolicy(pTxAutoRatePolicy);
+ #else
+ iTxRatePolicy.aData.txRatePolicy.rateClass[pTxAutoRatePolicy->iTxRateClassId - 1].txEnabledRates = TIWhaUtils::WhaRateToRatePolicy(pTxAutoRatePolicy);
+ #endif
+
+ #ifdef ALL_RATES_OPEN_DEBUG
+ if ( iTxRatePolicy.aData.txRatePolicy.rateClass[pTxAutoRatePolicy->iTxRateClassId - 1].txEnabledRates & HW_BIT_RATE_54MBPS)
+ {
+ iTxRatePolicy.aData.txRatePolicy.rateClass[pTxAutoRatePolicy->iTxRateClassId - 1].txEnabledRates = 0x1DFF;
+ }
+ #endif
+
+ iTxRatePolicy.aData.txRatePolicy.rateClass[pTxAutoRatePolicy->iTxRateClassId - 1].shortRetryLimit = pTxAutoRatePolicy->iShortRetryLimit;
+ iTxRatePolicy.aData.txRatePolicy.rateClass[pTxAutoRatePolicy->iTxRateClassId - 1].longRetryLimit = pTxAutoRatePolicy->iLongRetryLimit;
+
+ return (TWD_WriteMib (iTwdCtrl.hTWD, &iTxRatePolicy) == TI_OK) ? WHA::KSuccess : WHA::KFailed;
+}
+
+/**
+* \fn SetPowerSavePowerLevel
+* \brief Set the Power save power level
+*
+*
+* /note
+*
+* /return
+*/
+void TIWha::SetPowerSavePowerLevel(void *aMib)
+{
+ //os_printf("SetPowerSavePowerLevel send EPowerPolicy = %d",*((EPowerPolicy*)aMib));
+ TWD_CfgSleepAuth(iTwdCtrl.hTWD, *((EPowerPolicy*)aMib));
+}
+
+
+/**
+* \fn SoftGemini_SetParams
+* \brief initialization of Soft Gemini parameters
+*
+* used for init stage to initialize the SG parameters
+* /note
+*
+* /return
+*/
+
+TI_STATUS TIWha::SoftGemini_SetParams (TI_HANDLE hTWD, TSoftGeminiParams *pSgParams,ESoftGeminiEnableModes aSgMode )
+{
+ TTwdParamInfo iParamInfo;
+
+ iParamInfo.paramType = TWD_SG_CONFIG_PARAM_ID;
+ iParamInfo.paramLength = sizeof(TSoftGeminiParams);
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iParamInfo.content.SoftGeminiParam,&iSgParams,sizeof(TSoftGeminiParams));
+ TWD_SetParam(iTwdCtrl.hTWD,&iParamInfo);
+
+ iParamInfo.paramType = TWD_SG_ENABLE_PARAM_ID;
+ iParamInfo.paramLength = sizeof(ESoftGeminiEnableModes);
+ iParamInfo.content.SoftGeminiEnable = aSgMode;
+ TWD_SetParam(iTwdCtrl.hTWD,&iParamInfo);
+ return TI_OK;
+}
+
+/**
+* \fn ConfigureBtCoex
+* \brief Set the Soft Gemini parameters and send it to FW
+*
+* \note
+* \return KSuccess or KFailed
+* \sa
+*/
+void TIWha::InitBtCoex()
+{
+
+ /* Set Static parameters */
+
+ /* Setting the ratio for each profile */
+ /* Both coexBtLoadRatio & coexBtLoadRatio are 50/50 profiles */
+ /* The default profile is set to BtCoexProfData */
+ switch (BTCOEX_DEFAULT_PROFILE)
+ {
+ case BtCoexProfData:
+ iSgParams.coexParams[SOFT_GEMINI_BT_LOAD_RATIO] = 50;
+ break;
+
+ case BtCoexProfDataLowLatency:
+ iSgParams.coexParams[SOFT_GEMINI_BT_LOAD_RATIO] = 50;
+ break;
+
+ case BtCoexProfA2DP:
+ iSgParams.coexParams[SOFT_GEMINI_BT_LOAD_RATIO] = 71;
+ break;
+
+ default:
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "btCoexistenceProfile - Value Invalide = %d",BTCOEX_DEFAULT_PROFILE);
+ return;
+ }
+
+ iSgParams.coexParams[SOFT_GEMINI_BT_PER_THRESHOLD] = 7500;
+ iSgParams.coexParams[SOFT_GEMINI_HV3_MAX_OVERRIDE] = 0;
+ iSgParams.coexParams[SOFT_GEMINI_BT_NFS_SAMPLE_INTERVAL] = 400;
+ iSgParams.coexParams[SOFT_GEMINI_AUTO_PS_MODE] = 0;
+ iSgParams.coexParams[SOFT_GEMINI_AUTO_SCAN_PROBE_REQ] = 170;
+ iSgParams.coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_HV3] = 50;
+ iSgParams.coexParams[SOFT_GEMINI_ANTENNA_CONFIGURATION] = 0;
+ iSgParams.coexParams[SOFT_GEMINI_BEACON_MISS_PERCENT] = 60;
+ iSgParams.coexParams[SOFT_GEMINI_RATE_ADAPT_THRESH] = 21; /* Set to MCS_7 */
+ #ifdef ENHANCED_OPPORTUNISTIC
+ iSgParams.coexParams[SOFT_GEMINI_RATE_ADAPT_SNR] = 1;
+ #else
+ iSgParams.coexParams[SOFT_GEMINI_RATE_ADAPT_SNR]= 0;
+ #endif
+
+
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MIN_BR] = 10;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MAX_BR] = 30;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_MASTER_BR] = 8;
+
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MIN_BR] = 20;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MAX_BR] = 50;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_SLAVE_BR] = 8;
+
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MIN_EDR] = 7;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_MASTER_MAX_EDR] = 25;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_MASTER_EDR] = 20;
+
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MIN_EDR] = 8;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_BT_ACL_SLAVE_MAX_EDR] = 40;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_PS_MAX_BT_ACL_SLAVE_EDR] = 12;
+ iSgParams.coexParams[SOFT_GEMINI_RXT] = 1200;
+ iSgParams.coexParams[SOFT_GEMINI_TXT] = 1500;
+ iSgParams.coexParams[SOFT_GEMINI_ADAPTIVE_RXT_TXT] = 1;
+ iSgParams.coexParams[SOFT_GEMINI_PS_POLL_TIMEOUT] = 10;
+ iSgParams.coexParams[SOFT_GEMINI_UPSD_TIMEOUT] = 10;
+ iSgParams.coexParams[SOFT_GEMINI_UPSD_TIMEOUT] = 10;
+
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MASTER_MIN_EDR] = 7;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MASTER_MAX_EDR] = 15;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_MASTER_EDR] = 15;
+
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_SLAVE_MIN_EDR] = 8;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_SLAVE_MAX_EDR] = 20;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_SLAVE_EDR] = 15;
+
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MIN_BR] = 20;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_BT_ACL_MAX_BR] = 50;
+ iSgParams.coexParams[SOFT_GEMINI_WLAN_ACTIVE_MAX_BT_ACL_BR] = 5;
+
+ iSgParams.coexParams[SOFT_GEMINI_PASSIVE_SCAN_DURATION_FACTOR_HV3] = 200;
+ iSgParams.coexParams[SOFT_GEMINI_PASSIVE_SCAN_DURATION_FACTOR_A2DP] = 800;
+ iSgParams.coexParams[SOFT_GEMINI_PASSIVE_SCAN_BT_TIME] = 75;
+ iSgParams.coexParams[SOFT_GEMINI_PASSIVE_SCAN_WLAN_TIME] = 15;
+ iSgParams.coexParams[SOFT_GEMINI_HV3_MAX_SERVED] = 6;
+
+ iSgParams.coexParams[SOFT_GEMINI_DHCP_TIME] = 5000;
+ iSgParams.coexParams[SOFT_GEMINI_ACTIVE_SCAN_DURATION_FACTOR_A2DP] = 100;
+
+ iSgParams.coexParams[SOFT_GEMINI_TEMP_PARAM_1] = 0;
+ iSgParams.coexParams[SOFT_GEMINI_TEMP_PARAM_2] = 0;
+ iSgParams.coexParams[SOFT_GEMINI_TEMP_PARAM_3] = 0;
+ iSgParams.coexParams[SOFT_GEMINI_TEMP_PARAM_4] = 0;
+ iSgParams.coexParams[SOFT_GEMINI_TEMP_PARAM_5] = 0;
+}
+
+
+/**
+* \fn AddKey
+* \brief Add key according to the key type
+*
+* \note In case we already used the given index, we remove the old key
+* \return
+* \sa
+*/
+void TIWha::AddKey(
+ WHA::TKeyType aType,
+ const void* aKey,
+ TUint8 aEntryIndex )
+{
+ TTwdParamInfo param;
+ TSecurityKeys key;
+ TI_STATUS status;
+
+ os_memoryZero ((TI_HANDLE)&iTwdCtrl.tOsContext, &key, sizeof(TSecurityKeys));
+
+ if (aEntryIndex >= TIWha_MAX_PRIVACY_KEY_INDEX)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Invalid index=%d\n", aEntryIndex)
+ }
+
+ /* if the Key already exists, we remove it, and add the new one */
+ /* we check the encLen field beacuse if there is key in this entry */
+ /* the encLen field is always different than zero */
+ if (iTwdCtrl.privacyKey[aEntryIndex].encLen !=0)
+ {
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "Remove duplicate Key from AddKey, aEntryIndex= 0x%x\n", aEntryIndex);
+ RemoveKey(aEntryIndex);
+ }
+ else
+ {
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "AddKey, New key aEntryIndex= 0x%x, encLen= %d \n", aEntryIndex, iTwdCtrl.privacyKey[aEntryIndex].encLen);
+ }
+
+ /* Set the security mode */
+ switch (aType)
+ {
+ case WHA::EWepGroupKey:
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_WEP;
+ iTwdCtrl.eGroupKeyMode = TWD_CIPHER_WEP;
+ break;
+
+ case WHA::EWepPairWiseKey:
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_WEP;
+ iTwdCtrl.ePairwiseKeyMode = TWD_CIPHER_WEP;
+ break;
+
+ case WHA::ETkipGroupKey:
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_TKIP;
+ iTwdCtrl.eGroupKeyMode = TWD_CIPHER_TKIP;
+ break;
+
+ case WHA::ETkipPairWiseKey:
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_TKIP;
+ iTwdCtrl.ePairwiseKeyMode = TWD_CIPHER_TKIP;
+ break;
+
+ case WHA::EAesGroupKey:
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_AES_CCMP;
+ iTwdCtrl.eGroupKeyMode = TWD_CIPHER_AES_CCMP;
+ break;
+
+ case WHA::EAesPairWiseKey:
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_AES_CCMP;
+ iTwdCtrl.ePairwiseKeyMode = TWD_CIPHER_AES_CCMP;
+ break;
+
+ #ifdef GEM_SUPPORT
+ case GEMGroupKey:
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_GEM;
+ iTwdCtrl.eGroupKeyMode = TWD_CIPHER_GEM;
+ break;
+
+ case GEMPairWiseKey:
+ param.content.rsnEncryptionStatus = (ECipherSuite)TWD_CIPHER_GEM;
+ iTwdCtrl.ePairwiseKeyMode = TWD_CIPHER_GEM;
+ break;
+ #endif
+
+ default:
+ ASSERT_ERR (iTwdCtrl.hReport, "Unknown key type=%d\n", aType)
+ }
+
+ param.paramType = TWD_RSN_SECURITY_MODE_PARAM_ID;
+ TWD_SetParam (iTwdCtrl.hTWD, ¶m);
+
+ /* Converts the AddKey back to the correlated TWD command */
+ if (ConstructAddKey (&key,
+ aType,
+ aKey,
+ aEntryIndex) != WHA::KSuccess)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Failed to construct key type=%d\n", aType)
+ }
+
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void *)&iTwdCtrl.privacyKey[aEntryIndex],
+ (void *)&key,
+ sizeof(TSecurityKeys));
+
+ /* Activates the whal TWD_SetParam function (with TWD_RSN_KEY_ADD_PARAM) */
+ param.paramType = TWD_RSN_KEY_ADD_PARAM_ID;
+ param.content.configureCmdCBParams.pCb = (TUint8*)&key;
+ param.content.configureCmdCBParams.fCb = (void *)TIWhaAdaptCB::AddKeyResponse;
+ param.content.configureCmdCBParams.hCb = this;
+
+ status = TWD_SetParam (iTwdCtrl.hTWD, ¶m);
+
+ if (status != TI_OK)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Add key failure, key index=%d\n", aEntryIndex)
+ }
+}
+
+/**
+* \fn ConstructAddKey
+* \brief utility function for AddKey
+*
+* \note
+* \return
+* \sa
+*/
+WHA::TStatus TIWha::ConstructAddKey (
+ TSecurityKeys *aSecurityKey, /* structure to be filled */
+ WHA::TKeyType aType, /* Type of the key to be added */
+ const void *aKey, /* Pointer to buffer specifying the key */
+ /* material, according to the key type */
+ /* (see specification for details). */
+ TUint8 aEntryIndex) /* Key entry index. Valid range: 0-8. */
+{
+ TUint8 broadcast[MAC_ADDR_LEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+
+ TRACE3(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "(%d) - ConstructAddKey, type=%d ïndex=%d\n",__LINE__,aType, aEntryIndex);
+
+ /* Fill up the mutual fields */
+ switch (aType)
+ {
+ case WHA::EWepGroupKey:
+ {
+ /*
+ * WEP Group Key:
+ * 1) Key length
+ * 2) Key
+ * 3) Default key number
+ */
+ WHA::SWepGroupKey* pKey = (WHA::SWepGroupKey*)aKey;
+
+ aSecurityKey->keyType = KEY_WEP;
+ aSecurityKey->encLen = pKey->iKeyLengthInBytes;
+ aSecurityKey->keyIndex = pKey->iKeyId;
+
+ if (!bJoined) {
+ /* Clear mac address to distinguish between Group and Pairwise */
+ os_memoryZero ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->macAddress,
+ sizeof(TMacAddr));
+ }
+ else
+ {
+ MAC_COPY (aSecurityKey->macAddress, broadcast);
+ }
+
+
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->encKey,
+ (void*)pKey->iKey,
+ aSecurityKey->encLen);
+
+ break;
+ }
+ case WHA::EWepPairWiseKey:
+ {
+ /*
+ * WEP Pairwise Key:
+ * 1) MAC Address of the peer station
+ * 2) Key length
+ * 3) Key
+ */
+ WHA::SWepPairwiseKey* pKey = (WHA::SWepPairwiseKey*)aKey;
+
+ aSecurityKey->keyType = KEY_WEP;
+ aSecurityKey->keyIndex = 0;
+ MAC_COPY (aSecurityKey->macAddress, (TI_UINT8*)&pKey->iMacAddr);
+ aSecurityKey->encLen = pKey->iKeyLengthInBytes;
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->encKey,
+ (void*)pKey->iKey,
+ aSecurityKey->encLen);
+
+ break;
+ }
+
+ case WHA::ETkipGroupKey:
+ {
+ /* TKIP Group Key:
+ * 1) 128 encryption key
+ * 2) 64 bit Rx MIC Key
+ * 3) Key ID
+ */
+ WHA::STkipGroupKey* pKey = (WHA::STkipGroupKey*)aKey;
+
+ aSecurityKey->keyType = KEY_TKIP;
+ aSecurityKey->encLen = WHA::KTKIPKeyLength;
+ MAC_COPY (aSecurityKey->macAddress, broadcast);
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->micRxKey,
+ (void*)pKey->iRxMicKey,
+ WHA::KTKIPKeyLength);
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->encKey,
+ (void*)pKey->iTkipKey,
+ WHA::KTKIPKeyLength);
+ aSecurityKey->keyIndex = pKey->iKeyId;
+ break;
+ }
+
+ case WHA::ETkipPairWiseKey:
+ {
+ /*
+ * TKIP Pairwise Key:
+ * 1) MAC Address of the peer station
+ * 2) 64 bit Rx MIC Key
+ * 3) 64 bit Tx MIC Key
+ * 4) 128 encryption key
+ * 5) Key ID
+ */
+ WHA::STkipPairwiseKey* pKey = (WHA::STkipPairwiseKey*)aKey;
+
+ aSecurityKey->keyType = KEY_TKIP;
+ aSecurityKey->encLen = WHA::KTKIPKeyLength;
+ MAC_COPY (aSecurityKey->macAddress, (TI_UINT8*)&pKey->iMacAddr);
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->micRxKey,
+ (void*)pKey->iRxMicKey,
+ WHA::KTKIPKeyLength);
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->micTxKey,
+ (void*)pKey->iTxMicKey,
+ WHA::KTKIPKeyLength);
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->encKey,
+ (void*)pKey->iTkipKey,
+ WHA::KTKIPKeyLength);
+ aSecurityKey->keyIndex = pKey->iKeyId;
+ break;
+ }
+
+ case WHA::EAesGroupKey:
+ {
+ /* AES Group Key:
+ * 1) 128 encryption key
+ * 2) key ID
+ */
+ WHA::SAesGroupKey* pKey = (WHA::SAesGroupKey*)aKey;
+
+ /* Fill security key structure */
+ aSecurityKey->keyType = KEY_AES;
+ aSecurityKey->encLen = WHA::KAesKeyLength;
+ MAC_COPY (aSecurityKey->macAddress, broadcast);
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->encKey,
+ (void*)pKey->iAesKey,
+ WHA::KAesKeyLength);
+ aSecurityKey->keyIndex = pKey->iKeyId;
+ break;
+ }
+
+ case WHA::EAesPairWiseKey:
+ {
+ /*
+ * AES Pairwise Key:
+ * 1) MAC Address of the peer station
+ * 2) 128 encryption key
+ */
+ WHA::SAesPairwiseKey* pKey = (WHA::SAesPairwiseKey*)aKey;
+
+ /* Fill security key structure */
+ aSecurityKey->keyType = KEY_AES;
+ aSecurityKey->encLen = WHA::KAesKeyLength;
+ aSecurityKey->keyIndex = 0;
+ MAC_COPY (aSecurityKey->macAddress, (TI_UINT8*)&pKey->iMacAddr);
+ os_memoryCopy ((TI_HANDLE)&iTwdCtrl.tOsContext,
+ (void*)aSecurityKey->encKey,
+ (void*)pKey->iAesKey,
+ WHA::KAesKeyLength);
+ break;
+ }
+
+ #ifdef GEM_SUPPORT
+ case GEMGroupKey:
+ {
+ SGEMGroupKey* pKey = (SGEMGroupKey*)aKey;
+
+ /* Fill security key structure */
+ aSecurityKey->keyType = KEY_GEM;
+ aSecurityKey->encLen = KGEMKeyLength;
+ aSecurityKey->keyIndex = pKey->iKeyId;
+ MAC_COPY (aSecurityKey->macAddress, broadcast);
+ GROUP_KEY_COPY ((TI_HANDLE)&iTwdCtrl.tOsContext,aSecurityKey,pKey,KGEMKeyLength);
+ GROUP_MIC_COPY ((TI_HANDLE)&iTwdCtrl.tOsContext,aSecurityKey,pKey,KGEMMicKeyLength);
+ break;
+ }
+
+ case GEMPairWiseKey:
+ {
+ SGEMPairwiseKey* pKey = (SGEMPairwiseKey*)aKey;
+
+ /* Fill security key structure */
+ aSecurityKey->keyType = KEY_GEM;
+ aSecurityKey->encLen = KGEMKeyLength;
+ aSecurityKey->keyIndex = pKey->iKeyId;
+ MAC_COPY (aSecurityKey->macAddress, (TI_UINT8*)&pKey->iMacAddr);
+ PAIRWISE_KEY_COPY ((TI_HANDLE)&iTwdCtrl.tOsContext,aSecurityKey,pKey,KGEMKeyLength);
+ PAIRWISE_MIC_COPY ((TI_HANDLE)&iTwdCtrl.tOsContext,aSecurityKey,pKey,KGEMMicKeyLength);
+ break;
+ }
+ #endif /* GEM_SUPPORT */
+
+ default:
+ /*
+ * NULL_KEY, XCC_KEY
+ */
+ TRACE2(iTwdCtrl.hReport, REPORT_SEVERITY_ERROR, "(%d) - ConstructAddKey - ERROR - Key not supported, %d\n",__LINE__,aType);
+
+ break;
+ }
+
+ return WHA::KSuccess;
+}
+
+/**
+* \fn RemoveKey
+* \brief Remove key from our data base and from Fw
+*
+* \note This function is never called from LDD, therfore we use dummy response
+* \return
+* \sa
+*/
+void TIWha::RemoveKey( TUint8 aEntryIndex)
+{
+ TTwdParamInfo param;
+ TI_STATUS status;
+ ECipherSuite eOldCipherSuite;
+ TBool bSecurityChanged = FALSE;
+
+
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "RemoveKey, aEntryIndex= 0x%x\n", aEntryIndex);
+
+ if (aEntryIndex >= TIWha_MAX_PRIVACY_KEY_INDEX)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Invalid key index=%d\n", aEntryIndex)
+ }
+
+ param.paramType = TWD_RSN_SECURITY_MODE_PARAM_ID;
+ status = TWD_GetParam(iTwdCtrl.hTWD, ¶m);
+ if (status != TI_OK)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "RemoveKey : Remove key failure, key index=%d\n", aEntryIndex)
+ }
+
+ eOldCipherSuite = param.content.rsnEncryptionStatus;
+
+ /* Synchronies the current security mode with the key security mode */
+ switch (iTwdCtrl.privacyKey[aEntryIndex].keyType)
+ {
+ case KEY_WEP: param.content.rsnEncryptionStatus = TWD_CIPHER_WEP; break;
+ case KEY_TKIP: param.content.rsnEncryptionStatus = TWD_CIPHER_TKIP; break;
+ case KEY_AES: param.content.rsnEncryptionStatus = TWD_CIPHER_AES_CCMP; break;
+ #ifdef GEM_SUPPORT
+ case KEY_GEM: param.content.rsnEncryptionStatus = TWD_CIPHER_GEM; break;
+ #endif
+ }
+
+ TRACE3(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "RemoveKey, keyType= 0x%x, rsnEncryptionStatus = 0x%x eOldCipherSuite = 0x%x\n", iTwdCtrl.privacyKey[aEntryIndex].keyType, param.content.rsnEncryptionStatus, eOldCipherSuite);
+
+ /* Check if we should update security mode */
+ if (eOldCipherSuite != param.content.rsnEncryptionStatus)
+ {
+ bSecurityChanged = TRUE;
+ /* Change security mode in whalSecurity */
+ status = TWD_SetParam (iTwdCtrl.hTWD, ¶m);
+ if (status != TI_OK)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "RemoveKey : Remove key failure, key index=%d\n", aEntryIndex)
+ }
+ }
+
+ /* Activates the TWD_SetParam function (with TWD_RSN_KEY_REMOVE_PARAM) */
+ param.paramType = TWD_RSN_KEY_REMOVE_PARAM_ID;
+ param.content.configureCmdCBParams.pCb = (TUint8*)&iTwdCtrl.privacyKey[aEntryIndex];
+ /* Note that we never response a remove key since it is internal command. Symbian never issue this command */
+ param.content.configureCmdCBParams.fCb = (void *)TIWhaAdaptCB::DummyResponse;
+ param.content.configureCmdCBParams.hCb = this;
+
+ status = TWD_SetParam (iTwdCtrl.hTWD, ¶m);
+
+ if (status != TI_OK)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "Remove key failure, key index=%d\n", aEntryIndex)
+ }
+ else
+ {
+ /* remove the key from the keys table */
+ os_memoryZero ((TI_HANDLE)&iTwdCtrl.tOsContext, &iTwdCtrl.privacyKey[aEntryIndex], sizeof(TSecurityKeys));
+ }
+
+ /* Check if we should update back security mode */
+ if (bSecurityChanged)
+ {
+ param.content.rsnEncryptionStatus = eOldCipherSuite;
+ param.paramType = TWD_RSN_SECURITY_MODE_PARAM_ID;
+ status = TWD_SetParam (iTwdCtrl.hTWD, ¶m);
+ if (status != TI_OK)
+ {
+ ASSERT_ERR (iTwdCtrl.hReport, "RemoveKey : Remove key failure, key index=%d\n", aEntryIndex)
+ }
+ }
+}
+
+/**
+* \fn ConfigureQueue
+*
+* \return
+* \sa
+*/
+void TIWha::ConfigureQueue(
+ WHA::TQueueId aQueueId,
+ TUint32 aMaxLifeTime,
+ WHA::TPsScheme aPsScheme,
+ const WHA::SSAPSDConfig& aSAPSDConfig,
+ WHA::TAckPolicy aAckPolicy,
+ TUint16 aMediumTime )
+{
+ TTwdParamInfo param;
+ TQueueTrafficParams QueueTrafficParams;
+ TI_STATUS status;
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "\n");
+
+ TRACE5(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, " TIWha::ConfigureQueue: aQueueId = 0x%x, aPsScheme = 0x%x, APSDConf[0] = 0x%x, APSDConf[1] = 0x%x, aAckPolicy = 0x%x\n", aQueueId,aPsScheme,aSAPSDConfig.iServiceStartTime,aSAPSDConfig.iServiceInterval,aAckPolicy);
+
+ /* Set parameters */
+ QueueTrafficParams.queueID = (TUint8)aQueueId;
+ /* 0- 3 EDCA , 4 - HCCA */
+ QueueTrafficParams.channelType = (aQueueId < 4) ? CHANNEL_TYPE_EDCF : CHANNEL_TYPE_HCCA;
+ QueueTrafficParams.tsid = (TUint8)aQueueId;
+ QueueTrafficParams.dot11EDCATableMSDULifeTime = 0;
+ QueueTrafficParams.psScheme = aPsScheme;
+ QueueTrafficParams.APSDConf[0] = aSAPSDConfig.iServiceStartTime;
+ QueueTrafficParams.APSDConf[1] = aSAPSDConfig.iServiceInterval;
+ QueueTrafficParams.ackPolicy = aAckPolicy;
+
+ param.paramType = (TUint32)TWD_QUEUES_PARAM_ID;
+ param.content.pQueueTrafficParams = &QueueTrafficParams;
+
+ status = TWD_SetParam (iTwdCtrl.hTWD, ¶m);
+
+ if (status != TI_OK)
+ {
+ ASSERT_ERR ( iTwdCtrl.hReport, "ERROR:Configure queue failure, queue ID=%d\n", aQueueId)
+ }
+}
+
+/**
+* \fn ConfigureAC
+*
+* \return
+* \sa
+*/
+void TIWha::ConfigureAC(
+ TUint16 aCwMin[Wha::KNumOfEdcaQueues],
+ TUint16 aCwMax[Wha::KNumOfEdcaQueues],
+ TUint8 aAIFS[Wha::KNumOfEdcaQueues],
+ TUint16 aTxOplimit[Wha::KNumOfEdcaQueues],
+ TUint16 aMaxReceiveLifeTime[Wha::KNumOfEdcaQueues] )
+{
+ TAcQosParams AcQosParams;
+ WHA::TStatus status = TI_OK;
+ TUint8 i;
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "\n");
+
+ /* configure all AC's but the last one in a loop that returns as a dummy CB */
+ for (i = 0; (i < Wha::KNumOfEdcaQueues - 1) && (TI_OK == status); i++)
+ {
+ TRACE5(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, " TIWha::ConfigureAC: Index = 0x%x, aCwMin = 0x%x, aCwMax = 0x%x, aAIFS = 0x%x, aTxOpLimit = 0x%x\n", i,aCwMin[i],aCwMax[i],aAIFS[i],aTxOplimit[i]);
+
+ AcQosParams.ac = i;
+ AcQosParams.cwMin = (TUint8)aCwMin[i];
+ AcQosParams.cwMax = aCwMax[i];
+ AcQosParams.aifsn = aAIFS[i];
+ AcQosParams.txopLimit = aTxOplimit[i];
+
+ status = TWD_CfgAcParams (iTwdCtrl.hTWD,
+ &AcQosParams,
+ (void *)TIWhaAdaptCB::DummyResponse,
+ this);
+ }
+
+ /* After the loop - the last AC returns as a real CB */
+ if (TI_OK == status)
+ {
+ TRACE5(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, " TIWha::ConfigureAC: Index = 0x%x, aCwMin = 0x%x, aCwMax = 0x%x, aAIFS = 0x%x, aTxOpLimit = 0x%x\n", i,aCwMin[i],aCwMax[i],aAIFS[i],aTxOplimit[i]);
+
+ AcQosParams.ac = i;
+ AcQosParams.cwMin = (TUint8)aCwMin[i];
+ AcQosParams.cwMax = aCwMax[i];
+ AcQosParams.aifsn = aAIFS[i];
+ AcQosParams.txopLimit = aTxOplimit[i];
+
+ status = TWD_CfgAcParams (iTwdCtrl.hTWD,
+ &AcQosParams,
+ NULL, /* The generic CB will be called */
+ NULL);
+ }
+
+ if (status != TI_OK)
+ {
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "ERROR: Configure AC failure, status=%d\n", status);
+ }
+}
+
+
+
+/**
+* \fn Reset
+* \brief disconnect from BSS/IBSS
+* \return
+* \sa
+*/
+void TIWha::Reset()
+{
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "\n");
+ int status;
+
+ /* Check if we are in 802.11 PS mode. If not we should update sleepMode */
+ if (!(TWD_GetPsStatus (iTwdCtrl.hTWD)))
+ {
+ /* Configure H/W to user sleep mode */
+ SleepMode (iTwdCtrl.sleepMode, FALSE);
+ }
+
+
+ /* If connection timer is running - stop it */
+ if (bConnectionTimerRunning)
+ {
+ bConnectionTimerRunning = TI_FALSE;
+ os_timerStop(&iTwdCtrl.tOsContext, hConnectionTimer);
+ }
+
+#ifdef HT_SUPPORT
+ TWD_CloseAllBaSessions(iTwdCtrl.hTWD);
+#endif /* HT_SUPPORT */
+
+ status = TWD_CmdFwDisconnect ( iTwdCtrl.hTWD ,DISCONNECT_IMMEDIATE , STATUS_UNSPECIFIED);
+
+ if (status != TI_OK)
+ {
+ ASSERT_ERR ( iTwdCtrl.hReport, "Reset failure, status=%d\n", status)
+ }
+
+ /* We are not connected */
+ bJoined = 0;
+}
+
+#ifdef TI_TEST
+TTestCmd mTest;
+/**
+* \fn PltTester
+* \brief Called when PLT commands sent externally
+*
+* /Param aData - parametrs of PLT command
+* /return
+*/
+void TIWha::PltTester(const void *aData)
+{
+ TTestCmd* pPltTester = (TTestCmd*)aData;
+ os_memoryCopy(NULL,&mTest,(void *)aData,sizeof(TTestCmd));
+ Plt(pPltTester->testCmdId,&mTest.testCmd_u);
+}
+
+
+
+/**
+* \fn ChangeQueue
+* \brief Change the output queue for all packets
+*
+* /Param aData - queue to be set
+* /return
+*/
+void TIWha::ChangeQueue(const void *aData)
+{
+ iQueueId = *(WHA::TQueueId*)aData;
+
+ if( bErrorIndication == TI_FALSE)
+ {
+ WhaCb()->CommandResponse(WHA::EWriteMIBResponse, WHA::KSuccess, iUCommandResponseParams);
+ }
+ #if TI_DBG
+ else
+ {
+ WLAN_OS_REPORT(("%s : CommandResponse Block call to LDD response \n",__FUNCTION__));
+ }
+ #endif
+}
+#endif /* TI_TEST */
+
+
+/**
+* \fn Plt
+* \brief production line testing
+*
+* The host driver calls this method to perform production
+* line testing of the WLAN device
+* /param eTestCmd - specific test enum
+* /param pTestCmdParams - test specific parameters and place for return buffer
+* /return TStatus - KPending or KError
+*/
+WHA::TStatus TIWha::Plt (ETestCmdID eTestCmd, void *pTestCmdParams)
+{
+ TI_STATUS status;
+ TRACE1(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, " CmdID = 0x%x\n", eTestCmd);
+
+ /* Save type of test to be retrieved later on the CB */
+ iTwdCtrl.ePlt = eTestCmd;
+
+ switch (eTestCmd)
+ {
+ case TEST_CMD_P2G_CAL:
+ status = TWDriverTest (iTwdCtrl.hTWD,
+ (TestCmdID_enum) eTestCmd,
+ pTestCmdParams,
+ TIWhaAdaptCB::TxBipResponse,
+ (TI_HANDLE) this);
+ break;
+
+ case TEST_CMD_RX_PLT_CAL:
+ status = TWDriverTest (iTwdCtrl.hTWD,
+ (TestCmdID_enum) eTestCmd,
+ pTestCmdParams,
+ TIWhaAdaptCB::RxBipResponse,
+ (TI_HANDLE) this);
+ break;
+
+ case TEST_CMD_RX_STAT_GET:
+ status = TWDriverTest (iTwdCtrl.hTWD,
+ (TestCmdID_enum) eTestCmd,
+ pTestCmdParams,
+ TIWhaAdaptCB::RxStatResponse,
+ (TI_HANDLE) this);
+ break;
+ case TEST_CMD_FREE_RUN_RSSI:
+ status = TWDriverTest (iTwdCtrl.hTWD,
+ (TestCmdID_enum) eTestCmd,
+ pTestCmdParams,
+ TIWhaAdaptCB::RunRssiResponse,
+ (TI_HANDLE) this);
+ break;
+
+ default:
+ status = TWDriverTest (iTwdCtrl.hTWD,
+ (TestCmdID_enum) eTestCmd,
+ pTestCmdParams,
+ TIWhaAdaptCB::PltResponse,
+ (TI_HANDLE) this);
+ } /* switch */
+
+ return (status == TI_OK) ? WHA::KPending : WHA::KFailed;
+}
+/**
+* \fn Plt
+* \brief production line testing
+*
+* The host driver calls this method to perform production
+* line testing of the WLAN device
+* /param TPltType - specific test enum
+* /param aParams - test specific parameters and place for return buffer
+* /return TStatus - KPending or KError
+*/
+void TIWha::Plt (WHA::TPltType aType, void *aParams)
+{
+ Plt((ETestCmdID) aType,aParams);
+}
+
+
+/**
+ * \fn WriteMem
+ * \brief write buffer to HW address
+ *
+ * \note
+ * \param pMemoryAccess - address, length, buffer
+ * \return TStatus
+ */
+WHA::TStatus TIWha::WriteMem (TMemoryAccess *pMemoryAccess)
+{
+TRACE3(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, " addr = 0x%x length = %d p = %p\n", pMemoryAccess->addr, pMemoryAccess->length, pMemoryAccess);
+
+ TI_STATUS status = TWD_writeMem (iTwdCtrl.hTWD,
+ (TFwDebugParams*) pMemoryAccess, (void*)TIWhaAdaptCB::WriteMemResponse, this);
+
+ /* convert status to WHA::TStatus */
+ return (status == TI_OK) ? WHA::KPending : WHA::KFailed;
+}
+
+
+/**
+ * \fn ReadMem
+ * \brief read buffer from HW address
+ *
+ * \note
+ * \param pMemoryAccess - address, length, buffer
+ * \return TStatus
+ */
+WHA::TStatus TIWha::ReadMem (TMemoryAccess *pMemoryAccess)
+{
+TRACE3(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, " addr = 0x%x length = %d p = %p\n", pMemoryAccess->addr, pMemoryAccess->length, pMemoryAccess);
+
+ TI_STATUS status = TWD_readMem (iTwdCtrl.hTWD,
+ (TFwDebugParams*) pMemoryAccess, (void*)TIWhaAdaptCB::ReadMemResponse, this);
+
+ /* convert status to WHA::TStatus */
+ return (status == TI_OK) ? WHA::KPending : WHA::KFailed;
+}
+
+
+/**********************************************************
+TIWha Service functions
+**********************************************************/
+
+/**
+* \fn getMacAddress
+* \brief return the Mac address from the TWDCtrl
+*
+*
+* /note
+*
+* /return
+*/
+void * TIWha::getMacAddress()
+{
+ return (void *)iTwdCtrl.pMacAddr;
+
+}
+
+/**
+* \fn InitTwdParamTable
+* \brief initialization of TWD parameters
+*
+* since we have no ini file, we are initializing the
+* Modules wit hard coded values
+* /note
+*
+* /return
+*/
+void TIWha::InitTwdParamTable()
+{
+ os_memoryZero (&iTwdCtrl.tOsContext, (TI_UINT8*)&iTwdCtrl.twdInitParams, sizeof(TTwdInitParams));
+
+ iTwdCtrl.twdInitParams.tGeneral.packetDetectionThreshold = 0;
+ iTwdCtrl.twdInitParams.tGeneral.qosNullDataTemplateSize = sizeof(QosNullDataTemplate_t);
+ iTwdCtrl.twdInitParams.tGeneral.PsPollTemplateSize = sizeof(psPollTemplate_t);
+ iTwdCtrl.twdInitParams.tGeneral.probeResponseTemplateSize = sizeof(probeRspTemplate_t);
+ iTwdCtrl.twdInitParams.tGeneral.probeRequestTemplateSize = sizeof(probeReqTemplate_t);
+ iTwdCtrl.twdInitParams.tGeneral.beaconTemplateSize = sizeof(probeRspTemplate_t);
+ iTwdCtrl.twdInitParams.tGeneral.nullTemplateSize = sizeof(nullDataTemplate_t);
+ iTwdCtrl.twdInitParams.tGeneral.disconnTemplateSize = sizeof(disconnTemplate_t);
+ /* Beacon broadcast options */
+ iTwdCtrl.twdInitParams.tGeneral.BeaconRxTimeout = BCN_RX_TIMEOUT_DEF_VALUE;
+ iTwdCtrl.twdInitParams.tGeneral.BroadcastRxTimeout = BROADCAST_RX_TIMEOUT_DEF_VALUE;
+ iTwdCtrl.twdInitParams.tGeneral.RxBroadcastInPs = RX_BROADCAST_IN_PS_DEF_VALUE;
+ iTwdCtrl.twdInitParams.tGeneral.ConsecutivePsPollDeliveryFailureThreshold = CONSECUTIVE_PS_POLL_FAILURE_DEF;
+
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlRxDisableBroadcast = TWD_RX_DISABLE_BROADCAST_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlCalibrationChannel2_4 = TWD_CALIBRATION_CHANNEL_2_4_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlCalibrationChannel5_0 = TWD_CALIBRATION_CHANNEL_5_0_DEF;
+
+
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlRtsThreshold = TWD_RTS_THRESHOLD_DEF;
+
+
+ iTwdCtrl.twdInitParams.tGeneral.WiFiWmmPS = WIFI_WMM_PS_DEF;
+
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlMaxTxMsduLifetime = TWD_MAX_TX_MSDU_LIFETIME_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlMaxRxMsduLifetime = TWD_MAX_RX_MSDU_LIFETIME_DEF;
+
+ iTwdCtrl.twdInitParams.tGeneral.rxTimeOut.psPoll = QOS_RX_TIMEOUT_PS_POLL_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.rxTimeOut.UPSD = QOS_RX_TIMEOUT_UPSD_DEF;
+
+ /* RSSI/SNR Weights for Average calculations */
+ iTwdCtrl.twdInitParams.tGeneral.uRssiBeaconAverageWeight = TWD_RSSI_WEIGHT_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.uRssiPacketAverageWeight = TWD_RSSI_WEIGHT_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.uSnrBeaconAverageWeight = TWD_RSSI_WEIGHT_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.uSnrPacketAverageWeight = TWD_RSSI_WEIGHT_DEF;
+
+ /* No used */
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlFragThreshold = TWD_FRAG_THRESHOLD_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlListenInterval = TWD_LISTEN_INTERVAL_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlRateFallbackRetry = TWD_RATE_FB_RETRY_LIMIT_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlMacClock = 80;
+ iTwdCtrl.twdInitParams.tGeneral.halCtrlArmClock = 80;
+
+ iTwdCtrl.twdInitParams.tGeneral.TxCompletePacingThreshold = TWD_TX_CMPLT_THRESHOLD_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.TxCompletePacingTimeout = TWD_TX_CMPLT_TIMEOUT_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.RxIntrPacingThreshold = TWD_RX_INTR_THRESHOLD_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.RxIntrPacingTimeout = TWD_RX_INTR_TIMEOUT_DEF;
+
+ /* FM Coexistence params */
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uEnable = FM_COEX_ENABLE_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uSwallowPeriod = FM_COEX_SWALLOW_PERIOD_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uNDividerFrefSet1 = FM_COEX_N_DIVIDER_FREF_SET1_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uNDividerFrefSet2 = FM_COEX_N_DIVIDER_FREF_SET2_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uMDividerFrefSet1 = FM_COEX_M_DIVIDER_FREF_SET1_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uMDividerFrefSet2 = FM_COEX_M_DIVIDER_FREF_SET2_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uCoexPllStabilizationTime = FM_COEX_PLL_STABILIZATION_TIME_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uLdoStabilizationTime = FM_COEX_LDO_STABILIZATION_TIME_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uFmDisturbedBandMargin = FM_COEX_DISTURBED_BAND_MARGIN_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.tFmCoexParams.uSwallowClkDif = FM_COEX_SWALLOW_CLK_DIF_DEF;
+
+
+ /* Configure ARP IP */
+
+ iTwdCtrl.twdInitParams.tArpIpFilter.isFilterEnabled = DEF_FILTER_ENABLE_VALUE;
+ // Compialtion problem IP_COPY(iTwdCtrl.twdInitParams.tArpIpFilter.addr = "00 22 11 33 44 55");
+
+
+ /* Configure address group */
+ iTwdCtrl.twdInitParams.tMacAddrFilter.numOfMacAddresses = NUM_GROUP_ADDRESS_VALUE_DEF;
+ iTwdCtrl.twdInitParams.tMacAddrFilter.isFilterEnabled = DEF_FILTER_ENABLE_VALUE;
+#if 0
+ for (k = 0; k < pWlanParams->numGroupAddrs; k++)
+ {
+ MAC_COPY (iTwdCtrl.twdInitParams.tMacAddrFilter.macAddrTable[k]);
+ }
+#endif
+
+ /* QoS configure queue */
+ iTwdCtrl.twdInitParams.tGeneral.TxBlocksThresholdPerAc[0] = QOS_TX_BLKS_THRESHOLD_BE_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.TxBlocksThresholdPerAc[1] = QOS_TX_BLKS_THRESHOLD_BK_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.TxBlocksThresholdPerAc[2] = QOS_TX_BLKS_THRESHOLD_VI_DEF;
+ iTwdCtrl.twdInitParams.tGeneral.TxBlocksThresholdPerAc[3] = QOS_TX_BLKS_THRESHOLD_VO_DEF;
+
+
+
+ /* Configure the MAC services */
+
+ /* Power server */
+ iTwdCtrl.twdInitParams.tPowerSrv.hangOverPeriod = HANGOVER_PERIOD_DEF_VALUE + 5; /* Increase the hang over time to 10ms */
+ iTwdCtrl.twdInitParams.tPowerSrv.numNullPktRetries = POWER_MGMNT_NUM_NULL_PACKET_RETRY_DEF_VALUE;
+ /* Scan Server */
+ iTwdCtrl.twdInitParams.tScanSrv.numberOfNoScanCompleteToRecovery = SCAN_SRV_NUMBER_OF_NO_SCAN_COMPLETE_TO_RECOVERY_DEF;
+ iTwdCtrl.twdInitParams.tScanSrv.uTriggeredScanTimeOut = SCAN_SRV_TRIGGERED_SCAN_TIME_OUT_DEF;
+ iTwdCtrl.TxAlign.uCurrSend = 0;
+ iTwdCtrl.TxAlign.uCurrHandle = 0;
+
+ /* Configure the rate adaptaion */
+ iTwdCtrl.twdInitParams.tRateMngParams.InverseCuriosityFactor[0] = RATE_MGMT_INVERSE_CURIOSITY_FACTOR_OTHER;
+ iTwdCtrl.twdInitParams.tRateMngParams.InverseCuriosityFactor[1] = RATE_MGMT_INVERSE_CURIOSITY_FACTOR_VOICE;
+ iTwdCtrl.twdInitParams.tRateMngParams.MaxPer = RATE_MGMT_MAX_PER;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerAdd = RATE_MGMT_PER_ADD;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerAddShift = RATE_MGMT_PER_ADD_SHIFT;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerAlphaShift = RATE_MGMT_PER_ALPHA_SHIFT;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerBeta1Shift = RATE_MGMT_PER_BETA1_SHIFT;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerBeta2Shift = RATE_MGMT_PER_BETA2_SHIFT;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerTh1 = RATE_MGMT_PER_TH1;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerTh2 = RATE_MGMT_PER_TH2;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateCheckDown = RATE_MGMT_RATE_CHECK_DOWN;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateCheckUp = RATE_MGMT_RATE_CHECK_UP;
+
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[0] = 1;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[1] = 1;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[2] = 1;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[3] = 3;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[4] = 3;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[5] = 3;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[6] = 6;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[7] = 6;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[8] = 6;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[9] = 6;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[10] = 9;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[11] = 9;
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryPolicy[12] = 9;
+
+ iTwdCtrl.twdInitParams.tRateMngParams.RateRetryScore = RATE_MGMT_RATE_RETRY_SCORE;
+ iTwdCtrl.twdInitParams.tRateMngParams.TxFailLowTh = RATE_MGMT_TX_FAIL_LOW_TH;
+ iTwdCtrl.twdInitParams.tRateMngParams.TxFailHighTh = RATE_MGMT_TX_FAIL_HIGH_TH;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerWeightShift[0] = RATE_MGMT_PER_WEIGHT_SHIFT_OTHER;
+ iTwdCtrl.twdInitParams.tRateMngParams.PerWeightShift[1] = RATE_MGMT_PER_WEIGHT_SHIFT_VOICE;
+ iTwdCtrl.twdInitParams.tRateMngParams.TpWeightShift[0] = RATE_MGMT_TP_WEIGHT_SHIFT_OTHER;
+ iTwdCtrl.twdInitParams.tRateMngParams.TpWeightShift[1] = RATE_MGMT_TP_WEIGHT_SHIFT_VOICE;
+ iTwdCtrl.twdInitParams.tRateMngParams.paramIndex = RATE_MGMT_ALL_PARAMS;
+
+ iTwdCtrl.twdInitParams.tDcoItrimParams.enable = TWD_DCO_ITRIM_ENABLE_DEF;
+ iTwdCtrl.twdInitParams.tDcoItrimParams.moderationTimeoutUsec = TWD_DCO_ITRIM_MODERATION_TIMEOUT_DEF;
+}
+/**
+* \fn InitTwdPlatformGenParam
+* \brief initialization Platform General parameters
+*
+*
+* /return
+*/
+
+void TIWha::InitTwdPlatformGenParam()
+{
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iTwdCtrl.twdInitParams.tPlatformGenParams,&iAutoRadioParams.tGeneralParams,sizeof(IniFileGeneralParam));
+}
+
+
+/**
+* \fn InitTwdRadioParam
+* \brief initialization of Radio params
+* * /return
+*/
+
+void TIWha::InitTwdRadioParam()
+{
+ uint8 FemType;
+
+ if (iAutoRadioParams.tGeneralParams.TXBiPFEMAutoDetect == FEM_MANUAL_DETECT_MODE_E)
+ FemType = iAutoRadioParams.tGeneralParams.TXBiPFEMManufacturer;
+ else
+ FemType = TWD_GetFEMType(iTwdCtrl.hTWD);
+ /* fill TWD init parms with relevant (RFMD or TriQuint) Radio parms before calling TWD_SetDefault*/
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iTwdCtrl.twdInitParams.tIniFileRadioParams.tDynRadioParams,&iAutoRadioParams.tDynRadioParams[FemType],sizeof(TDynRadioParams));
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iTwdCtrl.twdInitParams.tIniFileRadioParams.tStatRadioParams,&iAutoRadioParams.tStatRadioParams,sizeof(TStatRadioParams));
+}
+
+
+/**
+* \fn InitTwdRadioParam
+* \brief initialization of Radio params
+* * /return
+*/
+
+void TIWha::InitTwdRadioSmartReflexParam()
+{
+ /* fill TWD init parms with relevant (RFMD or TriQuint) Radio parms before calling TWD_SetDefault*/
+ os_memoryCopy(iTwdCtrl.tOsContext.hOsa,&iTwdCtrl.twdInitParams.tSmartReflexParams.errorTable, &iSmartReflexParams.tErrorTable,sizeof(TSmartReflexErrTable));
+ os_memoryZero(iTwdCtrl.tOsContext.hOsa, &iSmartReflexDebugParams, sizeof(TSmartReflexDebugParams));
+ iTwdCtrl.twdInitParams.tSmartReflexState.enable = iSmartReflexParams.SmartReflexState;
+}
+
+
+/**
+* \fn InitReportParamTable
+* \brief initialization of Report parameters
+*
+* since we ave no ini file, we are initializing the
+* Modules with hard coded values
+* /note
+*
+* /return
+*/
+void TIWha::InitReportParamTable()
+{
+ /* Open All Modules and some severity */
+ iTwdCtrl.report_init.aSeverityTable [REPORT_SEVERITY_INIT] = '0';
+ iTwdCtrl.report_init.aSeverityTable [REPORT_SEVERITY_INFORMATION] = '0';
+ iTwdCtrl.report_init.aSeverityTable [REPORT_SEVERITY_WARNING] = '0';
+ iTwdCtrl.report_init.aSeverityTable [REPORT_SEVERITY_ERROR] = '1';
+ iTwdCtrl.report_init.aSeverityTable [REPORT_SEVERITY_FATAL_ERROR] = '1';
+ iTwdCtrl.report_init.aSeverityTable [REPORT_SEVERITY_SM] = '0';
+ iTwdCtrl.report_init.aSeverityTable [REPORT_SEVERITY_CONSOLE] = '0';
+
+ for (TUint8 index = 0; index < REPORT_FILES_NUM; index++)
+ {
+ iTwdCtrl.report_init.aFileEnable [index] = '1';
+ }
+}
+
+/**
+* \fn OpenAllReports
+* \brief open all reports in report module.
+*
+* Use this function if you encounter some problem in a specific area.
+*
+* /note Used for debug only.
+*
+* /return
+*/
+void TIWha::OpenAllReports()
+{
+ for (TUint8 index = 0; index < SIZE_ARR(iTwdCtrl.report_init.aSeverityTable); index++)
+ {
+ iTwdCtrl.report_init.aSeverityTable [index] = '1';
+ }
+
+ for (TUint8 index = 0; index < REPORT_FILES_NUM; index++)
+ {
+ iTwdCtrl.report_init.aFileEnable [index] = '1';
+ }
+
+ report_SetDefaults (iTwdCtrl.hReport, &(iTwdCtrl.report_init));
+
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, "\n");
+}
+
+
+/**
+ * \fn RegisterCb
+ * \brief registers the TIWha callbacks
+ *
+ * Register callbacks To Twd level according to the action
+ * that we would like to be triggered on
+ *
+ * \note
+ * \return status whther the registration succeed or not.
+ * \sa
+ */
+WHA::TStatus TIWha::RegisterCb ()
+{
+ /* Register the failure event callback */
+ TWD_RegisterCb (iTwdCtrl.hTWD,
+ TWD_EVENT_FAILURE,
+ (TTwdCB *)TIWhaAdaptCB::FailureIndication,
+ this);
+
+ /* Register the send packet callback */
+ TWD_RegisterCb (iTwdCtrl.hTWD,
+ TWD_EVENT_TX_XFER_SEND_PKT_TRANSFER,
+ (TTwdCB *)TIWhaAdaptCB::TxXfer,
+ this);
+
+ /* Register the send complete packet callback */
+ TWD_RegisterCb (iTwdCtrl.hTWD,
+ TWD_EVENT_TX_RESULT_SEND_PKT_COMPLETE,
+ (TTwdCB *)TIWhaAdaptCB::TxComplete,
+ this);
+
+ /* Register the receive packet callback */
+ TWD_RegisterCb (iTwdCtrl.hTWD,
+ TWD_EVENT_RX_RECEIVE_PACKET,
+ (TTwdCB *)TIWhaAdaptCB::ReceivePacket,
+ this);
+
+ /* Register the request for buffer callback */
+ TWD_RegisterCb (iTwdCtrl.hTWD,
+ TWD_EVENT_RX_REQUEST_FOR_BUFFER,
+ (TTwdCB *)TIWhaAdaptCB::RequestForBuffer,
+ this);
+
+ /* register scan SRV scan complete CB */
+ TWD_RegisterScanCompleteCb (iTwdCtrl.hTWD,
+ (TScanSrvCompleteCb)TIWhaAdaptCB::ScanComplete, this);
+
+ return WHA::KSuccess;
+}
+
+/**
+ * \fn RegisterEvents
+ * \brief register the TIWha Events
+ *
+ * Register callbacks To Twd level according to the event
+ * that we would like to be triggered on
+ *
+ * \note
+ * \return status whther the registration succeed or not.
+ * \sa
+ */
+WHA::TStatus TIWha::RegisterEvents ()
+{
+ /* Register the Regain BSS callback */
+ TWD_RegisterEvent (iTwdCtrl.hTWD,
+ TWD_OWN_EVENT_BSS_REGAIN,
+ (void *)TIWhaAdaptCB::RegainBssIndication,
+ this);
+
+ /* Register the RSSI callback */
+ TWD_RegisterEvent (iTwdCtrl.hTWD,
+ TWD_OWN_EVENT_RSSI_SNR_TRIGGER_0, //adi - rssi - use TWD_EVENT_RSSI_SNR_TRIGGER_0
+ (void *)TIWhaAdaptCB::RcpiIndication,
+ this);
+ TWD_EnableEvent (iTwdCtrl.hTWD, TWD_OWN_EVENT_RSSI_SNR_TRIGGER_0);
+#if 0
+ assaf: no support
+ TWD_RegisterEvent (iTwdCtrl.hTWD,
+ TWD_EVENT_RSSI_LEVEL_REGAIN, //adi - rssi - use TWD_EVENT_RSSI_SNR_TRIGGER_0
+ (void *)TIWhaAdaptCB::RcpiIndication,
+ this);
+#endif
+ /* Register & enable the Join callback */
+ TWD_RegisterEvent (iTwdCtrl.hTWD,
+ TWD_OWN_EVENT_JOIN_CMPLT,
+ (void *)TIWhaAdaptCB::JoinComplete,
+ this);
+
+ TWD_EnableEvent (iTwdCtrl.hTWD, TWD_OWN_EVENT_JOIN_CMPLT);
+
+#if 0
+ assaf: no BT support
+ /* Register the BtCoexsitence indications */
+ TWD_RegisterEvent (iTwdCtrl.hTWD,
+ TWD_EVENT_BT_COEX_SENSE,
+ (void *)TIWhaAdaptCB::btCoexSenseIndication,
+ this);
+
+ TWD_RegisterEvent (iTwdCtrl.hTWD,
+ TWD_EVENT_BT_COEX_PROTECTIVE_MODE,
+ (void *)TIWhaAdaptCB::btCoexProtectiveIndication,
+ this);
+
+ TWD_RegisterEvent (iTwdCtrl.hTWD,
+ TWD_EVENT_BT_COEX_AVALANCHE,
+ (void *)TIWhaAdaptCB::btCoexAvalancheIndication,
+ this);
+#endif
+ /* Roaming Triggers */
+ TWD_RegisterEvent (iTwdCtrl.hTWD,
+ TWD_OWN_EVENT_BSS_LOSE,
+ (void *)TIWhaAdaptCB::LostBssIndication,
+ this);
+
+ TWD_EnableEvent (iTwdCtrl.hTWD, TWD_OWN_EVENT_BSS_LOSE);
+
+
+
+ return WHA::KSuccess;
+}
+
+
+
+
+/**
+* \fn FillNWSASettings
+* \brief Fill UMAC structure with correct settings
+*
+* since we ave no ini file, we are initializing the
+* Modules wit hard coded values
+* \note
+*
+* \param SNWSASettings - pointer pointer to the UMAC settings struct
+* \return status
+*/
+WHA::TStatus TIWha::FillNWSASettings (WHA::SSettings *SNWSASettings)
+{
+#ifdef HT_SUPPORT
+ TTwdHtCapabilities* pTwdHtCapabilities;
+#endif /* HT_SUPPORT */
+ TRACE0(iTwdCtrl.hReport, REPORT_SEVERITY_INIT, "FillNWSASettings +");
+
+ /* Fill all the parameters in the NWSA Settings */
+ SNWSASettings->iNumOfSSIDs = TIWha_SCAN_MAX_SSID_NUM;
+ SNWSASettings->iRxBufAlignment = TIWha_NO_BUFFER_ALIGNMENT_SETTING; /* no alignment is needed */
+ SNWSASettings->iNumOfBytesForSsid = TIWha_MAX_SSID_LEN;
+ SNWSASettings->iRates = TIWha_RATE_BIT_MASK_SUPPORT;
+ SNWSASettings->iBand = TIWha_BAND_BIT_MASK_SUPPORT;
+ SNWSASettings->iRxoffset = WSPI_PAD_LEN_READ + sizeof(RxIfDescriptor_t);
+ SNWSASettings->iNumOfGroupTableEntrys = ADDRESS_GROUP_MAX;
+ SNWSASettings->iNumOfTxRateClasses = MAX_NUM_OF_TX_RATE_CLASS_POLICIES;
+ SNWSASettings->iTxFrameTrailerSpace = 0;
+ SNWSASettings->iTxFrameHeaderSpace = TX_TOTAL_OFFSET_BEFORE_DATA;
+ SNWSASettings->iFlagsMask = TIWha_RECEIVE_PACKET_BIT_MASK_SUPPORT;
+ SNWSASettings->iCapability = TIWha_CAPABILITY_BIT_MASK_SUPPORT;
+
+#ifdef GEM_SUPPORT
+ SNWSASettings->iCapability |= TIWha_CAPABILITY_GEM_SUPPORT;
+#endif /* GEM_SUPPORT */
+
+#ifdef MB_ENABLE
+ SNWSASettings->iCapability |= TIWha_CAPABILITY_MB_SUPPORT;
+#endif
+
+#ifdef HT_SUPPORT
+ SNWSASettings->iCapability |= TIWha_CAPABILITY_HT_OPERATION;
+#endif /* HT_SUPPORT */
+
+ SNWSASettings->iCapability |= TIWha_CAPABILITY_AUTO_RATE;
+
+ /* Add DS Parameters -- Allow only APs from the requested channel
+ to answer the probe increase scan result in crowded environment */
+
+ //SNWSASettings->iCapability |= WHA::SSettings::KDsParamSetIeInProbe;
+
+ /* Tx power level for each radio band */
+ TFwInfo *pFwInfo = TWD_GetFWInfo (iTwdCtrl.hTWD);
+
+ /*
+ * 2.4 GHz
+ * in txPowerTable[x][y]: x - 0 for 2.4GHz, y - power level starting from 0 to NUM_POWER_LEVELS - 1
+ */
+ SNWSASettings->iTxPowerRange[0].iMaxPowerLevel =
+ pFwInfo->txPowerTable[RADIO_BAND_2_4_GHZ][0] / DBM_TO_TX_POWER_FACTOR;
+ SNWSASettings->iTxPowerRange[0].iMinPowerLevel =
+ pFwInfo->txPowerTable[RADIO_BAND_2_4_GHZ][NUM_POWER_LEVELS - 1] / DBM_TO_TX_POWER_FACTOR;
+ SNWSASettings->iTxPowerRange[0].iStepping = 0;
+
+ TRACE3(iTwdCtrl.hReport, REPORT_SEVERITY_INFORMATION, ": 2.4 iMaxPowerLevel = %d iMinPowerLevel = %d stepping = %d\n", SNWSASettings->iTxPowerRange[0].iMaxPowerLevel, SNWSASettings->iTxPowerRange[0].iMinPowerLevel, SNWSASettings->iTxPowerRange[0].iStepping);
+
+ /* 4.9 GHZ temporary not supported for the power level */
+ SNWSASettings->iTxPowerRange[1].iMaxPowerLevel = 0;
+ SNWSASettings->iTxPowerRange[1].iMinPowerLevel = 0;
+ SNWSASettings->iTxPowerRange[1].iStepping = 0;
+
+ /* 5.0 GHZ temporary not supported for the power level since there are 4 sub-bands */
+ SNWSASettings->iTxPowerRange[2].iMaxPowerLevel = 0;
+ SNWSASettings->iTxPowerRange[2].iMinPowerLevel = 0;
+ SNWSASettings->iTxPowerRange[2].iStepping = 0;
+
+#ifdef HT_SUPPORT
+ TWD_GetTwdHtCapabilities (iTwdCtrl.hTWD,&pTwdHtCapabilities);
+ TConvertTwdHtCapa2SHtCapa (pTwdHtCapabilities,&SNWSASettings->iHtCapabilities);
+#endif /* HT_SUPPORT */
+
+ return WHA::KSuccess;
+}
+
+
+/****************************************************************************
+ * FillRadioData
+ ****************************************************************************
+ * DESCRIPTION: fill Radio params , in future will be done by Radio scope
+ *
+ * INPUTS:
+ *
+ * OUTPUT: radio params
+ *
+ * RETURNS: OK
+ ****************************************************************************/
+void TIWha::FillRadioData()
+{
+
+ iAutoRadioParams.tGeneralParams.TXBiPFEMAutoDetect = FEM_AUTO_DETECT_MODE_E;
+ iAutoRadioParams.tGeneralParams.TXBiPFEMManufacturer = FEM_TRIQUINT_TYPE_E;
+
+ iAutoRadioParams.tGeneralParams.RefClk = eREF_CLK_38_4_E;
+ iAutoRadioParams.tGeneralParams.SettlingTime = 5;
+ iAutoRadioParams.tGeneralParams.ClockValidOnWakeup = REF_CLK_NOT_VALID_E;
+ iAutoRadioParams.tGeneralParams.DC2DCMode = BT_SPI_IS_NOT_USED_E;
+ iAutoRadioParams.tGeneralParams.Single_Dual_Band_Solution = SINGLE_BAND_SOLUTION_E;
+
+ iAutoRadioParams.tStatRadioParams.RxTraceInsertionLoss_2_4G = 0;
+ iAutoRadioParams.tStatRadioParams.TXTraceLoss_2_4G = 0;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[0] = 0xEC;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[1] = 0xF6;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[2] = 0x00;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[3] = 0x0C;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[4] = 0x18;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[5] = 0xF8;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[6] = 0xFC;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[7] = 0x00;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[8] = 0x08;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[9] = 0x10;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[10] = 0xF0;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[11] = 0xF8;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[12] = 0x00;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[13] = 0x0A;
+ iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_2_4G[14] = 0x14;
+ memset(&iAutoRadioParams.tStatRadioParams.RxTraceInsertionLoss_5G[0],0,NUMBER_OF_SUB_BANDS_IN_5G_BAND_E);
+ memset(&iAutoRadioParams.tStatRadioParams.TXTraceLoss_5G[0],0,NUMBER_OF_SUB_BANDS_IN_5G_BAND_E);
+ memset(&iAutoRadioParams.tStatRadioParams.RxRssiAndProcessCompensation_5G[0],0,RSSI_AND_PROCESS_COMPENSATION_TABLE_SIZE);
+
+/* RMFD deafult value */
+ if (iAutoRadioParams.tGeneralParams.Single_Dual_Band_Solution == DUAL_BAND_SOLUTION_E)
+ {
+
+ iAutoRadioParams.tDynRadioParams[0].TXBiPReferencePDvoltage_2_4G = 0 ;
+ iAutoRadioParams.tDynRadioParams[0].TxBiPReferencePower_2_4G = 0;
+ iAutoRadioParams.tDynRadioParams[0].TxBiPOffsetdB_2_4G = 0;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[0] = 0x1E;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[1] = 0x1F;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[2] = 0x22;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[3] = 0x24;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[4] = 0x28;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[5] = 0x29;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[0] = 0x1B;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[1] = 0x1C;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[2] = 0x1E;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[3] = 0x20;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[4] = 0x24;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[5] = 0x25;
+ for (int i=0; i<NUMBER_OF_2_4_G_CHANNELS;i++)
+ {
+ iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_2_4G_11b[i] = 0x50;
+ iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_2_4G_OFDM[i] = 0x50;
+ }
+
+ iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_2_4G_OFDM[0] = 0x20;
+ iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_2_4G_OFDM[10] = 0x20;
+ memset(&iAutoRadioParams.tDynRadioParams[0].TxPDVsRateOffsets_2_4G[0],0,NUMBER_OF_RATE_GROUPS_E);
+ for (int i=0; i<NUMBER_OF_RATE_GROUPS_E;i++)
+ {
+ iAutoRadioParams.tDynRadioParams[0].TxIbiasTable_2_4G[i] = 0x0E;
+ }
+ iAutoRadioParams.tDynRadioParams[0].TxIbiasTable_2_4G[5] = 0x17;
+ iAutoRadioParams.tDynRadioParams[0].RxFemInsertionLoss_2_4G = 0x0D;
+
+ // SECTION 2: 5G parameters
+ memset(&iAutoRadioParams.tDynRadioParams[0].TXBiPReferencePDvoltage_5G[0],0,NUMBER_OF_RATE_GROUPS_E);
+ memset(&iAutoRadioParams.tDynRadioParams[0].TxBiPReferencePower_5G[0],0,NUMBER_OF_RATE_GROUPS_E);
+ memset(&iAutoRadioParams.tDynRadioParams[0].TxBiPOffsetdB_5G[0],0,NUMBER_OF_RATE_GROUPS_E);
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Normal[0] = 0x1D;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Normal[1] = 0x1E;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Normal[2] = 0x21;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Normal[3] = 0x23;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Normal[4] = 0x27;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Normal[5] = 0;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Degraded[0]= 0x1A;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Degraded[1] = 0x1B;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Degraded[2] = 0x1D;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Degraded[3] = 0x1F;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Degraded[4] = 0x23;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_5G_Degraded[5] = 0x00;
+ memset(&iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_5G_OFDM[0],0,NUMBER_OF_5G_CHANNELS);
+ memset(&iAutoRadioParams.tDynRadioParams[0].TxPDVsRateOffsets_5G[0],0,NUMBER_OF_RATE_GROUPS_E);
+ for (int i=0;i<NUMBER_OF_RATE_GROUPS_E;i++)
+ {
+ iAutoRadioParams.tDynRadioParams[0].TxIbiasTable_5G[i] = 0x27;
+ iAutoRadioParams.tDynRadioParams[0].RxFemInsertionLoss_5G[i] = 0x12;
+ }
+
+ iAutoRadioParams.tDynRadioParams[0].TxIbiasTable_5G[5] = 0;
+
+ }
+ else
+ {
+ iAutoRadioParams.tDynRadioParams[0].TXBiPReferencePDvoltage_2_4G =0x24E ;
+ iAutoRadioParams.tDynRadioParams[0].TxBiPReferencePower_2_4G = 0x78;
+ iAutoRadioParams.tDynRadioParams[0].TxBiPOffsetdB_2_4G = 0;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[0] = 0x1E;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[1] = 0x1F;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[2] = 0x22;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[3] = 0x24;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[4] = 0x28;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Normal[5] = 0x29;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[0] = 0x1B;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[1] = 0x1C;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[2] = 0x1E;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[3] = 0x20;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[4] = 0x24;
+ iAutoRadioParams.tDynRadioParams[0].TxPerRatePowerLimits_2_4G_Degraded[5] = 0x25;
+ for (int i =0;i<NUMBER_OF_2_4_G_CHANNELS;i++)
+ {
+ iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_2_4G_11b[i] = 0x50;
+ iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_2_4G_OFDM[i] = 0x50;
+ }
+ iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_2_4G_OFDM[0] = 0x20;
+ iAutoRadioParams.tDynRadioParams[0].TxPerChannelPowerLimits_2_4G_OFDM[10] = 0x20;
+ memset(&iAutoRadioParams.tDynRadioParams[0].TxPDVsRateOffsets_2_4G[0],0,NUMBER_OF_RATE_GROUPS_E);
+ for (int i = 0 ;i <NUMBER_OF_RATE_GROUPS_E;i++)
+ {
+ iAutoRadioParams.tDynRadioParams[0].TxIbiasTable_2_4G[i] = 0x1A;
+ }
+
+ iAutoRadioParams.tDynRadioParams[0].TxIbiasTable_2_4G[5] = 0x2F;
+ iAutoRadioParams.tDynRadioParams[0].RxFemInsertionLoss_2_4G = 0;
+
+/* TriQuint default value */
+ iAutoRadioParams.tDynRadioParams[1].TXBiPReferencePDvoltage_2_4G= 0x168;
+ iAutoRadioParams.tDynRadioParams[1].TxBiPReferencePower_2_4G= 0x83;
+ iAutoRadioParams.tDynRadioParams[1].TxBiPOffsetdB_2_4G=0;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Normal[0] = 0x1E;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Normal[1] = 0x1F;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Normal[2] = 0x22;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Normal[3] = 0x24;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Normal[4] = 0x28;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Normal[5] = 0x29;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Degraded[0] = 0x1B;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Degraded[1] = 0x1C;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Degraded[2] = 0x1E;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Degraded[3] = 0x20;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Degraded[4] = 0x24;
+ iAutoRadioParams.tDynRadioParams[1].TxPerRatePowerLimits_2_4G_Degraded[5] = 0x25;
+ for (int i =0;i<NUMBER_OF_2_4_G_CHANNELS;i++)
+ {
+ iAutoRadioParams.tDynRadioParams[1].TxPerChannelPowerLimits_2_4G_11b[i] = 0x50;
+ iAutoRadioParams.tDynRadioParams[1].TxPerChannelPowerLimits_2_4G_OFDM[i] = 0x50;
+ }
+ iAutoRadioParams.tDynRadioParams[1].TxPerChannelPowerLimits_2_4G_OFDM[0] = 0x20;
+ iAutoRadioParams.tDynRadioParams[1].TxPerChannelPowerLimits_2_4G_OFDM[10] = 0x20;
+ memset(&iAutoRadioParams.tDynRadioParams[1].TxPDVsRateOffsets_2_4G[0],0,NUMBER_OF_RATE_GROUPS_E);
+ for (int i = 0 ;i <NUMBER_OF_RATE_GROUPS_E;i++)
+ {
+ iAutoRadioParams.tDynRadioParams[1].TxIbiasTable_2_4G[i] = 0x11;
+ }
+
+ iAutoRadioParams.tDynRadioParams[1].TxIbiasTable_2_4G[5] = 0x12;
+ iAutoRadioParams.tDynRadioParams[1].RxFemInsertionLoss_2_4G = 0x12;
+ }
+}
+
+void TIWha::FillSmartReflexData()
+{
+ iSmartReflexParams.SmartReflexState = 0;
+
+ iSmartReflexParams.tErrorTable[0].len = 7;
+ iSmartReflexParams.tErrorTable[0].upperLimit = 3;
+ iSmartReflexParams.tErrorTable[0].values[0] = 24;
+ iSmartReflexParams.tErrorTable[0].values[1] = 16;
+ iSmartReflexParams.tErrorTable[0].values[2] = 5;
+ iSmartReflexParams.tErrorTable[0].values[3] = -5;
+ iSmartReflexParams.tErrorTable[0].values[4] = -16;
+ iSmartReflexParams.tErrorTable[0].values[5] = -24;
+ iSmartReflexParams.tErrorTable[1].len = 7;
+ iSmartReflexParams.tErrorTable[1].upperLimit = 3;
+ iSmartReflexParams.tErrorTable[1].values[0] = 24;
+ iSmartReflexParams.tErrorTable[1].values[1] = 16;
+ iSmartReflexParams.tErrorTable[1].values[2] = 5;
+ iSmartReflexParams.tErrorTable[1].values[3] = -5;
+ iSmartReflexParams.tErrorTable[1].values[4] = -16;
+ iSmartReflexParams.tErrorTable[1].values[5] = -24;
+ iSmartReflexParams.tErrorTable[2].len = 7;
+ iSmartReflexParams.tErrorTable[2].upperLimit = 3;
+ iSmartReflexParams.tErrorTable[2].values[0] = 24;
+ iSmartReflexParams.tErrorTable[2].values[1] = 16;
+ iSmartReflexParams.tErrorTable[2].values[2] = 5;
+ iSmartReflexParams.tErrorTable[2].values[3] = -5;
+ iSmartReflexParams.tErrorTable[2].values[4] = -16;
+ iSmartReflexParams.tErrorTable[2].values[5] = -24;
+}
+
+#if TI_DBG
+/****************************************************************************
+ * PrintRadioData
+ ****************************************************************************
+ * DESCRIPTION: print Radio params , used for debug
+ *
+ * INPUTS:
+ *
+ * OUTPUT: radio params
+ *
+ * RETURNS: OK
+ ****************************************************************************/
+void TIWha::PrintRadioData()
+{
+ TI_UINT32 i,j;
+ TI_UINT8* pRadio;
+
+ pRadio = reinterpret_cast<TI_UINT8*>(&iAutoRadioParams);
+
+ i=0;
+ os_printf("/**********************/ \n");
+ os_printf("/* INI General params */ \n");
+ os_printf("/**********************/ \n");
+
+ os_printf("0x%x, /* RefClk */ \n", pRadio[i++]);
+ os_printf("0x%x, /* SettlingTime */ \n", pRadio[i++]);
+ os_printf("0x%x, /* ClockValidOnWakeup */ \n", pRadio[i++]);
+ os_printf("0x%x, /* DC2DCMode */ \n", pRadio[i++]);
+ os_printf("0x%x, /* Single_Dual_Band_Solution */ \n", pRadio[i++]);
+ os_printf("0x%x, /* TXBiPFEMAutoDetect */ \n", pRadio[i++]);
+ os_printf("0x%x, /* TXBiPFEMManufacturer */ \n", pRadio[i++]);
+ os_printf("0x%x, /* Padding */ \n", pRadio[i++]);
+
+ os_printf("/*************************/ \n");
+ os_printf("/* INI Stat Radio params */ \n");
+ os_printf("/*************************/ \n");
+
+ os_printf("0x%x, /* RxTraceInsertionLoss_2_4G */ \n", pRadio[i++]);
+ os_printf("0x%x, /* TXTraceLoss_2_4G */ \n", pRadio[i++]);
+ for (j=0;j<15;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* RxRssiAndProcessCompensation_2_4G[15] */ \n");
+ for (j=0;j<7;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* RxTraceInsertionLoss_5G[7] */ \n");
+ for (j=0;j<7;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TXTraceLoss_5G[7] */ \n");
+ for (j=0;j<15;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* RxRssiAndProcessCompensation_5G[15] */ \n");
+
+ os_printf("/*******************************/ \n");
+ os_printf("/* Dyn Radio Params. First FEM */ \n");
+ os_printf("/*******************************/ \n");
+
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("0x%x, /* TXBiPReferencePDvoltage_2_4G */ \n", pRadio[i++]);
+ os_printf("0x%x, /* TxBiPReferencePower_2_4G */ \n", pRadio[i++]);
+ os_printf("0x%x, /* TxBiPOffsetdB_2_4G */ \n", pRadio[i++]);
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerRatePowerLimits_2_4G_Normal[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerRatePowerLimits_2_4G_Degraded[6] */ \n");
+ for (j=0;j<14;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerChannelPowerLimits_2_4G_11b[14] */ \n");
+ for (j=0;j<14;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerChannelPowerLimits_2_4G_OFDM[14] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPDVsRateOffsets_2_4G[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxIbiasTable_2_4G[6] */ \n");
+ os_printf("0x%x, /* RxFemInsertionLoss_2_4G */ \n", pRadio[i++]);
+ for (j=0;j<35;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerChannelPowerLimits_5G_OFDM[35] */ \n");
+ for (j=0;j<14;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TXBiPReferencePDvoltage_5G[7*2] */ \n");
+ for (j=0;j<7;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxBiPReferencePower_5G[7] */ \n");
+ for (j=0;j<7;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxBiPOffsetdB_5G[7] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerRatePowerLimits_5G_Normal[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerRatePowerLimits_5G_Degraded[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPDVsRateOffsets_5G[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxIbiasTable_5G[6] */ \n");
+ for (j=0;j<7;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* RxFemInsertionLoss_5G[7] */ \n");
+ os_printf("0x%x, /* Padding */ \n", pRadio[i++]);
+
+ os_printf("/************************************/ \n");
+ os_printf("/* INI Dyn Radio Params. Second FEM */ \n");
+ os_printf("/************************************/ \n");
+
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("0x%x, /* TXBiPReferencePDvoltage_2_4G */ \n", pRadio[i++]);
+ os_printf("0x%x, /* TxBiPReferencePower_2_4G */ \n", pRadio[i++]);
+ os_printf("0x%x, /* TxBiPOffsetdB_2_4G */ \n", pRadio[i++]);
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerRatePowerLimits_2_4G_Normal[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerRatePowerLimits_2_4G_Degraded[6] */ \n");
+ for (j=0;j<14;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerChannelPowerLimits_2_4G_11b[14] */ \n");
+ for (j=0;j<14;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerChannelPowerLimits_2_4G_OFDM[14] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPDVsRateOffsets_2_4G[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxIbiasTable_2_4G[6] */ \n");
+ os_printf("0x%x, /* RxFemInsertionLoss_2_4G */ \n", pRadio[i++]);
+ for (j=0;j<14;j++)
+ {
+ os_printf("0x%x, ", pRadio[i++]);
+ }
+ os_printf("/* TXBiPReferencePDvoltage_5G[7*2] */ \n");
+ for (j=0;j<7;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxBiPReferencePower_5G[7] */ \n");
+ for (j=0;j<7;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxBiPOffsetdB_5G[7] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerRatePowerLimits_5G_Normal[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerRatePowerLimits_5G_Degraded[6] */ \n");
+ for (j=0;j<35;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPerChannelPowerLimits_5G_OFDM[35] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxPDVsRateOffsets_5G[6] */ \n");
+ for (j=0;j<6;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* TxIbiasTable_5G[6] */ \n");
+ for (j=0;j<7;j++)
+ os_printf("0x%x, ", pRadio[i++]);
+ os_printf("/* RxFemInsertionLoss_5G[7] */ \n");
+ os_printf("0x%x /* Padding */ \n", pRadio[i++]);
+}
+#endif
+
+
+/**
+* \fn TIFailureDfcClient
+* \brief Constructor
+*
+* This method is the default constructor for TIFailureDfcClient.
+* This class is in charge of creating a new DFC that will handle
+* the failure handling & dispatch to the umac in case of a failure event.
+*
+* \note
+* return handle to TIFailureDfcClient class.
+* \sa
+*/
+TIFailureDfcClient::TIFailureDfcClient(MWlanOsa& aOsa)
+{
+ pFailureDfc = aOsa.DfcCreate();
+}
+
+
+/**
+* \fn TIFailureDfcClient::OnDfc
+* \brief Call TIWhaAdaptCB::FailureIndicationDFC from TIFailureDfcClient context
+*
+* \param handle to TIWha context
+*
+* /note
+*
+* /return void
+*/
+void TIFailureDfcClient::OnDfc(TInt aCtx)
+{
+ TIWhaAdaptCB::FailureIndicationDFC ((TI_HANDLE)aCtx);
+}
+
+
+/**
+* \fn TIConnectDfcClient
+* \brief Constructor
+*
+* This method is the default constructor for TIConnectDfcClient.
+* This class is in charge of creating a new DFC that will handle
+* the end of the bus connection phase in case of a sync init bus transaction .
+*
+* \note
+* return handle to TIConnectDfcClient class.
+* \sa
+*/
+TIConnectDfcClient::TIConnectDfcClient(MWlanOsa& aOsa)
+{
+ pConnectDfc = aOsa.DfcCreate();
+}
+
+
+/**
+* \fn TIConnectDfcClient::OnDfc
+* \brief Call TIWhaAdaptCB::ConnectBus from TIConnectDfcClient context
+*
+* \param handle to TIWha context
+*
+* /note
+*
+* /return void
+*/
+void TIConnectDfcClient::OnDfc(TInt aCtx)
+{
+ TIWhaAdaptCB::ConnectBus ((TI_HANDLE)aCtx);
+}
+
+
+
+/*****************************************************************************************************/
+/************************************** CREATE DRIVER ************************************************/
+
+
+DECLARE_STANDARD_PDD()
+{
+ TIWha* p = new TIWha;
+ return p;
+}
+
+
+ TInt TIWha::Install()
+ {
+ TPtrC mDeviceName= DEVICE_NAME;
+
+ return SetName(&mDeviceName);
+ }
+
+ void TIWha::GetCaps( TDes8& aDes ) const
+ {
+ aDes.FillZ(aDes.MaxLength());
+
+ aDes.Copy( (TUint8*)&iVersion, Min(aDes.MaxLength(), sizeof(TVersion)) );
+ }
+
+
+
+ TInt TIWha::Create( DBase *&aChannel, TInt aUnit, const TDesC* anInfo, const TVersion& aVer)
+ {
+ if ( !Kern::QueryVersionSupported( iVersion, aVer ) )
+ {
+ return KErrNotSupported;
+ }
+ if (bDriverCreated) {
+ aChannel = (MWlanPddIface*)this;
+ return KErrNone;
+ }
+ else
+ {
+ return KErrNotReady;
+ }
+ }
+
+
+ TInt TIWha::Validate( TInt aUnit, const TDesC8 *aInfo, const TVersion &aVer )
+ {
+ return KErrNone;
+ }
+
+ TBool TIWha::Attach( MWlanOsa& aWlanOsa, MWlanOsaExt& aWlanOsaExt )
+ {
+ iTwdCtrl.tOsContext.hOsa = &aWlanOsa;
+
+ /* Create HPA */
+ iTwdCtrl.tOsContext.hHpa = WlanHpa::Create( aWlanOsaExt, aWlanOsa);
+
+ /* Create SPIA */
+ iTwdCtrl.tOsContext.hSpia = WlanSpia::Create( aWlanOsaExt );
+
+ if (iTwdCtrl.tOsContext.hHpa == NULL || iTwdCtrl.tOsContext.hSpia == NULL) {
+ WLAN_OS_REPORT (("Failed to create Driver layers -- iHpa = 0x%x, , iSpia = 0x%x",iTwdCtrl.tOsContext.hHpa,iTwdCtrl.tOsContext.hSpia));
+ return EFalse;
+ }
+
+
+ pFailureDfcClient = new TIFailureDfcClient(*iTwdCtrl.tOsContext.hOsa);
+ if (pFailureDfcClient == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR: CreateDriver TIFailureDfcClient failure\n"));
+ }
+
+ pConnectDfcClient = new TIConnectDfcClient(*iTwdCtrl.tOsContext.hOsa);
+ if (pConnectDfcClient == NULL)
+ {
+ WLAN_OS_REPORT (("ERROR: CreateDriver TIConnectDfcClient failure\n"));
+ }
+
+ return ETrue;
+ }
+
+
+ WHA::Wha& TIWha::Extract()
+ {
+ return *this;
+ }
+
+
+ void TIWha::GetCapabilities( SCapabilities*& aCapabilities )
+ {
+ aCapability = (SCapabilities*)Kern::Alloc(sizeof(SCapabilities));
+ aCapability->iCapabilities = SCapabilities::KCachedMemory;
+ aCapability->iCacheLineLength = 32;
+
+ aCapabilities = aCapability;
+ }