text: /*
   * ScanSrv.c
   *
   * Copyright(c) 1998 - 2009 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 ScanSrv.c
   *  \brief This file include the scan SRV module implementation
   *
   *  \see   ScanSrv.h, ScanSrvSm.h, ScanSrvSm.c
   */
  
  
  #define __FILE_ID__  FILE_ID_115
  #include "report.h"
  #include "timer.h"
  #include "ScanSrv.h"
  #include "ScanSrvSM.h"
  #include "MacServices.h"
  #include "MacServices_api.h"
  #include "eventMbox_api.h"
  #include "CmdBld.h"
  
  /**
   * \\n
   * \date 16-Oct-2004\n
   * \brief Creates the scan SRV object
   *
   * Function Scope \e Public.\n
   * \param hOS - handle to the OS object.\n
   * \return a handle to the scan SRV object, NULL if an error occurred.\n
   */
  TI_HANDLE MacServices_scanSRV_create( TI_HANDLE hOS )
  {
      /* allocate the scan SRV object */
      scanSRV_t *pScanSRV = os_memoryAlloc( hOS, sizeof(scanSRV_t));
      if ( NULL == pScanSRV )
      {
          WLAN_OS_REPORT( ("ERROR: Failed to create scan SRV module"));
          return NULL;
      }
  
      os_memoryZero( pScanSRV->hOS, pScanSRV, sizeof(scanSRV_t));
  
      /* allocate the state machine */
      if ( TI_OK != fsm_Create( hOS, &(pScanSRV->SM), SCAN_SRV_NUM_OF_STATES, SCAN_SRV_NUM_OF_EVENTS ))
      {
          WLAN_OS_REPORT( ("ERROR: Failed to allocate scan SRV state machine"));
          os_memoryFree( hOS, pScanSRV, sizeof(scanSRV_t));
          return NULL;
      }
   
      /* store the OS handle */
      pScanSRV->hOS = hOS;
  
      return pScanSRV;
  }
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief Finalizes the scan SRV module (releasing memory and timer)
   *
   * Function Scope \e Public.\n
   * \param hScanSRV - handle to the scan SRV object.\n
   */
  void MacServices_scanSRV_destroy( TI_HANDLE hScanSRV )
  {
      scanSRV_t *pScanSRV = (scanSRV_t*)hScanSRV;
  
      /* free timer */
  	if (pScanSRV->hScanSrvTimer)
  	{
  		tmr_DestroyTimer (pScanSRV->hScanSrvTimer);
  	}
      
      /* free memory */
      fsm_Unload( pScanSRV->hOS, pScanSRV->SM );
      os_memoryFree( pScanSRV->hOS, (TI_HANDLE)pScanSRV , sizeof(scanSRV_t));
  }
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief Initializes the scan SRV module, registers SCAN_COMPLETE to HAL.
   *
   * Function Scope \e Public.\n
   * \param hScanSRV - handle to the scan SRV object.\n
   * \param Handles of other modules.\n
    */
  TI_STATUS MacServices_scanSRV_init (TI_HANDLE hMacServices,
                                      TI_HANDLE hReport,
                                      TI_HANDLE hTWD,
                                      TI_HANDLE hTimer,
                                      TI_HANDLE hEventMbox,
                                      TI_HANDLE hCmdBld)
  {
      MacServices_t* pMacServices =  (MacServices_t*)hMacServices;
      scanSRV_t *pScanSRV =  pMacServices->hScanSRV;
  
      /* store handles */
      pScanSRV->hTWD = hTWD;
      pScanSRV->hTimer = hTimer;
      pScanSRV->hReport = hReport;
      pScanSRV->hEventMbox = hEventMbox;
      pScanSRV->hPowerSrv = pMacServices->hPowerSrv;
      pScanSRV->hCmdBld = hCmdBld;
      pScanSRV->commandResponseFunc = NULL;
      pScanSRV->commandResponseObj = NULL;  
  
      /* create the timer */
      pScanSRV->hScanSrvTimer = tmr_CreateTimer (pScanSRV->hTimer);
  	if (pScanSRV->hScanSrvTimer == NULL)
  	{
          TRACE0(pScanSRV->hReport, REPORT_SEVERITY_ERROR, "MacServices_scanSRV_init(): Failed to create hScanSrvTimer!\n");
  		return TI_NOK;
  	}
  
      /* init state machine */
      scanSRVSM_init ((TI_HANDLE)pScanSRV);
  
      /* Register our scan complete handler to the HAL events mailbox */
      eventMbox_RegisterEvent (pScanSRV->hEventMbox, 
                                TWD_OWN_EVENT_SCAN_CMPLT, 
                                (void *)MacServices_scanSRV_scanCompleteCB, 
                                (TI_HANDLE)pScanSRV); 
      eventMbox_RegisterEvent (pScanSRV->hEventMbox, 
                                TWD_OWN_EVENT_SPS_SCAN_CMPLT, 
                                (void *)MacServices_scanSRV_scanCompleteCB, 
                                (TI_HANDLE)pScanSRV);
  
      /* init other stuff */
      pScanSRV->currentNumberOfConsecutiveNoScanCompleteEvents = 0;
  
      TRACE0( hReport, REPORT_SEVERITY_INIT, ".....Scan SRV configured successfully.\n");
  
      return TI_OK;
  }
  
  /**
   * \brief Restart the scan SRV module upon recovery.
   *
   * Function Scope \e Public.\n
   * \param hScanSRV - handle to the scan SRV object.\n
   */
  void scanSRV_restart (TI_HANDLE hScanSRV)
  {
  	scanSRV_t *pScanSRV =  (scanSRV_t *)hScanSRV;
      /* init state machine */
  	/* initialize current state */
  	pScanSRV->SMState = SCAN_SRV_STATE_IDLE;
  
      if (pScanSRV->bTimerRunning)
      {
          tmr_StopTimer (pScanSRV->hScanSrvTimer);
          pScanSRV->bTimerRunning = TI_FALSE;
      }
  }
  
  /**
   * \\n
   * \date 26-July-2006\n
   * \brief Configures the scan SRV module with initialization values
   *
   * Function Scope \e Public.\n
   * \param hScanSRV - handle to the scan SRV object.\n
   * \param hReport - handle to the report object.\n
   * \param hTWD - handle to the HAL ctrl object.\n
    */
  void MacServices_scanSrv_config( TI_HANDLE hMacServices, TScanSrvInitParams* pInitParams )
  {
      MacServices_t* pMacServices =  (MacServices_t*)hMacServices;
      scanSRV_t *pScanSRV =  pMacServices->hScanSRV;
  
      pScanSRV->numberOfNoScanCompleteToRecovery = pInitParams->numberOfNoScanCompleteToRecovery;
  
      /* Set Triggered scan time out per channel */
      pScanSRV->uTriggeredScanTimeOut = pInitParams->uTriggeredScanTimeOut;
  	TWD_CmdSetSplitScanTimeOut (pScanSRV->hTWD, pScanSRV->uTriggeredScanTimeOut);
  }
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief Registers a complete callback for scan complete notifications.
   *
   * Function Scope \e Public.\n
   * \param hMacServices - handle to the MacServices object.\n
   * \param scanCompleteCB - the complete callback function.\n
   * \param hScanCompleteObj - handle to the object passed to the scan complete callback function.\n
   */
  void MacServices_scanSRV_registerScanCompleteCB( TI_HANDLE hMacServices, 
                                       TScanSrvCompleteCb scanCompleteCB, TI_HANDLE hScanCompleteObj )
  {
      scanSRV_t *pScanSRV = (scanSRV_t*)((MacServices_t*)hMacServices)->hScanSRV;
  
      pScanSRV->scanCompleteNotificationFunc = scanCompleteCB;
      pScanSRV->scanCompleteNotificationObj = hScanCompleteObj;
  }
  
  /**
   * \brief Registers a failure event callback for scan error notifications.
   *
   * Function Scope \e member.\n
   * \param hScanSRV - handle to the Scan SRV object.\n
   * \param failureEventCB - the failure event callback function.\n
   * \param hFailureEventObj - handle to the object passed to the failure event callback function.\n
   */
  void scanSRV_registerFailureEventCB( TI_HANDLE hScanSRV, 
                                       void * failureEventCB, TI_HANDLE hFailureEventObj )
  {
      scanSRV_t *pScanSRV = (scanSRV_t*)(hScanSRV);
  
      pScanSRV->failureEventFunc  = (TFailureEventCb)failureEventCB;
      pScanSRV->failureEventObj   = hFailureEventObj;
  }
  
  /**
   * \\n
   * \date 27-Sep-2005\n
   * \brief This function is the CB which is called as response to 'StartScan' or 'StopScan' \n.
   *        here we check if there is a GWSI command response , and call it if necessary .\n
   * Function Scope \e Private.\n
   * \param hScanSrv - handle to the scan SRV object.\n
   * \param MboxStatus - mailbox status. \n
   */
  void MacServices_scanSRVCommandMailBoxCB(TI_HANDLE hScanSrv,TI_UINT16 MboxStatus)
  {
      scanSRV_t* pScanSRV = (scanSRV_t*)hScanSrv;
      TI_UINT16 responseStatus;
      TCmdResponseCb CB_Func;
      TI_HANDLE  CB_Handle;
  
      TRACE1( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, " status %u\n",MboxStatus);
  
      /* set response to TI_OK or TI_NOK */
      responseStatus = ((MboxStatus > 0) ? TI_NOK : TI_OK);
      
      /* if we have a Response Function (only in GWSI) we set it back to NULL and then 
          we call it */
      if (pScanSRV->commandResponseFunc != NULL)
      {
          CB_Func = pScanSRV->commandResponseFunc;
          CB_Handle = pScanSRV->commandResponseObj;
  
          pScanSRV->commandResponseFunc = NULL;
          pScanSRV->commandResponseObj = NULL;
  
          CB_Func(CB_Handle, responseStatus);
      }
       /* if scan request failed */
      if ( TI_OK != responseStatus )
      {
          TRACE0( pScanSRV->hReport, REPORT_SEVERITY_ERROR, "Mail box returned error , quitting scan.\n");
  
          /* send a scan complete event. This will do all necessary clean-up (timer, power manager, notifying scan complete) */
          scanSRVSM_SMEvent( hScanSrv, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_SCAN_COMPLETE );
      }
  }
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief Performs a scan
   *
   * Function Scope \e Public.\n
   * \param hMacServices - handle to the MacServices object.\n
   * \param scanParams - the scan specific parameters.\n
   * \param eScanresultTag - tag used for result and scan complete tracking
   * \param bHighPriority - whether to perform a high priority (overlaps DTIM) scan.\n
   * \param bDriverMode - whether to try to enter driver mode (with PS on) before issuing the scan command.\n
   * \param bScanOnDriverModeError - whether to proceed with the scan if requested to enter driver mode and failed.\n
   * \param psRequest - Parameter sent to PowerSaveServer on PS request to indicate PS on or "keep current" 
   * \param bSendNullData - whether to send Null data when exiting driver mode on scan complete.\n
   * \param commandResponseFunc - CB function which called after downloading the command. \n
   * \param commandResponseObj -  The CB function Obj (Notice : last 2 params are NULL in Legacy run). \n
   * \param psRequest - Parameter sent to PowerSaveServer on PS request to indicate PS on or "keep current" 
   * \return TI_OK if successful (various, TBD codes if not).\n
   */
  TI_STATUS MacServices_scanSRV_scan( TI_HANDLE hMacServices, TScanParams *scanParams, EScanResultTag eScanTag,
                                      TI_BOOL bHighPriority, TI_BOOL bDriverMode, TI_BOOL bScanOnDriverModeError, 
                          E80211PsMode psRequest, TI_BOOL bSendNullData,
                          TCmdResponseCb commandResponseFunc, TI_HANDLE commandResponseObj)
  {
     scanSRV_t *pScanSRV = (scanSRV_t*)((MacServices_t*)hMacServices)->hScanSRV;
  
  
      TRACE0( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "Scan request received.\n");
  
      /* sanity check - scan can only start if the scan SRV is idle */
      if ( SCAN_SRV_STATE_IDLE != pScanSRV->SMState )
      {
          TRACE0( pScanSRV->hReport, REPORT_SEVERITY_WARNING, "Scan request while scan is running!\n");
          return TI_NOK;
      }
  
      /* Response function for GWSI only. In Legacy run we get NULL and never use it. */
      pScanSRV->commandResponseFunc = commandResponseFunc;
      pScanSRV->commandResponseObj  = commandResponseObj;
  
      pScanSRV->bInRequest = TI_TRUE;
      pScanSRV->returnStatus = TI_OK;
  
      /* copy scan paramaters */
      pScanSRV->scanParams = scanParams;
      pScanSRV->eScanTag = eScanTag;
      pScanSRV->uResultCount = 0;
      pScanSRV->bHighPriority = bHighPriority;
      pScanSRV->bScanOnDriverModeFailure = bScanOnDriverModeError;
      pScanSRV->bSendNullData = bSendNullData;
      pScanSRV->psRequest = psRequest;
  
      if ( SCAN_TYPE_SPS == scanParams->scanType )
      {
          pScanSRV->bSPSScan = TI_TRUE;
  
      }
      else
      {
          pScanSRV->bSPSScan = TI_FALSE;
      }
  
  
      /* check whether the scan will overlap DTIM frame */
      if ( (TI_FALSE == bHighPriority) && (TI_TRUE == bDriverMode))
      {
          pScanSRV->bDtimOverlapping = TI_FALSE;
      }
      else
      {
          pScanSRV->bDtimOverlapping = TI_TRUE;
      }
  
      /* mark the no scan complete flag. The purpose of this flag is to be able to identify
         whether the scan complete is a normal process, or was it generated because a no scan ocmplete
         was identified, a stop scan command was snet to the FW, and thus a scan complete was received.
         In the former case we nullify the consecutive no scan complete counter, whereas in the latter
         we do not. */
      pScanSRV->bNoScanCompleteFlag = TI_FALSE;
  
      /* if required to enter driver mode */
      if ( TI_TRUE == bDriverMode )
      {
          pScanSRV->bExitFromDriverMode = TI_TRUE;
          /* send a PS_REQUEST event */
          scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&(pScanSRV->SMState), SCAN_SRV_EVENT_REQUEST_PS );
      }
      /* no driver mode required */
      else
      {
          pScanSRV->bExitFromDriverMode = TI_FALSE;
          /* send a PS_SUCCESS event - will start the scan */
          scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_PS_SUCCESS );
      }
  
      pScanSRV->bInRequest = TI_FALSE;
      
      return pScanSRV->returnStatus;
  }
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief Sends a Stop Scan command to FW, no matter if we are in scan progress or not
   *
   * Function Scope \e Public.\n
   * \param hMacServices - handle to the MacServices object.\n
   * \param eScanTag - scan tag, used for scan complete and result tracking
   * \param bSendNullData - indicates whether to send Null data when exiting driver mode.\n
   * \param commandResponseFunc - CB function which called after downloading the command. \n
   * \param commandResponseObj -  The CB function Obj (Notice : last 2 params are NULL in Legacy run). \n
   * \return TI_OK if successful (various, TBD codes if not).\n
   */
  TI_STATUS MacServices_scanSRV_stopScan( TI_HANDLE hMacServices, EScanResultTag eScanTag, TI_BOOL bSendNullData,
                                          TCmdResponseCb ScanCommandResponseCB, TI_HANDLE CB_handle )
  {
      scanSRV_t *pScanSRV = (scanSRV_t*)((MacServices_t*)hMacServices)->hScanSRV;
      TI_INT32 stopScanStatus;
  
      TRACE0( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "Stop scan request received.\n");
  
      /* update the driver mode exit flag */
      pScanSRV->bSendNullData = bSendNullData;
  
      if ( TI_TRUE == pScanSRV->bSPSScan )
      {
          stopScanStatus = cmdBld_CmdStopSPSScan (pScanSRV->hCmdBld, eScanTag, (void *)ScanCommandResponseCB, CB_handle);
      }
      else
      {
          stopScanStatus = cmdBld_CmdStopScan (pScanSRV->hCmdBld, eScanTag, (void *)ScanCommandResponseCB, CB_handle);
      }
  
      if (TI_OK != stopScanStatus)
      {
          return TI_NOK;
      }
      
      /* send a stop scan event */
      scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_STOP_SCAN );
  
      return pScanSRV->returnStatus;
  }
  
  /**
   * \\n
   * \date 17-Jan-2005\n
   * \brief Notifies the scan SRV of a FW reset (that had originally been reported by a different module).\n
   *
   * Function Scope \e Public.\n
   * \param hMacServices - handle to the MacServices object.\n
   * \return TI_OK if successful (various, TBD codes if not).\n
   */
  TI_STATUS MacServices_scanSRV_stopOnFWReset( TI_HANDLE hMacServices )
  {
     scanSRV_t *pScanSRV = (scanSRV_t*)((MacServices_t*)hMacServices)->hScanSRV;
  
      TRACE0( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "FW reset notification received.\n");
  
      /* mark the return status */
      pScanSRV->returnStatus = TI_NOK;
  
      /* send a FW reset event */
      return scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_FW_RESET );
  }
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief callback function used by the power server to notify driver mode result
   *          this CB is used in requesting PS and exiting PS.
   * Function Scope \e Public.\n
   * \param hScanSRV - handle to the scan SRV object.\n
   * \param psStatus - the power save request status.\n
   */
  void MacServices_scanSRV_powerSaveCB( TI_HANDLE hScanSRV, TI_UINT8 PSMode,TI_UINT8 psStatus )
  {
      scanSRV_t *pScanSRV = (scanSRV_t*)hScanSRV;
  
      TRACE1( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "PS Call Back status %d .\n",psStatus);
  
      /* if driver mode enter/exit succeedded */
      if ( (ENTER_POWER_SAVE_SUCCESS == psStatus) || (EXIT_POWER_SAVE_SUCCESS == psStatus))
      {
          TRACE0( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "PS successful.\n");
  
          /* send a PS_SUCCESS event */
          scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_PS_SUCCESS );
      }
      /* driver mode entry failed, and scan is requested even on PS failure but we are entering PS and not Exiting */
      else if ( (TI_TRUE == pScanSRV->bScanOnDriverModeFailure) && ( ENTER_POWER_SAVE_FAIL == psStatus))
      {
          TRACE0( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "PS enter failed, continune scan .\n");
  
          /* send a PS_SUCCESS event */
          scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_PS_SUCCESS );
      }
      /* driver mode enter or exit failed */
      else
      {
          /* if we are trying to enter PS and fail to do so - return error on scan complete */
          if ( ENTER_POWER_SAVE_FAIL == psStatus) 
          {
              TRACE0( pScanSRV->hReport, REPORT_SEVERITY_WARNING, "PS enter failed . quiting scan .\n");
              /* Set the return status  */
              pScanSRV->returnStatus = TI_NOK;
          }
  
          /* send a PS FAIL event */
          scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_PS_FAIL );
      }
  }
  
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief Callback function used by the HAL ctrl to notify scan complete
   *
   * Function Scope \e Public.\n
   * \param hScanSRV - handle to the scan SRV object.\n
   * \param str - pointer to scan result buffer (holding SPS status for SPS scan only!).\n
   * \param strLen - scan result buffer length (should ALWAYS be 2, even for non SPS scans).\n
   */
  void MacServices_scanSRV_scanCompleteCB( TI_HANDLE hScanSRV, char* str, TI_UINT32 strLen )
  {
      scanSRV_t *pScanSRV = (scanSRV_t*)hScanSRV;
      scanCompleteResults_t   *pResult = (scanCompleteResults_t*)str;
  
      TRACE0( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "Scan complete notification from TNET.\n");
  
  	/* nullify the consecutive no scan complete events counter  - only if this is a scan complete that
         does not happen afetr a stop scan (due to a timer expiry) */
  	if ( TI_FALSE == pScanSRV->bNoScanCompleteFlag )
      {
          pScanSRV->currentNumberOfConsecutiveNoScanCompleteEvents = 0;
      }
  
      /* copy result counter and scan tag */
      pScanSRV->uResultCount = pResult->numberOfScanResults;
      pScanSRV->eScanTag = (EScanResultTag)pResult->scanTag;
  
      /* copy scan SPS addmitted channels and SPS result */
      if (TI_FALSE == pScanSRV->bSPSScan) 
      {
          /* normal scan - no result is available */
          pScanSRV->bTSFError = TI_FALSE;
          TRACE0( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "Normal scan completed.\n");
      }
      else
      {
          /* SPS scan - first byte indicates whether a TSF error (AP recovery) occured */
          if ( 0 != (pResult->scheduledScanStatus >> 24))
          {
              pScanSRV->bTSFError = TI_TRUE;
          }
          else
          {
              pScanSRV->bTSFError = TI_FALSE;
          }
  
          /* next two bytes indicates on which channels scan was attempted */
          pScanSRV->SPSScanResult = (TI_UINT16)(pResult->scheduledScanStatus >> 16) | 0xff;
          pScanSRV->SPSScanResult = ENDIAN_HANDLE_WORD( pScanSRV->SPSScanResult );
          TRACE1( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "SPS scan completed. TSF error: , SPS result: %x\n", pScanSRV->SPSScanResult);
      }
  
      /* send a SCAN_COMPLETE event  */
      scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_SCAN_COMPLETE );
  }
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief called when a scan timer expires. Completes the scan and starts a recovery process.
   *
   * Function Scope \e Public.\n
   * \param hScanSRV - handle to the scan SRV object.\n
   * \param bTwdInitOccured - Indicates if TWDriver recovery occured since timer started.\n
   */
  void MacServices_scanSRV_scanTimerExpired (TI_HANDLE hScanSRV, TI_BOOL bTwdInitOccured)
  {
      scanSRV_t *pScanSRV = (scanSRV_t*)hScanSRV;
  
      /* mark that no scan complete occured (see sanSRV_scan for more detailed explanation) */
      pScanSRV->bNoScanCompleteFlag = TI_TRUE;
  
      /* send a TIMER_EXPIRED event */
      scanSRVSM_SMEvent( (TI_HANDLE)pScanSRV, (scan_SRVSMStates_e*)&pScanSRV->SMState, SCAN_SRV_EVENT_TIMER_EXPIRED );
  }
  
  /**
   * \\n
   * \date 29-Dec-2004\n
   * \brief Calculates the maximal time required for a scan operation
   *
   * Function Scope \e Public.\n
   * \param hScanSRV - handle to the scan SRV object.\n
   * \param scanParams - the scan parameters
   * \param bConsiderDTIM - whether this scan overlaps DTIM
   * \return the time (in milliseconds)
   */
  TI_UINT32 MacServices_scanSRVcalculateScanTimeout( TI_HANDLE hScanSRV, TScanParams* scanParams, TI_BOOL bConsiderDTIM )
  {
      TI_UINT32 i, uDtimPeriodMs, uBeaconIntervalMs, timeout = 0;
      scanSRV_t *pScanSRV = (scanSRV_t*)hScanSRV;
  
      /********************************************************************************
          timeout calculation is performed according to scan type:
          1. for normal scan, multiply the channel time by the number of channels.
             if this scan is not overlapping DTIM, add the DTIM period (in case
             starting the scan right now will cause the very last milliseconds of the
             scan to overlap the next DTIM). Add the guard time.
          2. for triggered scan, multiply the channel time plus the trigger time
             constant (the maximum time between two frames from the Tid
             according to which the scan is triggered) by the number of channels.
             DTIM period is added only as precaution - since the scan is divided to
             channels, only very few of them will be delayed due to DTIM (in the worst 
             case), and this delay would be only the length of one channel scan.
             Eventually, Add the guard time.
          3. for SPS scan: Measure the time from current TSF to the TSF at which the 
             scan is scheduled to finish (done by the scan manager, and passed as 
             a parameter in the scan structure). Add guard time. DTIM overlapping is not 
             considered because if the scan overlaps DTIM the channels which are 
             scheduled during the DTIM (if any) won't be scanned.
       ********************************************************************************/
  
      /* get DTIM time, if scanning in connected mode and need to consider DTIM */
      if ( bConsiderDTIM ) 
      {  
          /* new dtimPeriod calculation */
          uBeaconIntervalMs = MacServices_scanSRVConvertTUToMsec (pScanSRV->uBeaconInterval);
          uDtimPeriodMs     = uBeaconIntervalMs * pScanSRV->uDtimPeriod; 
      }
      else
      {
          uDtimPeriodMs = 0;
      }
  
      switch (scanParams->scanType)
      {
      case SCAN_TYPE_NORMAL_ACTIVE:
      case SCAN_TYPE_NORMAL_PASSIVE:
          /* the timeout is the scan duration on all channels */
          for ( i = 0; i < scanParams->numOfChannels; i++ )
          {
              timeout += scanParams->channelEntry[ i ].normalChannelEntry.maxChannelDwellTime;
          }
          timeout = (timeout / 1000) + uDtimPeriodMs + SCAN_SRV_FW_GUARD_TIME_MS;
          break;
  
      case SCAN_TYPE_TRIGGERED_ACTIVE:
      case SCAN_TYPE_TRIGGERED_PASSIVE:
          /* the timeout is the scan duration on all channels, plus the maximum time that can pass 
             between two different frames from the same Tid */
          for ( i = 0; i < scanParams->numOfChannels; i++ )
          {
              timeout += scanParams->channelEntry[ i ].normalChannelEntry.maxChannelDwellTime;
          }
          timeout = (timeout / 1000) + uDtimPeriodMs + 
                    ((pScanSRV->uTriggeredScanTimeOut / 1000 + 1) * scanParams->numOfChannels) + 
                    SCAN_SRV_FW_GUARD_TIME_MS;
          break;
  
      case SCAN_TYPE_SPS:
          timeout = scanParams->SPSScanDuration + SCAN_SRV_FW_GUARD_TIME_MS;
          break;
  
      default:
          TRACE1( pScanSRV->hReport, REPORT_SEVERITY_ERROR, "Trying to calculate timeout for undefined scan type %d\n", scanParams->scanType);
          break;
      }
      TRACE1( pScanSRV->hReport, REPORT_SEVERITY_INFORMATION, "scanSRVcalculateScanTimeout, timeout = %d\n", timeout);
  
      return timeout;
  }
  
  /**
   * \\n
   * \date 16-Jan-2005\n
   * \brief Convert time units (1024 usecs) to millisecs
   *
   * Function Scope \e Private.\n
   * \param tu - the time in time units
   * \return the time in milliseconds
   */
  TI_UINT32 MacServices_scanSRVConvertTUToMsec( TI_UINT32 tu )
  {
      return (tu * 1024) / 1000;
  }
  
  
  /**
   * \\n
   * \brief Save DTIM and Beacon periods for scan timeout calculations
   *
   * Function Scope \e Public.\n
   * \param hMacServices    - module object
   * \param uDtimPeriod     - DTIM period in number of beacons
   * \param uBeaconInterval - Beacon perios in TUs (1024 msec)
   * \return void
   */
  void MacServices_scanSrv_UpdateDtimTbtt (TI_HANDLE hMacServices, 
                                           TI_UINT8  uDtimPeriod, 
                                           TI_UINT16 uBeaconInterval)
  {
      scanSRV_t *pScanSRV = (scanSRV_t*)((MacServices_t*)hMacServices)->hScanSRV;
  
      pScanSRV->uDtimPeriod     = uDtimPeriod;
      pScanSRV->uBeaconInterval = uBeaconInterval;
  }
  
  
  #ifdef TI_DBG
  /**
   * \\n
   * \date God knows when...\n
   * \brief Prints Scan Server SM status.\n
   *
   * Function Scope \e Public.\n
   * \param hMacServices - handle to the Mac Services object.\n
   * \return always TI_OK.\n
   */
  void MacServices_scanSrv_printDebugStatus(TI_HANDLE hMacServices)
  {
     scanSRV_t *pScanSRV = (scanSRV_t*)((MacServices_t*)hMacServices)->hScanSRV;
  
      WLAN_OS_REPORT(("scanSrv State="));
      switch (pScanSRV->SMState)
      {
      case SCAN_SRV_STATE_IDLE:
          WLAN_OS_REPORT((" IDLE\n"));
          break;
      case SCAN_SRV_STATE_PS_WAIT:
          WLAN_OS_REPORT((" PS_WAIT\n"));
          break;
      case SCAN_SRV_STATE_PS_EXIT:
          WLAN_OS_REPORT((" PS_EXIT\n"));
          break;
      case SCAN_SRV_STATE_SCANNING:
          WLAN_OS_REPORT((" SCANNING\n"));
          break;
      case SCAN_SRV_STATE_STOPPING:
          WLAN_OS_REPORT((" STOPPING\n"));
          break;
      default:
          WLAN_OS_REPORT((" Invalid State=%d\n",pScanSRV->SMState));
          break;
  
      }
  
      if (NULL != pScanSRV->scanParams)
      {
          WLAN_OS_REPORT(("scanSrv bExitFromDriverMode=%d, bHighPriority=%d, bInRequest=%d,\n \
                          bScanOnDriverModeFailure=%d, bSendNullData=%d, bSPSScan=%d, bTimerRunning=%d, \n \
                          psRequest=%d, scanType=%d\n", 
                          pScanSRV->bExitFromDriverMode,
                          pScanSRV->bHighPriority,
                          pScanSRV->bInRequest,
                          pScanSRV->bScanOnDriverModeFailure,
                          pScanSRV->bSendNullData,
                          pScanSRV->bSPSScan,
                          pScanSRV->bTimerRunning,
                          pScanSRV->psRequest,
                          pScanSRV->scanParams->scanType));
      }
  }
  #endif
  
  