| /* |
| * 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; |
| |
| 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; |
| TI_BOOL tmpRecovery; |
| |
| 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! |
| */ |
| |
| tmpRecovery = pDrvMain->bRecovery; |
| 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 (!tmpRecovery) |
| { |
| 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 (); |
| if (!pDrvMain->bRecovery) |
| { |
| os_SignalObjectSet (hOs, pDrvMain->hSignalObj); |
| } |
| else if (pDrvMain->uNumOfRecoveryAttempts < MAX_NUM_OF_RECOVERY_TRIGGERS) |
| { |
| pDrvMain->uNumOfRecoveryAttempts++; |
| pDrvMain->eSmState = SM_STATE_STOPPING; |
| eStatus = drvMain_StopActivities (pDrvMain); |
| } |
| WLAN_OS_REPORT(("[WLAN] Exit application\n")); |
| pDrvMain->bRecovery = TI_FALSE; |
| 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); |
| } |
| } |
