/*

 * 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;