path: root/wl1271/stad/src/Ctrl_Interface/DrvMain.c

/*
 * DrvMain.c
 *
 * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.      
 * All rights reserved.                                                  
 *                                                                       
 * 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   DrvMain.c 
 *  \brief  The DrvMain module. Handles driver init, stop and recovery processes.
 *  
 *  \see    DrvMain.h
 */

#define __FILE_ID__  FILE_ID_49
#include "tidef.h"
#include "osApi.h"
#include "report.h"
#include "context.h"
#include "timer.h"
#include "CmdHndlr.h"
#include "DrvMain.h"
#include "scrApi.h"
#include "EvHandler.h"
#include "connApi.h"
#include "siteMgrApi.h"
#include "sme.h"
#include "SoftGeminiApi.h"
#include "roamingMngrApi.h"
#include "qosMngr_API.h"
#include "TrafficMonitor.h"
#include "PowerMgr_API.h"
#include "EvHandler.h"
#include "apConn.h"
#include "currBss.h"
#include "SwitchChannelApi.h"
#include "ScanCncn.h"
#include "healthMonitor.h"
#include "scanMngrApi.h"
#include "regulatoryDomainApi.h"
#include "measurementMgrApi.h"
#ifdef XCC_MODULE_INCLUDED
#include "XCCMngr.h"
#endif
#include "TxnQueue.h"
#include "TWDriver.h"
#include "debug.h"
#include "host_platform.h"
#include "StaCap.h"
#include "WlanDrvCommon.h"
#include "DrvMainModules.h"
#include "CmdDispatcher.h"


#define SM_WATCHDOG_TIME_MS     20000  /* SM processes timeout is 20 sec. */

#define SDIO_CONNECT_THRESHOLD  8

/* This is used to prevent endless recovery loops */
#define MAX_NUM_OF_RECOVERY_TRIGGERS 5

/* Handle failure status from the SM callbacks by triggering the SM with FAILURE event */
#define HANDLE_CALLBACKS_FAILURE_STATUS(hDrvMain, eStatus)      \
            if (eStatus != TI_OK) { drvMain_SmEvent (hDrvMain, SM_EVENT_FAILURE);  return; }
    
/* The DrvMain SM states */
typedef enum
{
    /*  0 */ SM_STATE_IDLE,
    /*  1 */ SM_STATE_WAIT_INI_FILE,
    /*  2 */ SM_STATE_WAIT_NVS_FILE,
    /*  3 */ SM_STATE_HW_INIT,
    /*  4 */ SM_STATE_DOWNLOAD_FW_FILE,
    /*  5 */ SM_STATE_WAIT_FW_FILE,
    /*  6 */ SM_STATE_FW_INIT,
    /*  7 */ SM_STATE_FW_CONFIG,
    /*  8 */ SM_STATE_OPERATIONAL,  
    /*  9 */ SM_STATE_DISCONNECTING,
    /* 10 */ SM_STATE_STOPPING,     
    /* 11 */ SM_STATE_STOPPED,      
    /* 12 */ SM_STATE_STOPPING_ON_FAIL,       
    /* 13 */ SM_STATE_FAILED        

} ESmState;

/* The DrvMain SM events */
typedef enum
{
    /*  0 */ SM_EVENT_START,
    /*  1 */ SM_EVENT_INI_FILE_READY,
    /*  2 */ SM_EVENT_NVS_FILE_READY,
    /*  3 */ SM_EVENT_HW_INIT_COMPLETE,
    /*  4 */ SM_EVENT_FW_FILE_READY,
    /*  5 */ SM_EVENT_FW_INIT_COMPLETE,
    /*  6 */ SM_EVENT_FW_CONFIG_COMPLETE,
    /*  7 */ SM_EVENT_STOP,          
    /*  8 */ SM_EVENT_RECOVERY,      
    /*  9 */ SM_EVENT_DISCONNECTED,  
    /* 10 */ SM_EVENT_STOP_COMPLETE, 
    /* 11 */ SM_EVENT_FAILURE

} ESmEvent;

/* The module's object */
typedef struct
{
    TStadHandlesList  tStadHandles; /* All STAD modules handles (distributed in driver init process) */
	TI_BOOL           bRecovery;    /* Indicates if we are during recovery process */
	TI_UINT32         uNumOfRecoveryAttempts;    /* Indicates if we are during recovery process */
	ESmState          eSmState;     /* The DrvMain SM state. */
	ESmEvent          ePendingEvent;/* A pending event issued when the SM is busy */
    TI_UINT32         uPendingEventsCount; /* Counts the number of events pending for SM execution */
    TFileInfo         tFileInfo;    /* Information of last file retrieved by os_GetFile() */
    TI_UINT32         uContextId;   /* ID allocated to this module on registration to context module */
    EActionType       eAction;      /* The last action (start/stop) inserted to the driver */
    void             *hSignalObj;   /* The signal object used for waiting for action completion */
    TBusDrvCfg        tBusDrvCfg;   /* A union (struc per each supported bus type) for the bus driver configuration */
    TI_UINT32         uRxDmaBufLen; /* The bus driver Rx DMA buffer length (needed as a limit for Rx aggregation length) */
    TI_UINT32         uTxDmaBufLen; /* The bus driver Tx DMA buffer length (needed as a limit for Tx aggregation length) */

} TDrvMain;


static void drvMain_Init (TI_HANDLE hDrvMain);
static void drvMain_InitHwCb (TI_HANDLE hDrvMain, TI_STATUS eStatus);
static void drvMain_InitFwCb (TI_HANDLE hDrvMain, TI_STATUS eStatus);
static void drvMain_ConfigFwCb (TI_HANDLE hDrvMain, TI_STATUS eStatus);
static void drvMain_TwdStopCb (TI_HANDLE hDrvMain, TI_STATUS eStatus);
static void drvMain_InitFailCb (TI_HANDLE hDrvMain, TI_STATUS eStatus);
static void drvMain_InitLocals (TDrvMain *pDrvMain);
/* static void drvMain_SmWatchdogTimeout (TI_HANDLE hDrvMain); */
static void drvMain_SmEvent (TI_HANDLE hDrvMain, ESmEvent eEvent);
static void drvMain_Sm (TI_HANDLE hDrvMain, ESmEvent eEvent);

/* External functions prototypes */

/** \brief WLAN Driver I/F Get file
 * 
 * \param  hOs         - OS module object handle
 * \param  pFileInfo   - Pointer to output file information
 * \return TI_OK on success or TI_NOK on failure 
 * 
 * \par Description
 * This function provides access to a requested init file:
 * It provides the requested file information and call the requester callback.
 * Note that in Linux the files were previously loaded to driver memory by the loader
 * 
 * \sa
 */ 
extern int  wlanDrvIf_GetFile (TI_HANDLE hOs, TFileInfo *pFileInfo);
/** \brief WLAN Driver I/F Update Driver State
 * 
 * \param  hOs          - OS module object handle
 * \param  eDriverState - New Driver State
 * \return void
 * 
 * \par Description
 * This function Update the driver state (Idle | Running | Stopped |Failed):
 * 
 * \sa
 */
extern void wlanDrvIf_UpdateDriverState (TI_HANDLE hOs, EDriverSteadyState eDriverState);
/** \brief WLAN Driver I/F Set MAC Address
 * 
 * \param  hOs          - OS module object handle
 * \param  pMacAddr     - Pointer to MAC address to set
 * \return void
 * 
 * \par Description
 * This function Update the driver MAC address by copy it to the network interface structure
 * 
 * \sa
 */
extern void wlanDrvIf_SetMacAddress (TI_HANDLE hOs, TI_UINT8 *pMacAddr);
/** \brief OS Init Table INI File
 * 
 * \param  hOs              - OS module object handle
 * \param  InitTable        - Pointer to initialization table
 * \param  file_buf         - Pointer to Input buffer from INI file
 * \param  file_length      - Length of input buffer from INI file
 * \return void
 * 
 * \par Description
 * This function perform Initializing of init table accrding to data from INI file and driver defaults
 * 
 * \sa
 */
extern int  osInitTable_IniFile (TI_HANDLE hOs, TInitTable *InitTable, char *file_buf, int file_length);



/* 
 * \fn     drvMain_Create
 * \brief  Create the driver modules
 * 
 * Create all STAD and TWD modules.
 * Then call all modules init functions which initializes their handles and variables.
 * 
 * \note   
 * \param  hOs          - Handle to the Os Abstraction Layer                           
 * \param  pDrvMainHndl - Pointer for returning the DrvMain handle.                      
 * \param  pCmdHndlr    - Pointer for returning the CmdHndlr handle.                      
 * \param  pContext     - Pointer for returning the Context handle.                      
 * \param  pTxDataQ     - Pointer for returning the TxDataQ handle.                      
 * \param  pTxMgmtQ     - Pointer for returning the TxMgmtQ handle.                      
 * \param  pTxCtrl      - Pointer for returning the TxCtrl handle.                      
 * \param  pTwd         - Pointer for returning the TWD handle.                      
 * \param  pEvHandler   - Pointer for returning the EvHndler handle.                      
 * \return Handle to the DrvMain module (NULL if failed) 
 * \sa     
 */ 
TI_STATUS drvMain_Create (TI_HANDLE  hOs, 
                          TI_HANDLE *pDrvMainHndl, 
                          TI_HANDLE *pCmdHndlr, 
                          TI_HANDLE *pContext, 
                          TI_HANDLE *pTxDataQ, 
                          TI_HANDLE *pTxMgmtQ,
                          TI_HANDLE *pTxCtrl,
                          TI_HANDLE *pTwd,
                          TI_HANDLE *pEvHandler,
		                  TI_HANDLE *pCmdDispatch,
                          TI_HANDLE *pReport)
{
    /* Create the DrvMain module object. */
    TDrvMain *pDrvMain = (TDrvMain *) os_memoryAlloc (hOs, sizeof(TDrvMain));

    if (pDrvMain == NULL) 
    {
        return TI_NOK;
    }

    os_memoryZero (hOs, (void *)pDrvMain, sizeof(TDrvMain));

    pDrvMain->tStadHandles.hDrvMain = (TI_HANDLE)pDrvMain;
    pDrvMain->tStadHandles.hOs = hOs;

/* 
 *   Create all driver modules
 *   =========================
 */

    pDrvMain->tStadHandles.hContext = context_Create (hOs);
    if (pDrvMain->tStadHandles.hContext == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hTimer = tmr_Create (hOs);
    if (pDrvMain->tStadHandles.hTimer == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hSCR = scr_create (hOs);
    if (pDrvMain->tStadHandles.hSCR == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hTxnQ = txnQ_Create (hOs);
    if (pDrvMain->tStadHandles.hTxnQ == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hEvHandler = EvHandler_Create (hOs);
    if (pDrvMain->tStadHandles.hEvHandler == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hReport = report_Create (hOs);
    if (pDrvMain->tStadHandles.hReport == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hConn = conn_create (hOs);
    if (pDrvMain->tStadHandles.hConn == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hScanCncn = scanCncn_Create (hOs);
    if (pDrvMain->tStadHandles.hScanCncn == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hSme = sme_Create (hOs);
    if (pDrvMain->tStadHandles.hSme == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hSiteMgr = siteMgr_create (hOs);
    if (pDrvMain->tStadHandles.hSiteMgr == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hMlmeSm = mlme_create (hOs);
    if (pDrvMain->tStadHandles.hMlmeSm == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hAuth = auth_create (hOs);
    if (pDrvMain->tStadHandles.hAuth == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hAssoc = assoc_create (hOs);
    if (pDrvMain->tStadHandles.hAssoc == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hRxData = rxData_create (hOs);
    if (pDrvMain->tStadHandles.hRxData == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hTxCtrl = txCtrl_Create (hOs);
    if (pDrvMain->tStadHandles.hTxCtrl == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hTxDataQ = txDataQ_Create(hOs);
    if (pDrvMain->tStadHandles.hTxDataQ == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hTxMgmtQ = txMgmtQ_Create(hOs);
    if (pDrvMain->tStadHandles.hTxMgmtQ == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hTxPort = txPort_create (hOs);
    if (pDrvMain->tStadHandles.hTxPort == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hCtrlData = ctrlData_create (hOs);
    if (pDrvMain->tStadHandles.hCtrlData == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hTrafficMon = TrafficMonitor_create (hOs);
    if (pDrvMain->tStadHandles.hTrafficMon == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hRsn = rsn_create (hOs);
    if (pDrvMain->tStadHandles.hRsn == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hRegulatoryDomain = regulatoryDomain_create (hOs);
    if (pDrvMain->tStadHandles.hRegulatoryDomain == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hMeasurementMgr = measurementMgr_create (hOs);
    if (pDrvMain->tStadHandles.hMeasurementMgr == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hSoftGemini = SoftGemini_create (hOs);
    if (pDrvMain->tStadHandles.hSoftGemini == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

#ifdef XCC_MODULE_INCLUDED
    pDrvMain->tStadHandles.hXCCMngr = XCCMngr_create (hOs);
    if (pDrvMain->tStadHandles.hXCCMngr == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }
#else
    pDrvMain->tStadHandles.hXCCMngr = NULL;
#endif

    pDrvMain->tStadHandles.hRoamingMngr = roamingMngr_create (hOs);
    if (pDrvMain->tStadHandles.hRoamingMngr == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hAPConnection = apConn_create (hOs);
    if (pDrvMain->tStadHandles.hAPConnection == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hCurrBss = currBSS_create (hOs);
    if (pDrvMain->tStadHandles.hCurrBss == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hQosMngr = qosMngr_create (hOs);
    if (pDrvMain->tStadHandles.hQosMngr == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hPowerMgr = PowerMgr_create (hOs);
    if (pDrvMain->tStadHandles.hPowerMgr == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hSwitchChannel = switchChannel_create (hOs);
    if (pDrvMain->tStadHandles.hSwitchChannel == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hScanMngr = scanMngr_create (hOs);
    if (NULL == pDrvMain->tStadHandles.hScanMngr)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hHealthMonitor = healthMonitor_create (hOs);
    if (NULL == pDrvMain->tStadHandles.hHealthMonitor)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hTWD = TWD_Create (hOs);
    if (pDrvMain->tStadHandles.hTWD == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hCmdHndlr = cmdHndlr_Create (hOs, pDrvMain->tStadHandles.hEvHandler);
    if (pDrvMain->tStadHandles.hCmdHndlr == NULL) 
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hCmdDispatch = cmdDispatch_Create (hOs);
    if (pDrvMain->tStadHandles.hCmdDispatch == NULL) 
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    pDrvMain->tStadHandles.hStaCap = StaCap_Create (hOs);
    if (pDrvMain->tStadHandles.hStaCap == NULL)
    {
        drvMain_Destroy (pDrvMain);
        return TI_NOK;
    }

    /* Bind all modules handles */
    drvMain_Init ((TI_HANDLE)pDrvMain);


    /* Provide required handles to the OAL */
    *pDrvMainHndl = (TI_HANDLE)pDrvMain;
    *pCmdHndlr    = pDrvMain->tStadHandles.hCmdHndlr;
    *pContext     = pDrvMain->tStadHandles.hContext;
    *pTxDataQ     = pDrvMain->tStadHandles.hTxDataQ;
    *pTxMgmtQ     = pDrvMain->tStadHandles.hTxMgmtQ;
    *pTxCtrl      = pDrvMain->tStadHandles.hTxCtrl;
    *pTwd         = pDrvMain->tStadHandles.hTWD;
    *pEvHandler   = pDrvMain->tStadHandles.hEvHandler;
    *pReport      = pDrvMain->tStadHandles.hReport;
    *pCmdDispatch = pDrvMain->tStadHandles.hCmdDispatch;

    WLAN_INIT_REPORT (("drvMain_Create: success\n"));

    return TI_OK;
}

/* 
 * \fn     drvMain_Destroy
 * \brief  Destroy driver
 * 
 * Destroy all STAD and TWD modules and resources.
 * 
 * \note   
 * \param  hDrvMain - The DrvMain object
 * \return TI_OK if succeeded, TI_NOK if failed. 
 * \sa     drvMain_Create
 */ 
TI_STATUS drvMain_Destroy (TI_HANDLE  hDrvMain)
{
    TDrvMain *pDrvMain = (TDrvMain *)hDrvMain;

    hPlatform_Wlan_Hardware_DeInit ();

    if (pDrvMain == NULL) 
    {
        return TI_NOK;
    }

    if (pDrvMain->tStadHandles.hScanMngr != NULL)
    {
        scanMngr_unload (pDrvMain->tStadHandles.hScanMngr);
    }

    if (pDrvMain->tStadHandles.hSiteMgr != NULL)
    {
        siteMgr_unLoad (pDrvMain->tStadHandles.hSiteMgr);
    }

    if (pDrvMain->tStadHandles.hSme != NULL)
    {
        sme_Destroy (pDrvMain->tStadHandles.hSme);
    }

    if (pDrvMain->tStadHandles.hConn != NULL)
    {
        conn_unLoad (pDrvMain->tStadHandles.hConn);
    }

    if (pDrvMain->tStadHandles.hTWD != NULL)
    {
        TWD_Destroy (pDrvMain->tStadHandles.hTWD);
    }

    if (pDrvMain->tStadHandles.hScanCncn != NULL)
    {
        scanCncn_Destroy (pDrvMain->tStadHandles.hScanCncn);
    }

    if (pDrvMain->tStadHandles.hTrafficMon != NULL)
    {
        TrafficMonitor_Destroy (pDrvMain->tStadHandles.hTrafficMon);
    }

    if (pDrvMain->tStadHandles.hCtrlData != NULL)
    {
        ctrlData_unLoad (pDrvMain->tStadHandles.hCtrlData);
    }

    if (pDrvMain->tStadHandles.hTxCtrl != NULL)
    {
        txCtrl_Unload (pDrvMain->tStadHandles.hTxCtrl);
    }

    if (pDrvMain->tStadHandles.hTxDataQ != NULL)
    {
        txDataQ_Destroy (pDrvMain->tStadHandles.hTxDataQ);
    }

    if (pDrvMain->tStadHandles.hTxMgmtQ != NULL)
    {
        txMgmtQ_Destroy (pDrvMain->tStadHandles.hTxMgmtQ);
    }

    if (pDrvMain->tStadHandles.hTxPort != NULL)
    {
        txPort_unLoad (pDrvMain->tStadHandles.hTxPort);
    }

    if (pDrvMain->tStadHandles.hRxData != NULL)
    {
        rxData_unLoad (pDrvMain->tStadHandles.hRxData);
    }

    if (pDrvMain->tStadHandles.hAssoc != NULL)
    {
        assoc_unload (pDrvMain->tStadHandles.hAssoc);
    }

    if (pDrvMain->tStadHandles.hAuth != NULL)
    {
        auth_unload (pDrvMain->tStadHandles.hAuth);
    }

    if (pDrvMain->tStadHandles.hMlmeSm != NULL)
    {
        mlme_unload (pDrvMain->tStadHandles.hMlmeSm);
    }

    if (pDrvMain->tStadHandles.hSCR != NULL)
    {
        scr_release (pDrvMain->tStadHandles.hSCR);
    }


    if (pDrvMain->tStadHandles.hRsn != NULL)
    {
        rsn_unload (pDrvMain->tStadHandles.hRsn);
    }

    if (pDrvMain->tStadHandles.hRegulatoryDomain != NULL)
    {
        regulatoryDomain_destroy (pDrvMain->tStadHandles.hRegulatoryDomain);
    }

    if (pDrvMain->tStadHandles.hMeasurementMgr != NULL)
    {
        measurementMgr_destroy (pDrvMain->tStadHandles.hMeasurementMgr);
    }

    if (pDrvMain->tStadHandles.hSoftGemini != NULL)
    {
        SoftGemini_destroy (pDrvMain->tStadHandles.hSoftGemini);
    }

#ifdef XCC_MODULE_INCLUDED
    if (pDrvMain->tStadHandles.hXCCMngr != NULL)
    {
        XCCMngr_unload (pDrvMain->tStadHandles.hXCCMngr);
    }
#endif

    if (pDrvMain->tStadHandles.hRoamingMngr != NULL)
    {
        roamingMngr_unload (pDrvMain->tStadHandles.hRoamingMngr);
    }

    if (pDrvMain->tStadHandles.hQosMngr != NULL)
    {
        qosMngr_destroy (pDrvMain->tStadHandles.hQosMngr);
    }

    if (pDrvMain->tStadHandles.hPowerMgr != NULL)
    {
        PowerMgr_destroy (pDrvMain->tStadHandles.hPowerMgr);
    }

    if (pDrvMain->tStadHandles.hAPConnection != NULL)
    {
        apConn_unload (pDrvMain->tStadHandles.hAPConnection);
    }

    if (pDrvMain->tStadHandles.hCurrBss != NULL)
    {
        currBSS_unload (pDrvMain->tStadHandles.hCurrBss);
    }

    if (pDrvMain->tStadHandles.hSwitchChannel != NULL)
    {
        switchChannel_unload (pDrvMain->tStadHandles.hSwitchChannel);
    }

    if (pDrvMain->tStadHandles.hHealthMonitor != NULL)
    {
        healthMonitor_unload (pDrvMain->tStadHandles.hHealthMonitor);
    }

    if (pDrvMain->tStadHandles.hCmdHndlr && pDrvMain->tStadHandles.hEvHandler)
    {
        cmdHndlr_Destroy (pDrvMain->tStadHandles.hCmdHndlr, pDrvMain->tStadHandles.hEvHandler);
    }

    if (pDrvMain->tStadHandles.hEvHandler != NULL)
    {
         EvHandlerUnload (pDrvMain->tStadHandles.hEvHandler);
    }

    if (pDrvMain->tStadHandles.hCmdDispatch) 
    {
        cmdDispatch_Destroy (pDrvMain->tStadHandles.hCmdDispatch);
    }

    if (pDrvMain->tStadHandles.hTxnQ != NULL)
    {
        txnQ_Destroy (pDrvMain->tStadHandles.hTxnQ);
    }
    /* Note: The Timer module must be destroyed last, so all created timers are already destroyed!! */
    if (pDrvMain->tStadHandles.hTimer != NULL)
    {
        tmr_Destroy (pDrvMain->tStadHandles.hTimer);
    }

    /* Note: Moved after timers for locks */
    if (pDrvMain->tStadHandles.hContext != NULL)
    {
        context_Destroy (pDrvMain->tStadHandles.hContext);
    }

    if (pDrvMain->tStadHandles.hStaCap != NULL)
    {
        StaCap_Destroy (pDrvMain->tStadHandles.hStaCap);
    }

    if (pDrvMain->tStadHandles.hReport != NULL)
    {
        report_Unload (pDrvMain->tStadHandles.hReport);
    }

    /* Destroy the DrvMain object */
    os_memoryFree (pDrvMain->tStadHandles.hOs, hDrvMain, sizeof(TDrvMain));

    return TI_OK;
}

void drvMain_SmeStop (TI_HANDLE hDrvMain)
{
    drvMain_SmEvent (hDrvMain, SM_EVENT_DISCONNECTED);
}


/* 
 * \fn     drvMain_Init
 * \brief  Init driver modules
 * 
 * Called from OS context following the driver creation.
 * Calls all STAD and TWD modules Init functions, which are saving other modules handles,
 *     registering to other modules and initializing their variables.
 * 
 * \note   
 * \param  hDrvMain - The DrvMain object
 * \return void 
 * \sa     drvMain_Create
 */ 
static void drvMain_Init (TI_HANDLE hDrvMain)
{
    TDrvMain    *pDrvMain = (TDrvMain *) hDrvMain;
    TStadHandlesList *pModules = &pDrvMain->tStadHandles; /* The STAD modules handles list */

    /* 
     *  Init all modules handles, variables and registries 
     */
    context_Init (pModules->hContext, pModules->hOs, pModules->hReport);
    tmr_Init (pModules->hTimer, pModules->hOs, pModules->hReport, pModules->hContext);
    txnQ_Init (pModules->hTxnQ, pModules->hOs, pModules->hReport, pModules->hContext);
    scr_init (pModules);
    conn_init (pModules);
    ctrlData_init (pModules,
                 #ifdef XCC_MODULE_INCLUDED
                   XCCMngr_LinkTestRetriesUpdate, pModules->hXCCMngr);
                 #else
                   NULL, NULL);
                 #endif                 
    siteMgr_init (pModules);
    regulatoryDomain_init (pModules);
    scanCncn_Init (pModules);
    auth_init (pModules);
    mlme_init (pModules);    
    assoc_init (pModules);
    rxData_init (pModules);
    txCtrl_Init (pModules);
    txDataQ_Init (pModules);
    txMgmtQ_Init (pModules);
    txPort_init (pModules);
    TrafficMonitor_Init (pModules, 1000 /* pInitTable->trafficMonitorMinIntervalPercentage */);
    sme_Init (pModules);
    rsn_init (pModules);
    measurementMgr_init (pModules);
#ifdef XCC_MODULE_INCLUDED
    XCCMngr_init (pModules);
#endif
    scanMngr_init (pModules);
    currBSS_init (pModules); 
    apConn_init (pModules);
    roamingMngr_init (pModules);
    qosMngr_init (pModules);
    switchChannel_init (pModules);
    healthMonitor_init (pModules);
    PowerMgr_init (pModules);
    SoftGemini_init (pModules);                                                                                
    cmdDispatch_Init (pModules);                                                                                
    StaCap_Init (pModules);                                                                 
    cmdHndlr_Init (pModules);

    /* Init TWD component (handles, variables and registries) and provide callbacks for next steps */
    TWD_Init (pModules->hTWD,
              pModules->hReport,
              pModules->hDrvMain,
              pModules->hTimer,
              pModules->hContext,
              pModules->hTxnQ,
              (TTwdCallback)drvMain_InitHwCb,
              (TTwdCallback)drvMain_InitFwCb,
              (TTwdCallback)drvMain_ConfigFwCb,
              (TTwdCallback)drvMain_TwdStopCb,
              (TTwdCallback)drvMain_InitFailCb);

    /* Init DrvMain module local variables */
    drvMain_InitLocals (pDrvMain);
}


/* 
 * \fn     drvMain_SetDefaults
 * \brief  Set driver default configuration
 * 
 * Configure all STAD and TWD modules with their default settings from the ini-file.
 * Timers creation is also done at this stage.
 * 
 * \note   
 * \param  hDrvMain - The DrvMain object
 * \param  pBuf     - The ini-file data.
 * \param  uLength  - The ini-file length.
 * \return TI_OK if succeeded, TI_NOK if failed. 
 * \sa     drvMain_Init
 */ 
static TI_STATUS drvMain_SetDefaults (TI_HANDLE hDrvMain, TI_UINT8 *pBuf, TI_UINT32 uLength)
{
    TDrvMain   *pDrvMain = (TDrvMain *) hDrvMain;
    TInitTable *pInitTable;
    TI_STATUS   eStatus;

    pInitTable = os_memoryAlloc (pDrvMain->tStadHandles.hOs, sizeof(TInitTable));

    /* Parse defaults */
    eStatus = osInitTable_IniFile (pDrvMain->tStadHandles.hOs, pInitTable, (char*)pBuf, (int)uLength);

    /*
     *  Configure modules with their default settings
     */
    report_SetDefaults (pDrvMain->tStadHandles.hReport, &pInitTable->tReport);
    context_SetDefaults (pDrvMain->tStadHandles.hContext, &pInitTable->tContextInitParams);
    TWD_SetDefaults (pDrvMain->tStadHandles.hTWD, &pInitTable->twdInitParams);
    conn_SetDefaults (pDrvMain->tStadHandles.hConn, &pInitTable->connInitParams);
    ctrlData_SetDefaults (pDrvMain->tStadHandles.hCtrlData, &pInitTable->ctrlDataInitParams);
    regulatoryDomain_SetDefaults (pDrvMain->tStadHandles.hRegulatoryDomain, &pInitTable->regulatoryDomainInitParams);
    scanCncn_SetDefaults (pDrvMain->tStadHandles.hScanCncn, &pInitTable->tScanCncnInitParams);
    auth_SetDefaults (pDrvMain->tStadHandles.hAuth, &pInitTable->authInitParams);
    assoc_SetDefaults (pDrvMain->tStadHandles.hAssoc, &pInitTable->assocInitParams);
    rxData_SetDefaults (pDrvMain->tStadHandles.hRxData, &pInitTable->rxDataInitParams);
    sme_SetDefaults (pDrvMain->tStadHandles.hSme, &pInitTable->tSmeModifiedInitParams, &pInitTable->tSmeInitParams);
    rsn_SetDefaults (pDrvMain->tStadHandles.hRsn, &pInitTable->rsnInitParams);
    measurementMgr_SetDefaults (pDrvMain->tStadHandles.hMeasurementMgr, &pInitTable->measurementInitParams);
#ifdef XCC_MODULE_INCLUDED
    XCCMngr_SetDefaults (pDrvMain->tStadHandles.hXCCMngr, &pInitTable->XCCMngrParams);
#endif /*XCC_MODULE_INCLUDED*/
    apConn_SetDefaults (pDrvMain->tStadHandles.hAPConnection, &pInitTable->apConnParams);
    qosMngr_SetDefaults (pDrvMain->tStadHandles.hQosMngr, &pInitTable->qosMngrInitParams);
    switchChannel_SetDefaults (pDrvMain->tStadHandles.hSwitchChannel, &pInitTable->SwitchChannelInitParams);
    healthMonitor_SetDefaults (pDrvMain->tStadHandles.hHealthMonitor, &pInitTable->healthMonitorInitParams);
    PowerMgr_SetDefaults (pDrvMain->tStadHandles.hPowerMgr, &pInitTable->PowerMgrInitParams);
    SoftGemini_SetDefaults (pDrvMain->tStadHandles.hSoftGemini, &pInitTable->SoftGeminiInitParams);
    txDataQ_SetDefaults (pDrvMain->tStadHandles.hTxDataQ, &pInitTable->txDataInitParams);
    txCtrl_SetDefaults (pDrvMain->tStadHandles.hTxCtrl, &pInitTable->txDataInitParams);
    currBSS_SetDefaults (pDrvMain->tStadHandles.hCurrBss, &pInitTable->tCurrBssInitParams);
    mlme_SetDefaults (pDrvMain->tStadHandles.hMlmeSm, &pInitTable->tMlmeInitParams);

    scanMngr_SetDefaults(pDrvMain->tStadHandles.hScanMngr, &pInitTable->tRoamScanMngrInitParams);
    roamingMngr_setDefaults(pDrvMain->tStadHandles.hRoamingMngr, &pInitTable->tRoamScanMngrInitParams);

    /* Note: The siteMgr_SetDefaults includes many settings that relate to other modules so keep it last!! */ 
    siteMgr_SetDefaults (pDrvMain->tStadHandles.hSiteMgr, &pInitTable->siteMgrInitParams);

    /* Set DrvMain local defaults */
    pDrvMain->tBusDrvCfg.tSdioCfg.uBlkSizeShift         = pInitTable->tDrvMainParams.uSdioBlkSizeShift;
    pDrvMain->tBusDrvCfg.tSdioCfg.uBusDrvThreadPriority = pInitTable->tDrvMainParams.uBusDrvThreadPriority;
    os_SetDrvThreadPriority (pDrvMain->tStadHandles.hOs, pInitTable->tDrvMainParams.uWlanDrvThreadPriority);

    /* Release the init table memory */
    os_memoryFree (pDrvMain->tStadHandles.hOs, pInitTable, sizeof(TInitTable));

    return eStatus;
}
 

/* 
 * \fn     drvMain_xxx...Cb
 * \brief  Callback functions for the init/stop stages completion
 *
 * The following callback functions are called from other modules (most from TWD)
 *     when the current init/stop step is completed.
 * Note that the callbacks are called anyway, either in the original context (if completed), or
 *     in another context if pending. 
 * The first case (same context) may lead to a recursion of the SM, so a special handling is added
 *     to the SM to prevent recursion (see drvMain_Sm).
 * 
 * drvMain_InitHwCb   - HW init completion callback
 * drvMain_InitFwCb   - FW init (mainly download) completion callback
 * drvMain_ConfigFwCb - FW configuration completion callback
 * drvMain_TwdStopCb  - TWD stopping completion callback
 * drvMain_InitFailCb - FW init faulty completion callback
 * drvMain_SmeStopCb  - SME stopping completion callback
 * drvMain_GetFileCb  - Getting-file completion callback
 * 
 * \note   
 * \param  hDrvMain - The DrvMain object
 * \param  eStatus  - The process result (TI_OK if succeeded, TI_NOK if failed)
 * \return void 
 * \sa     drvMain_Create
 */ 
static void drvMain_InitHwCb (TI_HANDLE hDrvMain, TI_STATUS eStatus)
{
    HANDLE_CALLBACKS_FAILURE_STATUS(hDrvMain, eStatus);
    drvMain_SmEvent (hDrvMain, SM_EVENT_HW_INIT_COMPLETE);
}

static void drvMain_InitFwCb (TI_HANDLE hDrvMain, TI_STATUS eStatus)
{
    HANDLE_CALLBACKS_FAILURE_STATUS(hDrvMain, eStatus);
    drvMain_SmEvent (hDrvMain, SM_EVENT_FW_INIT_COMPLETE);
}

static void drvMain_ConfigFwCb (TI_HANDLE hDrvMain, TI_STATUS eStatus)
{
    HANDLE_CALLBACKS_FAILURE_STATUS(hDrvMain, eStatus);
    drvMain_SmEvent (hDrvMain, SM_EVENT_FW_CONFIG_COMPLETE);
}

static void drvMain_TwdStopCb (TI_HANDLE hDrvMain, TI_STATUS eStatus)
{
    HANDLE_CALLBACKS_FAILURE_STATUS(hDrvMain, eStatus);
    drvMain_SmEvent (hDrvMain, SM_EVENT_STOP_COMPLETE);
}

static void drvMain_InitFailCb (TI_HANDLE hDrvMain, TI_STATUS eStatus)
{
    drvMain_SmEvent (hDrvMain, SM_EVENT_FAILURE);
    /* 
     * Note that this call will pass the SM to the FAILED state, since this event 
     *     is not handled by any state.
     */
}

static void drvMain_InvokeAction (TI_HANDLE hDrvMain)
{
    TDrvMain *pDrvMain = (TDrvMain *)hDrvMain;

    switch (pDrvMain->eAction)
    {
    case ACTION_TYPE_START:
        drvMain_SmEvent (hDrvMain, SM_EVENT_START);
        break;
    case ACTION_TYPE_STOP:
        drvMain_SmEvent (hDrvMain, SM_EVENT_STOP);
        break;
        default:    
            TRACE1(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR , "drvMain_InvokeAction(): Action=%d\n", pDrvMain->eAction);
    }
}

static void drvMain_GetFileCb (TI_HANDLE hDrvMain)
{
    TDrvMain *pDrvMain = (TDrvMain *)hDrvMain;
    ESmEvent  eSmEvent;

    switch (pDrvMain->tFileInfo.eFileType)
    {
        case FILE_TYPE_INI:     eSmEvent = SM_EVENT_INI_FILE_READY;    break;
        case FILE_TYPE_NVS:     eSmEvent = SM_EVENT_NVS_FILE_READY;    break;
        case FILE_TYPE_FW:      eSmEvent = SM_EVENT_FW_FILE_READY;     break;
        case FILE_TYPE_FW_NEXT: eSmEvent = SM_EVENT_FW_FILE_READY;     break;
        default:    
            TRACE1(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR , "drvMain_GetFileCb(): Unknown eFileType=%d\n", pDrvMain->tFileInfo.eFileType);
            return;
    }
    drvMain_SmEvent (hDrvMain, eSmEvent);
}


/*
 * \fn     drvMain_InitLocals
 * \brief  Init DrvMain module
 * 
 * Init the DrvMain variables, register to other modules and set device power to off.
 * 
 * \note   
 * \param  pDrvMain - The DrvMain object
 * \return void 
 * \sa     drvMain_Init
 */ 
static void drvMain_InitLocals (TDrvMain *pDrvMain)
{
    /* Initialize the module's local varniables to default values */
    pDrvMain->tFileInfo.eFileType   = FILE_TYPE_INI;
    pDrvMain->tFileInfo.fCbFunc     = drvMain_GetFileCb;
    pDrvMain->tFileInfo.hCbHndl     = (TI_HANDLE)pDrvMain;
    pDrvMain->eSmState              = SM_STATE_IDLE;
    pDrvMain->uPendingEventsCount   = 0;
	pDrvMain->bRecovery             = TI_FALSE; 
	pDrvMain->uNumOfRecoveryAttempts = 0;
	pDrvMain->eAction               = ACTION_TYPE_NONE; 

    /* Register the Action callback to the context engine and get the client ID */
    pDrvMain->uContextId = context_RegisterClient (pDrvMain->tStadHandles.hContext,
                                                   drvMain_InvokeAction,
                                                   (TI_HANDLE)pDrvMain,
                                                   TI_TRUE,
                                                   "ACTION",
                                                   sizeof("ACTION"));

    /* Platform specific HW preparations */
	hPlatform_Wlan_Hardware_Init(pDrvMain->tStadHandles.hOs);

    /* Insure that device power is off (expected to be) */
    hPlatform_DevicePowerOff ();
}


/* 
 * \fn     drvMain_InitHw & drvMain_InitFw
 * \brief  Init HW and Init FW sequences
 * 
 * drvMain_InitHw - HW init sequence which writes and reads some HW registers
 *                      that are needed prior to FW download.
 * drvMain_InitFw - FW init sequence which downloads the FW image and waits for 
 *                      FW init-complete indication.
 * 
 * \note   
 * \param  hDrvMain - The DrvMain object
 * \param  pBuf     - The file data (NVS for HW-init, FW-Image for FW-init).
 * \param  uLength  - The file length.
 * \return TI_OK if succeeded, TI_NOK if failed. 
 * \sa     
 */ 
static TI_STATUS drvMain_InitHw (TI_HANDLE hDrvMain, TI_UINT8 *pbuf, TI_UINT32 uLength)
{
    TDrvMain   *pDrvMain = (TDrvMain *) hDrvMain;

    return TWD_InitHw (pDrvMain->tStadHandles.hTWD, pbuf, uLength, pDrvMain->uRxDmaBufLen, pDrvMain->uTxDmaBufLen);
}

static TI_STATUS drvMain_InitFw (TI_HANDLE hDrvMain, TFileInfo *pFileInfo)
{
    TDrvMain   *pDrvMain = (TDrvMain *) hDrvMain;

    return TWD_InitFw (pDrvMain->tStadHandles.hTWD, pFileInfo);
}


/* 
 * \fn     drvMain_ConfigFw
 * \brief  Configure the FW
 * 
 * The step that follows the FW Init (mainly FW download).
 * The Command-Mailbox interface is enabled here and the FW is configured.
 * 
 * \note   
 * \param  pDrvMain - The DrvMain object
 * \return TI_OK 
 * \sa     drvMain_Init
 */ 
static TI_STATUS drvMain_ConfigFw (TI_HANDLE hDrvMain)
{
    TDrvMain    *pDrvMain = (TDrvMain *) hDrvMain;

    /* get pointer to FW static info (already in driver memory) */
    TFwInfo     *pFwInfo  = TWD_GetFWInfo (pDrvMain->tStadHandles.hTWD); 
    TI_UINT8    *pMacAddr = (TI_UINT8 *)pFwInfo->macAddress; /* STA MAC address */

    /* Update driver's MAC address */
    wlanDrvIf_SetMacAddress (pDrvMain->tStadHandles.hOs, pMacAddr);

    /*
     *  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 (pDrvMain->tStadHandles.hTWD);

    /* Configure the FW from the TWD DB */
    TWD_ConfigFw (pDrvMain->tStadHandles.hTWD);

    TRACE0(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_INIT , "EXIT FROM INIT\n");

    /* Print the driver and firmware version and the mac address */
    os_printf("\n");
    os_printf("-----------------------------------------------------\n");
    os_printf("Driver Version  : %s\n", SW_VERSION_STR);
    os_printf("Firmware Version: %s\n", pFwInfo->fwVer);
    os_printf("Station ID      : %02X-%02X-%02X-%02X-%02X-%02X\n",
              pMacAddr[0], pMacAddr[1], pMacAddr[2], pMacAddr[3], pMacAddr[4], pMacAddr[5]);
    os_printf("-----------------------------------------------------\n");
    os_printf("\n");

    return TI_OK;
}


/* 
 * \fn     drvMain_StopActivities
 * \brief  Freeze driver activities
 * 
 * Freeze all driver activities due to stop command or recovery process.
 * 
 * \note   
 * \param  pDrvMain - The DrvMain object
 * \return TI_OK if succeeded, TI_NOK if failed. 
 * \sa     drvMain_EnableActivities
 */ 
static TI_STATUS drvMain_StopActivities (TDrvMain *pDrvMain)
{
    txPort_suspendTx (pDrvMain->tStadHandles.hTxPort);

    /* Disable External Inputs (IRQs and commands) */
    TWD_DisableInterrupts(pDrvMain->tStadHandles.hTWD);
    cmdHndlr_Disable (pDrvMain->tStadHandles.hCmdHndlr);

    /* Initiate TWD Restart */
    return TWD_Stop (pDrvMain->tStadHandles.hTWD);
}


/* 
 * \fn     drvMain_EnableActivities
 * \brief  Enable driver activities
 * 
 * Enable driver activities after init or recovery process completion.
 * 
 * \note   
 * \param  pDrvMain - The DrvMain object
 * \return void 
 * \sa     drvMain_StopActivities
 */ 
static void drvMain_EnableActivities (TDrvMain *pDrvMain)
{
    txPort_resumeTx (pDrvMain->tStadHandles.hTxPort);

   /* Enable External Inputs (IRQ is enabled elsewhere) */
    cmdHndlr_Enable (pDrvMain->tStadHandles.hCmdHndlr);

    /* Enable external events from FW */
    TWD_EnableExternalEvents (pDrvMain->tStadHandles.hTWD);

    
}


/* 
 * \fn     drvMain_ClearQueuedEvents
 * \brief  Enable driver activities
 * 
 * Clear all external events queues (Tx, commands and timers) upon driver stop.
 * 
 * \note   
 * \param  pDrvMain - The DrvMain object
 * \return void 
 * \sa     
 */ 
static void drvMain_ClearQueuedEvents (TDrvMain *pDrvMain)
{
    txDataQ_ClearQueues (pDrvMain->tStadHandles.hTxDataQ);
    txMgmtQ_ClearQueues (pDrvMain->tStadHandles.hTxMgmtQ);
    cmdHndlr_ClearQueue (pDrvMain->tStadHandles.hCmdHndlr);
    tmr_ClearOperQueue (pDrvMain->tStadHandles.hTimer);
}


/* 
 * \fn     drvMain_InsertAction
 * \brief  Get start/stop action and trigger handling
 * 
 * Get start or stop action command from OAL, save it and trigger driver task
 *     for handling it.
 * Wait on a signal object until the requested process is completed.
 * 
 * \note   
 * \param  hDrvMain - The DrvMain object
 * \param  eAction  - The requested action
 * \return void 
 * \sa     
 */ 
TI_STATUS drvMain_InsertAction (TI_HANDLE hDrvMain, EActionType eAction)
{
    TDrvMain *pDrvMain = (TDrvMain *) hDrvMain;

    context_EnterCriticalSection(pDrvMain->tStadHandles.hContext);
    if (pDrvMain->eAction == eAction)
    {
        context_LeaveCriticalSection(pDrvMain->tStadHandles.hContext);
        TRACE0(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_CONSOLE, "Action is identical to last action!\n");
        WLAN_OS_REPORT(("Action %d is identical to last action!\n", eAction));
        return TI_OK;
    }

    /* Save the requested action */
    pDrvMain->eAction = eAction;
    context_LeaveCriticalSection(pDrvMain->tStadHandles.hContext);

    /* Create signal object */
    /* 
     * Notice that we must create the signal object before asking for ReSchedule,
     * because we might receive it immidiatly, and then we will be in a different context 
     * with null signal object.
     */
    pDrvMain->hSignalObj = os_SignalObjectCreate (pDrvMain->tStadHandles.hOs);
    if (pDrvMain->hSignalObj == NULL) 
    {
        TRACE0(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR , "drvMain_InsertAction(): Couldn't allocate signal object!\n");
        return TI_NOK;
    }

    /* Request driver task schedule for action handling */
    context_RequestSchedule (pDrvMain->tStadHandles.hContext, pDrvMain->uContextId);

    /* Wait for the action processing completion */
    os_SignalObjectWait (pDrvMain->tStadHandles.hOs, pDrvMain->hSignalObj);

    /* After "wait" - the action has already been processed in the driver's context */

    /* Free signalling object */
    os_SignalObjectFree (pDrvMain->tStadHandles.hOs, pDrvMain->hSignalObj);
    pDrvMain->hSignalObj = NULL;

    if (pDrvMain->eSmState == SM_STATE_FAILED)
    return TI_NOK;

    return TI_OK;
}


/* 
 * \fn     drvMain_Recovery
 * \brief  Initiate recovery process
 * 
 * Initiate recovery process upon HW/FW error detection (in the Health-Monitor).
 * 
 * \note   
 * \param  hDrvMain - The DrvMain object
 * \return TI_OK if started recovery, TI_NOK if recovery is already in progress. 
 * \sa     
 */ 
TI_STATUS drvMain_Recovery (TI_HANDLE hDrvMain)
{
    TDrvMain         *pDrvMain = (TDrvMain *) hDrvMain;

	pDrvMain->uNumOfRecoveryAttempts++;
    if (!pDrvMain->bRecovery)
    {
        TRACE1(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_CONSOLE,".....drvMain_Recovery, ts=%d\n", os_timeStampMs(pDrvMain->tStadHandles.hOs));
#ifdef REPORT_LOG
        WLAN_OS_REPORT((".....drvMain_Recovery, ts=%d\n", os_timeStampMs(pDrvMain->tStadHandles.hOs)));
#else
        printk("%s\n",__func__);
#endif
        pDrvMain->bRecovery = TI_TRUE;
        drvMain_SmEvent (hDrvMain, SM_EVENT_RECOVERY);
        return TI_OK;
    }
    else
    {
        TRACE0(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR, "drvMain_Recovery: ****  Recovery already in progress!  ****\n");

		/* nesting recoveries... Try again */
		drvMain_SmEvent (hDrvMain, SM_EVENT_RECOVERY);
        return TI_NOK;
    }
}


/* 
 * \fn     drvMain_RecoveryNotify
 * \brief  Notify STAD modules about recovery
 * 
 * Notify the relevant STAD modules that recovery took place (after completed).
 * 
 * \note   
 * \param  pDrvMain - The DrvMain object
 * \return void 
 * \sa     
 */ 
static void drvMain_RecoveryNotify (TDrvMain *pDrvMain)
{
    txCtrl_NotifyFwReset (pDrvMain->tStadHandles.hTxCtrl);
    scr_notifyFWReset (pDrvMain->tStadHandles.hSCR);
    PowerMgr_notifyFWReset (pDrvMain->tStadHandles.hPowerMgr);

    TRACE1(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_CONSOLE, ".....drvMain_RecoveryNotify: End Of Recovery, ts=%d\n", os_timeStampMs(pDrvMain->tStadHandles.hOs));
    WLAN_OS_REPORT((".....drvMain_RecoveryNotify: End Of Recovery, ts=%d\n", os_timeStampMs(pDrvMain->tStadHandles.hOs)));
}


/* 
 * \fn     drvMain_SmWatchdogTimeout
 * \brief  SM watchdog timer expiry handler
 * 
 * This is the callback function called upon expiartion of the watchdog timer.
 * It is called by the OS-API in timer expiry context, and it issues a failure event to the SM.
 * Note that we can't switch to the driver task as for other timers, since we are using
 *     this timer to protect the init processes, and anyway we just need to stop the driver.
 * 
 * \note   
 * \param  hDrvMain - The DrvMain object
 * \return void
 * \sa     
 */ 

#if 0
static void drvMain_SmWatchdogTimeout (TI_HANDLE hDrvMain)
{
    TDrvMain *pDrvMain = (TDrvMain *)hDrvMain;

    TRACE1(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR , "drvMain_SmWatchdogTimeout():  State = %d\n", pDrvMain->eSmState);

    /* Send failure event directly to the SM (so the drvMain_SmEvent won't block it).  */

    drvMain_Sm ((TI_HANDLE)pDrvMain, SM_EVENT_FAILURE);
}
#endif

/* 
 * \fn     drvMain_SmEvent
 * \brief  Issue DrvMain SM event
 * 
 * Each event that is handled by the DrvMain state machine, is introduced through this function.
 * To prevent SM recursion, the SM is invoeked only if it's not already handling the 
 *      previous event. 
 * If the SM is busy, the current event is saved until the previous handling is completed.
 * 
 * \note   Recursion may happen because some SM activities generate SM events in the same context.
 * \param  hDrvMain - The DrvMain object
 * \param  eEvent   - The event issued to the SM
 * \return void 
 * \sa     
 */ 
static void drvMain_SmEvent (TI_HANDLE hDrvMain, ESmEvent eEvent)
{
    TDrvMain *pDrvMain = (TDrvMain *)hDrvMain;

    /* Increment pending events counter and save last event. */
    pDrvMain->uPendingEventsCount++;
    pDrvMain->ePendingEvent = eEvent;

    /* If the SM is busy, save event and exit (will be handled when current event is finished) */
    if (pDrvMain->uPendingEventsCount > 1)
    {
        /* Only one pending event is expected (in addition to the handled one, so two together). */
        if (pDrvMain->uPendingEventsCount > 2)
        {
            TRACE3(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR , "drvMain_SmEvent():  Multiple pending events (%d), State = %d, Event = %d\n", pDrvMain->uPendingEventsCount, pDrvMain->eSmState, eEvent);
        }

        /* Exit. The current event will be handled by the following while loop of the first instance. */
        return;
    }

    /* Invoke the SM with the current event and further events issued by the last SM invocation. */
    while (pDrvMain->uPendingEventsCount > 0)
    {
        drvMain_Sm (hDrvMain, pDrvMain->ePendingEvent);

        /* 
         * Note: The SM may issue another event by calling this function and incrementing 
         *           the counter. 
         *       In this case, only the upper part of this function is run, and the pending
         *           event is hanlded in the next while loo[.
         */

        pDrvMain->uPendingEventsCount--;
    }
}


/* 
 * \fn     drvMain_Sm
 * \brief  The DrvMain state machine
 * 
 * The DrvMain state machine, which handles all driver init, recovery and stop processes.
 * 
 * \note   Since the SM may be called back from its own context, recursion is prevented 
 *             by postponing the last event.
 * \param  hDrvMain - The DrvMain object
 * \param  eEvent   - The event that triggers the SM
 * \return void 
 * \sa     
 */ 
static void drvMain_Sm (TI_HANDLE hDrvMain, ESmEvent eEvent)
{
    TDrvMain    *pDrvMain   = (TDrvMain *)hDrvMain;
    TI_STATUS    eStatus    = TI_NOK;
    TI_HANDLE    hOs        = pDrvMain->tStadHandles.hOs;
    TI_UINT32    uSdioConIndex = 0;

    TRACE2(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_INFORMATION , "drvMain_Sm():  State = %d, Event = %d\n", pDrvMain->eSmState, eEvent);
    
    /* 
     *  General explenations:
     *  =====================
     *  1) This SM calls some functions that may complete their processing in another context.
     *     All of these functions (wlanDrvIf_GetFile, drvMain_InitHw, drvMain_InitFw, drvMain_ConfigFw,
     *         drvMain_StopActivities, smeSm_start, smeSm_stop) are provided with a callback which 
     *         they always call upon completion, even if they are completed in the original (SM) context.
     *     Since these callbacks are calling the SM, a simple mechanism is added to prevent
     *         recursion, by postponing the last event if the SM is still in the previous event's context.
     *  2) In any case of unexpected event, the eStatus remains TI_NOK, leading to the FAILED state!
     *     FAILED state is also reached if any of the functions listed in note 1 returns TI_NOK.
     *     Note that if these functions detect a failure in another context, they may call their callback
     *         with the eStatus parameter set to TI_NOK, or call the drvMain_InitFailCb callback.
     *     All these cases lead to FAILED state which terminates all driver activities and wait for destroy.
     *  3) Note that the wlanDrvIf_GetFile is always completed in the original context, and the
     *         option of completion in a later context is only for future use.
     *  4) All processes (Start, Stop, Relcovery) are protected by a watchdog timer to let
     *         the user free the driver in case of deadlock during the process.
     */

    switch (pDrvMain->eSmState) 
    {
    case SM_STATE_IDLE:
        /*
         * We get a START action after all modules are created and linked.
         * Disable further actions, start watchdog timer and request for the ini-file.
         */
        if (eEvent == SM_EVENT_START) 
        {
            pDrvMain->eSmState = SM_STATE_WAIT_INI_FILE;
            context_DisableClient (pDrvMain->tStadHandles.hContext, pDrvMain->uContextId);
            pDrvMain->tFileInfo.eFileType = FILE_TYPE_INI;
            eStatus = wlanDrvIf_GetFile (hOs, &pDrvMain->tFileInfo);
        }
        break;
    case SM_STATE_WAIT_INI_FILE:
        /* 
         * We've got the ini-file.
         * Set STAD and TWD modules defaults according to the ini-file, 
         *     turn on the device and request for the NVS file.
         */
        if (eEvent == SM_EVENT_INI_FILE_READY) 
        {
            pDrvMain->eSmState = SM_STATE_WAIT_NVS_FILE;
            drvMain_SetDefaults (hDrvMain, pDrvMain->tFileInfo.pBuffer, pDrvMain->tFileInfo.uLength);
            hPlatform_DevicePowerOn ();

            pDrvMain->tFileInfo.eFileType = FILE_TYPE_NVS;
            eStatus = wlanDrvIf_GetFile (hOs, &pDrvMain->tFileInfo);
        }
        break;

    case SM_STATE_WAIT_NVS_FILE:

        /* SDBus Connect connection validation  */
        for(uSdioConIndex=0; (uSdioConIndex < SDIO_CONNECT_THRESHOLD) && (eStatus != TI_OK); uSdioConIndex++)
        {
			/* : We should split the call to txnQ_ConnectBus to other state in order to support Async bus connection */
            eStatus = txnQ_ConnectBus(pDrvMain->tStadHandles.hTxnQ, &pDrvMain->tBusDrvCfg, NULL, NULL, &pDrvMain->uRxDmaBufLen, &pDrvMain->uTxDmaBufLen); 

			if((eStatus != TI_OK) &&
			   (uSdioConIndex < (SDIO_CONNECT_THRESHOLD - 1)))
            {
                     TRACE0(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_WARNING , "SDBus Connect Failed\n");
                     WLAN_OS_REPORT(("Try to SDBus Connect again...\n"));
                     if (uSdioConIndex > 1)
						hPlatform_DevicePowerOffSetLongerDelay();
					 else
						hPlatform_DevicePowerOff();
                     hPlatform_DevicePowerOn();
            }
        }

		if(eStatus != TI_OK)
		{
			WLAN_OS_REPORT(("SDBus Connect Failed, Set Object Event !!\r\n"));
			TRACE0(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR , "SDBus Connect Failed, Set Object Event !!\r\n");
			if (!pDrvMain->bRecovery)
			{
				os_SignalObjectSet(hOs, pDrvMain->hSignalObj);
			}
		}
		else /* SDBus Connect success */
        {
            /*
             * We've got the NVS file.
             * Start HW-Init process providing the NVS file.
             */
			if (eEvent == SM_EVENT_NVS_FILE_READY)
            {
                pDrvMain->eSmState = SM_STATE_HW_INIT;
                eStatus = drvMain_InitHw (hDrvMain, pDrvMain->tFileInfo.pBuffer, pDrvMain->tFileInfo.uLength);
            }
        }
        break;
    case SM_STATE_HW_INIT:
        /*
         * HW-Init process is completed.
         * Request for the FW image file.
         */
        if (eEvent == SM_EVENT_HW_INIT_COMPLETE)
        {
            pDrvMain->tFileInfo.eFileType = FILE_TYPE_FW;
            pDrvMain->eSmState = SM_STATE_DOWNLOAD_FW_FILE;
            eStatus = wlanDrvIf_GetFile (hOs, &pDrvMain->tFileInfo);
        }
        break;
    case SM_STATE_DOWNLOAD_FW_FILE:
        if (eEvent == SM_EVENT_FW_FILE_READY)
        {
            pDrvMain->tFileInfo.eFileType = FILE_TYPE_FW_NEXT;
            if (pDrvMain->tFileInfo.bLast == TI_TRUE)
            {
            pDrvMain->eSmState = SM_STATE_FW_INIT;
            }
            else
            {
                pDrvMain->eSmState = SM_STATE_WAIT_FW_FILE;
            }
            /*
             * We've got the FW image file.
             * Start FW-Init process (mainly FW image download) providing the FW image file.
             */
            eStatus = drvMain_InitFw (hDrvMain, &pDrvMain->tFileInfo);
        }
        break;
    case SM_STATE_WAIT_FW_FILE:
        if (eEvent == SM_EVENT_FW_INIT_COMPLETE)
        {
            pDrvMain->eSmState = SM_STATE_DOWNLOAD_FW_FILE;
            eStatus = wlanDrvIf_GetFile (hOs, &pDrvMain->tFileInfo);
        }
        break;
    case SM_STATE_FW_INIT:
        /*
         * FW-Init process is completed.
         * Free the semaphore of the START action to enable the OS interface.
         * Enable interrupts (or polling for debug).
         * Start FW-Configuration process, and free the semaphore of the START action.
         *
         * Note that in some OSs, the semaphore must be released in order to enable the
         *     interrupts, and the interrupts are needed for the configuration process!
         */
        if (eEvent == SM_EVENT_FW_INIT_COMPLETE)
        {
            pDrvMain->eSmState = SM_STATE_FW_CONFIG;
            TWD_EnableInterrupts(pDrvMain->tStadHandles.hTWD);
          #ifdef PRIODIC_INTERRUPT
            /* Start periodic interrupts. It means that every period of time the FwEvent SM will be called */
            os_periodicIntrTimerStart (hOs);
          #endif
            eStatus = drvMain_ConfigFw (hDrvMain);
        }
        break;
    case SM_STATE_FW_CONFIG:
        /*
         * FW-configuration process is completed.
         * Stop watchdog timer.
         * For recovery, notify the relevant STAD modules.
         * For regular start, start the SME which handles the connection process.
         * Update timer and OAL about entering OPERATIONAL state (OAL ignores recovery)
         * Enable driver activities and external events.
         * Enable STOP action
         * We are now in OPERATIONAL state, i.e. the driver is fully operational!
         */
      
        if (eEvent == SM_EVENT_FW_CONFIG_COMPLETE) 
        {
            pDrvMain->eSmState = SM_STATE_OPERATIONAL;
            if (pDrvMain->bRecovery) 
            {
				pDrvMain->uNumOfRecoveryAttempts = 0;
                drvMain_RecoveryNotify (pDrvMain);
                pDrvMain->bRecovery = TI_FALSE;
            }
            else 
            {
                sme_Start (pDrvMain->tStadHandles.hSme); 
                wlanDrvIf_UpdateDriverState (hOs, DRV_STATE_RUNNING);
            }
            tmr_UpdateDriverState (pDrvMain->tStadHandles.hTimer, TI_TRUE);
            drvMain_EnableActivities (pDrvMain);
            context_EnableClient (pDrvMain->tStadHandles.hContext, pDrvMain->uContextId);
            eStatus = TI_OK;
           
        }
        if (!pDrvMain->bRecovery)
        {
            os_SignalObjectSet(hOs, pDrvMain->hSignalObj);
        }
        break;
    case SM_STATE_OPERATIONAL:
        /* 
         * Disable start/stop commands and start watchdog timer.
         * Update timer and OAL about exiting OPERATIONAL state (OAL ignores recovery).
         * For STOP, stop SME (handle disconnection) and move to DISCONNECTING state.
         * For recovery, stop driver activities and move to STOPPING state.
         * Note that driver-stop process may be Async if we are during Async bus transaction.
         */
        
        context_DisableClient (pDrvMain->tStadHandles.hContext, pDrvMain->uContextId);
        tmr_UpdateDriverState (pDrvMain->tStadHandles.hTimer, TI_FALSE);
        if (eEvent == SM_EVENT_STOP) 
        {
            pDrvMain->eSmState = SM_STATE_DISCONNECTING;
            wlanDrvIf_UpdateDriverState (hOs, DRV_STATE_STOPING);
            sme_Stop (pDrvMain->tStadHandles.hSme);
            eStatus = TI_OK;
        }
        else if (eEvent == SM_EVENT_RECOVERY) 
        {
            pDrvMain->eSmState = SM_STATE_STOPPING;
            eStatus = drvMain_StopActivities (pDrvMain);
        }
        
        break;
    case SM_STATE_DISCONNECTING:
        /* 
         * Note that this state is not relevant for recovery.
         * SME stop is completed 
         * Stop driver activities and move to STOPPING state.
         * Note that driver stop process may be Async if we are during Async bus transaction.
         */
        
        if (eEvent == SM_EVENT_DISCONNECTED) 
        {
            pDrvMain->eSmState = SM_STATE_STOPPING;
            eStatus = drvMain_StopActivities (pDrvMain);
        }
        break;
    case SM_STATE_STOPPING:
        /* 
         * Driver stopping process is done.
         * Turn device power off.
         * For recovery, turn device power back on, request NVS file and continue with
         *     the init process (recover back all the way to OPERATIONAL state).
         * For STOP process, the driver is now fully stopped (STOPPED state), so stop watchdog timer,
         *     clear all events queues, free the semaphore of the STOP action and enable START action.
         */
        
        if (eEvent == SM_EVENT_STOP_COMPLETE) 
        {
            txnQ_DisconnectBus (pDrvMain->tStadHandles.hTxnQ);
            hPlatform_DevicePowerOff ();
            if (pDrvMain->bRecovery) 
            {
                hPlatform_DevicePowerOn ();
                pDrvMain->eSmState = SM_STATE_WAIT_NVS_FILE;
                pDrvMain->tFileInfo.eFileType = FILE_TYPE_NVS;
                eStatus = wlanDrvIf_GetFile (hOs, &pDrvMain->tFileInfo);
            }
            else 
            {
                pDrvMain->eSmState = SM_STATE_STOPPED;
                drvMain_ClearQueuedEvents (pDrvMain);
                scr_notifyFWReset(pDrvMain->tStadHandles.hSCR);
                os_SignalObjectSet (hOs, pDrvMain->hSignalObj);
                context_EnableClient (pDrvMain->tStadHandles.hContext, pDrvMain->uContextId);
                wlanDrvIf_UpdateDriverState (hOs, DRV_STATE_STOPPED);
                eStatus = TI_OK;
            }
        }
        
        break;
    case SM_STATE_STOPPED:
        /* 
         * A START action command was inserted, so we go through the init process.
         * Disable further actions, start watchdog timer, turn on device and request NVS file.
         */
        
        context_DisableClient (pDrvMain->tStadHandles.hContext, pDrvMain->uContextId);
        if (eEvent == SM_EVENT_START) 
        {
            hPlatform_DevicePowerOn ();
            pDrvMain->eSmState = SM_STATE_WAIT_NVS_FILE;
            pDrvMain->tFileInfo.eFileType = FILE_TYPE_NVS;
            eStatus = wlanDrvIf_GetFile (hOs, &pDrvMain->tFileInfo);
        }
        break;
    case SM_STATE_STOPPING_ON_FAIL:
        /*
         * Driver stopping process upon failure is completed.
         * Turn off the device and move to FAILED state.
         */
        
        pDrvMain->eSmState = SM_STATE_FAILED;
        txnQ_DisconnectBus (pDrvMain->tStadHandles.hTxnQ);
        hPlatform_DevicePowerOff ();
        WLAN_OS_REPORT(("[WLAN] Exit application\n"));
        if (!pDrvMain->bRecovery) 
        {
            os_SignalObjectSet (hOs, pDrvMain->hSignalObj);
		}
		else if (pDrvMain->uNumOfRecoveryAttempts < MAX_NUM_OF_RECOVERY_TRIGGERS) 
		{
			pDrvMain->eSmState = SM_STATE_STOPPING;
			eStatus = drvMain_StopActivities (pDrvMain);
		}
        break;
    case SM_STATE_FAILED:
        /* Nothing to do except waiting for Destroy */
        break;
 default:
        TRACE2(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR , "drvMain_Sm: Unknown state, eEvent=%u at state=%u\n", eEvent, pDrvMain->eSmState);
        /* Note: Handled below as a failure since the status remains TI_NOK */
        break;  
    }

    /* Handle failures (status = NOK) if not handled yet */
    if ((eStatus == TI_NOK) && 
        (pDrvMain->eSmState != SM_STATE_FAILED) &&
        (pDrvMain->eSmState != SM_STATE_STOPPING_ON_FAIL))
    {
        TRACE3(pDrvMain->tStadHandles.hReport, REPORT_SEVERITY_ERROR , "drvMain_Sm: eEvent=%u at state=%u, status=%d\n", eEvent, pDrvMain->eSmState, eStatus);
        pDrvMain->eSmState = SM_STATE_STOPPING_ON_FAIL;
        wlanDrvIf_UpdateDriverState (hOs, DRV_STATE_FAILED);

        /* 
         * Stop all activities. This may be completed in a different context if
         *     we should wait for an Async bus transaction completion.
         * The drvMain_TwdStopCb is called from the TWD in any case to pass
         *     us to the SM_STATE_FAILED state (where we wait for Destroy).
         */
        eStatus = drvMain_StopActivities (pDrvMain);
    }
}