/*

 * MeasurementSrv.c

 *

 * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.      

 * All rights reserved.      

 * 

 * This program and the accompanying materials are made available under the 

 * terms of the Eclipse Public License v1.0 or BSD License which accompanies

 * this distribution. The Eclipse Public License is available at

 * http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below.                                   

 *                                                                       

 * Redistribution and use in source and binary forms, with or without    

 * modification, are permitted provided that the following conditions    

 * are met:                                                              

 *                                                                       

 *  * Redistributions of source code must retain the above copyright     

 *    notice, this list of conditions and the following disclaimer.      

 *  * Redistributions in binary form must reproduce the above copyright  

 *    notice, this list of conditions and the following disclaimer in    

 *    the documentation and/or other materials provided with the         

 *    distribution.                                                      

 *  * Neither the name Texas Instruments nor the names of its            

 *    contributors may be used to endorse or promote products derived    

 *    from this software without specific prior written permission.      

 *                                                                       

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   

 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     

 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 

 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT  

 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 

 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      

 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT   

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/** \file measurementSrv.c

 *  \brief This file include the measurement SRV interface functions implementation.

 *  \author Ronen Kalish

 *  \date 09-November-2005

 */

#define __FILE_ID__  FILE_ID_110

#include "tidef.h"

#include "MeasurementSrv.h"

#include "MeasurementSrvSM.h"

#include "report.h"

#include "timer.h"

#include "osApi.h"

#include "MacServices.h"

#include "measurementSrvDbgPrint.h"

#include "eventMbox_api.h"

#include "CmdBld.h"

/**

 * \author Ronen Kalish\n

 * \date 08-November-2005\n

 * \brief Creates the measurement SRV object

 *

 * Function Scope \e Public.\n

 * \param hOS - handle to the OS object.\n

 * \return a handle to the measurement SRV object, NULL if an error occurred.\n

 */

TI_HANDLE MacServices_measurementSRV_create( TI_HANDLE hOS )

{

    measurementSRV_t* pMeasurementSRV;

    /* allocate the measurement SRV object */

    pMeasurementSRV = os_memoryAlloc( hOS, sizeof(measurementSRV_t),MemoryNormal);

    if ( NULL == pMeasurementSRV )

    {

        WLAN_OS_REPORT( ("ERROR: Failed to create measurement SRV object."));

        return NULL;

    }

    /* nullify the object */

    os_memoryZero( hOS, pMeasurementSRV, sizeof(measurementSRV_t));

    /* store OS handle */

    pMeasurementSRV->hOS = hOS;

    /* allocate the SM */

    if ( TI_OK != fsm_Create( hOS, &(pMeasurementSRV->SM), MSR_SRV_NUM_OF_STATES, MSR_SRV_NUM_OF_EVENTS ))

    {

        pMeasurementSRV->SM = NULL;

        WLAN_OS_REPORT(("Failed to create measurement SRV state machine.\n"));

        MacServices_measurementSRV_destroy( pMeasurementSRV );

        return NULL;

    }

    return (TI_HANDLE)pMeasurementSRV;

}

/**

 * \author Ronen Kalish\n

 * \date 08-November-2005\n

 * \brief Initializes the measurement SRV object

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSRV - handle to the measurement SRV object.\n

 * \param hReport - handle to the report object.\n

 * \param hCmdBld - handle to the Command Builder object.\n

 * \param hPowerSaveSRV - handle to the power save SRV object.\n

 */

TI_STATUS MacServices_measurementSRV_init (TI_HANDLE hMeasurementSRV, 

                                           TI_HANDLE hReport, 

                                           TI_HANDLE hCmdBld,

                                           TI_HANDLE hEventMbox,

                                           TI_HANDLE hPowerSaveSRV,

                                           TI_HANDLE hTimer)

{ 

    measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

	TI_INT32 i;

    /* store handles */

    pMeasurementSRV->hReport = hReport;

    pMeasurementSRV->hCmdBld = hCmdBld;

    pMeasurementSRV->hEventMbox = hEventMbox;

    pMeasurementSRV->hPowerSaveSRV = hPowerSaveSRV;

    pMeasurementSRV->hTimer = hTimer;

    /* Initialize the state machine */

    measurementSRVSM_init (hMeasurementSRV);

    /* allocate the module timers */

    pMeasurementSRV->hStartStopTimer = tmr_CreateTimer (pMeasurementSRV->hTimer);

	if (pMeasurementSRV->hStartStopTimer == NULL)

	{

        TRACE0(pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, "MacServices_measurementSRV_init(): Failed to create hStartStopTimer!\n");

		return TI_NOK;

	}

    pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;

    for (i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++)

    {

        pMeasurementSRV->hRequestTimer[i] = tmr_CreateTimer (pMeasurementSRV->hTimer);

        if (pMeasurementSRV->hRequestTimer[i] == NULL)

        {

            TRACE0(pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, "MacServices_measurementSRV_init(): Failed to create hRequestTimer!\n");

            return TI_NOK;

        }

        pMeasurementSRV->bRequestTimerRunning[i] = TI_FALSE;

    }

    /* register HAL callbacks */

    /* Register and Enable the Measure Start event in HAL */

	eventMbox_RegisterEvent (pMeasurementSRV->hEventMbox, 

                               TWD_OWN_EVENT_MEASUREMENT_START,

                               (void *)MacServices_measurementSRV_measureStartCB, 

                               hMeasurementSRV);

    eventMbox_UnMaskEvent (pMeasurementSRV->hEventMbox, TWD_OWN_EVENT_MEASUREMENT_START, NULL, NULL);

    /* Register and Enable the Measurement Complete event in HAL.

    This event will be received when the Measurement duration expired,

    or after Stop Measure command. */

	eventMbox_RegisterEvent (pMeasurementSRV->hEventMbox,

                               TWD_OWN_EVENT_MEASUREMENT_COMPLETE,

                               (void *)MacServices_measurementSRV_measureCompleteCB,

                               hMeasurementSRV);

    eventMbox_UnMaskEvent (pMeasurementSRV->hEventMbox, TWD_OWN_EVENT_MEASUREMENT_COMPLETE, NULL, NULL);

	/* Register and Enable the AP Discovery Complete event in HAL */

    eventMbox_RegisterEvent (pMeasurementSRV->hEventMbox, 

                               TWD_OWN_EVENT_AP_DISCOVERY_COMPLETE, 

                               (void *)MacServices_measurementSRV_apDiscoveryCompleteCB, 

                               hMeasurementSRV);

    eventMbox_UnMaskEvent (pMeasurementSRV->hEventMbox, TWD_OWN_EVENT_AP_DISCOVERY_COMPLETE, NULL, NULL);

    TRACE0(hReport, REPORT_SEVERITY_INIT , ".....Measurement SRV configured successfully.\n");

    return TI_OK;

}

/**

 * \brief Restart the measurement SRV object upon recovery.

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSRV - handle to the measurement SRV object.\n

 */

void measurementSRV_restart( TI_HANDLE hMeasurementSRV)

{

    measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

	TI_INT32 i;

	/* if a timer is running, stop it */

	if (pMeasurementSRV->bStartStopTimerRunning)

	{

		tmr_StopTimer (pMeasurementSRV->hStartStopTimer);

		pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;

	}

	for (i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++)

	{

		if (pMeasurementSRV->bRequestTimerRunning[i])

		{

			tmr_StopTimer (pMeasurementSRV->hRequestTimer[i]);

			pMeasurementSRV->bRequestTimerRunning[i] = TI_FALSE;

		}

	}

    /* Initialize the state machine */

	/* initialize current state */

	pMeasurementSRV->SMState = MSR_SRV_STATE_IDLE;

    /* mark that all timers are not running */

    pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;

    for ( i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++ )

    {

        pMeasurementSRV->bRequestTimerRunning[ i ] = TI_FALSE;

    }

}

/**

 * \author Ronen Kalish\n

 * \date 08-November-2005\n

 * \brief Destroys the measurement SRV object

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSRV - handle to the measurement SRV object.\n

 */

void MacServices_measurementSRV_destroy( TI_HANDLE hMeasurementSRV )

{

    measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

    TI_INT32 i;

    /* sanity cehcking */

    if ( NULL == hMeasurementSRV )

    {

        return;

    }

    /* release state machine */

    if ( NULL != pMeasurementSRV->SM )

    {

        fsm_Unload( pMeasurementSRV->hOS, pMeasurementSRV->SM );

    }

    /* release timers */

    for ( i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++ )

    {

        if (pMeasurementSRV->hRequestTimer[i])

        {

            tmr_DestroyTimer (pMeasurementSRV->hRequestTimer[i]);

        }

    }

    if (pMeasurementSRV->hStartStopTimer)

    {

        tmr_DestroyTimer (pMeasurementSRV->hStartStopTimer);

    }

    /* release object space */

    os_memoryFree( pMeasurementSRV->hOS, (TI_HANDLE)pMeasurementSRV, sizeof(measurementSRV_t));

}

/**

 * \author Ronen Kalish\n

 * \date 09-November-2005\n

 * \brief Starts a measurement operation.\n

 *

 * Function Scope \e Public.\n

 * \param hMacServices - handle to the MacServices object.\n

 * \param pMsrRequest - a structure containing measurement parameters.\n

 * \param timeToRequestexpiryMs - the time (in milliseconds) the measurement SRV has to start the request.\n

 * \param cmdResponseCBFunc - callback function to used for command response.\n

 * \param cmdResponseCBObj - handle to pass to command response CB.\n

 * \param cmdCompleteCBFunc - callback function to be used for command complete.\n

 * \param cmdCompleteCBObj - handle to pass to command complete CB.\n

 * \return TI_OK if successful (various, TBD codes if not).\n

 */ 

TI_STATUS MacServices_measurementSRV_startMeasurement( TI_HANDLE hMacServices, 

                                                       TMeasurementRequest* pMsrRequest,

													   TI_UINT32 timeToRequestExpiryMs,

                                                       TCmdResponseCb cmdResponseCBFunc,

                                                       TI_HANDLE cmdResponseCBObj,

                                                       TMeasurementSrvCompleteCb cmdCompleteCBFunc,

                                                       TI_HANDLE cmdCompleteCBObj )

{

    measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)((MacServices_t*)hMacServices)->hMeasurementSRV;

	TI_INT32 i;

#ifdef TI_DBG

TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Received measurement request.\n");

	measurementSRVPrintRequest( (TI_HANDLE)pMeasurementSRV, pMsrRequest );

TRACE3( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "time to expiry: %d ms, cmd response CB: 0x%x, cmd response handle: 0x%x\n",							  timeToRequestExpiryMs,							  cmdResponseCBFunc,							  cmdResponseCBObj);

TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "cmd complete CB: 0x%x, cmd complete handle: 0x%x\n",							  cmdCompleteCBFunc,							  cmdCompleteCBObj);

#endif

	/* mark that request is in progress */

    pMeasurementSRV->bInRequest = TI_TRUE;

	/* mark to send NULL data when exiting driver mode (can be changed to TI_FALSE

	   only when explictly stopping the measurement */

	pMeasurementSRV->bSendNullDataWhenExitPs = TI_TRUE;

    /* Nullify return status */

    pMeasurementSRV->returnStatus = TI_OK;

    /* copy request parameters */

    os_memoryCopy (pMeasurementSRV->hOS, 

                   (void *)&pMeasurementSRV->msrRequest, 

                   (void *)pMsrRequest, 

                   sizeof(TMeasurementRequest));

	/* Mark the current time stamp and the duration to start to cehck expiry later */

	pMeasurementSRV->requestRecptionTimeStampMs = os_timeStampMs( pMeasurementSRV->hOS );

	pMeasurementSRV->timeToRequestExpiryMs = timeToRequestExpiryMs;

	/* copy callbacks */

    pMeasurementSRV->commandResponseCBFunc = cmdResponseCBFunc;

    pMeasurementSRV->commandResponseCBObj = cmdResponseCBObj;

    pMeasurementSRV->measurmentCompleteCBFunc = cmdCompleteCBFunc;

    pMeasurementSRV->measurementCompleteCBObj = cmdCompleteCBObj;

	/* initialize reply */

	pMeasurementSRV->msrReply.numberOfTypes = pMsrRequest->numberOfTypes;

	for ( i = 0; i < pMsrRequest->numberOfTypes; i++ )

	{

		pMeasurementSRV->msrReply.msrTypes[ i ].msrType = pMeasurementSRV->msrRequest.msrTypes[ i ].msrType;

		pMeasurementSRV->msrReply.msrTypes[ i ].status = TI_OK;

	}

	/* nullify the pending CBs bitmap */

	pMeasurementSRV->pendingParamCBs = 0;

    /* send a start measurement event to the SM */

    measurementSRVSM_SMEvent( (TI_HANDLE)pMeasurementSRV, &(pMeasurementSRV->SMState), 

                              MSR_SRV_EVENT_MEASURE_START_REQUEST );

    /* mark that request has been sent */

    pMeasurementSRV->bInRequest = TI_FALSE;

    return pMeasurementSRV->returnStatus;

}

/**

 * \author Ronen Kalish\n

 * \date 09-November-2005\n

 * \brief Stops a measurement operation in progress.\n

 *

 * Function Scope \e Public.\n

 * \param hMacServices - handle to the MacServices object.\n

 * \param bSendNullData - whether to send NULL data when exiting driver mode.\n

 * \param cmdResponseCBFunc - callback function to used for command response.\n

 * \param cmdResponseCBObj - handle to pass to command response CB.\n

 * \return TI_OK if successful (various, TBD codes if not).\n

 */

TI_STATUS MacServices_measurementSRV_stopMeasurement( TI_HANDLE hMacServices,

													  TI_BOOL bSendNullData,

                                                      TCmdResponseCb cmdResponseCBFunc,

                                                      TI_HANDLE cmdResponseCBObj )

{

    measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)((MacServices_t*)hMacServices)->hMeasurementSRV;

TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Received measurement stop request.\n");

TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "Send null data:, cmd response CB: 0x%x, cmd response handle: 0x%x\n",							  cmdResponseCBFunc,							  cmdResponseCBObj);

	/* store callbacks */

    pMeasurementSRV->commandResponseCBFunc = cmdResponseCBFunc;

    pMeasurementSRV->commandResponseCBObj = cmdResponseCBObj;

	/* store NULL data indication */

	pMeasurementSRV->bSendNullDataWhenExitPs = bSendNullData;

    /* mark that current return status is TI_OK */

    pMeasurementSRV->returnStatus = TI_OK;

	/* mark that a stop request is in progress */

	pMeasurementSRV->bInRequest = TI_TRUE;

    /* send a stop event to the SM */

    measurementSRVSM_SMEvent( (TI_HANDLE)pMeasurementSRV, &(pMeasurementSRV->SMState),

                              MSR_SRV_EVENT_MEASURE_STOP_REQUEST );

	/*mark that stop request has completed */

	pMeasurementSRV->bInRequest = TI_FALSE;

    return pMeasurementSRV->returnStatus;

}

/**

 * \author Ronen Kalish\n

 * \date 09-November-2005\n

 * \brief Notifies the measurement SRV of a FW reset (recovery).\n

 *

 * Function Scope \e Public.\n

 * \param hMacServices - handle to the MacServices object.\n

 */

void MacServices_measurementSRV_FWReset( TI_HANDLE hMacServices )

{

    measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)((MacServices_t*)hMacServices)->hMeasurementSRV;

    TI_INT32 i;

TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Received FW reset indication.\n");

	/* if a timer is running, stop it */

    if (pMeasurementSRV->bStartStopTimerRunning)

    {

        tmr_StopTimer (pMeasurementSRV->hStartStopTimer);

        pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;

    }

    for (i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++)

    {

        if (pMeasurementSRV->bRequestTimerRunning[i])

        {

            tmr_StopTimer (pMeasurementSRV->hRequestTimer[i]);

            pMeasurementSRV->bRequestTimerRunning[i] = TI_FALSE;

        }

    }

    /* change SM state to idle */

    pMeasurementSRV->SMState = MSR_SRV_STATE_IDLE;

}

/** 

 * \author Ronen Kalish\n

 * \date 09-November-2005\n

 * \brief callback function used by the power manager to notify driver mode result

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSRV - handle to the measurement SRV object.\n

 * \param PSMode - the power save mode the STA is currently in.\n

 * \param psStatus - the power save request status.\n

 */

void MacServices_measurementSRV_powerSaveCB( TI_HANDLE hMeasurementSRV, TI_UINT8 PSMode, TI_UINT8 psStatus )

{

    measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Power save SRV CB called. PS mode:%d status: %d\n", PSMode, psStatus);

	/* if driver mode entry succeedded */

    if ( ENTER_POWER_SAVE_SUCCESS == psStatus )

    {

        TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": PS successful.\n");

        /* send a RIVER_MODE_SUCCESS event */

        measurementSRVSM_SMEvent( (TI_HANDLE)pMeasurementSRV, &(pMeasurementSRV->SMState), 

                                  MSR_SRV_EVENT_DRIVER_MODE_SUCCESS );

    }

    /* driver mode entry failed */

    else

    {

        TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": PS failed, status %d.\n", psStatus);

        /* Set the return status to TI_NOK */

        pMeasurementSRV->returnStatus = (TI_STATUS)psStatus;

        /* send a DRIVER_MODE_FAILURE event */

        measurementSRVSM_SMEvent( (TI_HANDLE)pMeasurementSRV, &(pMeasurementSRV->SMState), 

								  MSR_SRV_EVENT_DRIVER_MODE_FAILURE );

    }

}

/** 

 * \author Ronen Kalish\n

 * \date 14-November-2005\n

 * \brief callback function used by the HAL for measure start event (sent when the FW 

 * has started measurement operation, i.e. switched channel and changed RX filters).\n

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSRV - handle to the measurement SRV object.\n

 */

void MacServices_measurementSRV_measureStartCB( TI_HANDLE hMeasurementSRV )

{

    measurementSRV_t *pMeasurementSRV  = (measurementSRV_t*)hMeasurementSRV;

    TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": measure start CB called.\n");

	/* stop the FW guard timer */

    tmr_StopTimer (pMeasurementSRV->hStartStopTimer);

	pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;

	/* clear the CB function, so that it won't be called on stop as well! */

	pMeasurementSRV->commandResponseCBFunc = NULL;

	pMeasurementSRV->commandResponseCBObj = NULL;

    measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState), 

							  MSR_SRV_EVENT_START_SUCCESS );

}

/** 

 * \author Ronen Kalish\n

 * \date 14-November-2005\n

 * \brief callback function used by the HAL for measure stop event (sent when the FW 

 * has finished measurement operation, i.e. switched channel to serving channel and changed back RX filters).\n

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSRV - handle to the measurement SRV object.\n

 */

void MacServices_measurementSRV_measureCompleteCB( TI_HANDLE hMeasurementSRV )

{

    measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

    TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": measure complete CB called.\n");

	/* stop the FW guard timer */

    tmr_StopTimer (pMeasurementSRV->hStartStopTimer);

	pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;

    measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState), 

							  MSR_SRV_EVENT_STOP_COMPLETE );

}

/** 

 * \author Ronen Kalish\n

 * \date 14-November-2005\n

 * \brief callback function used by the HAL for AP discovery stop event (sent when the FW 

 * has finished AP discovery operation).\n

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSRV - handle to the measurement SRV object.\n

 */

void MacServices_measurementSRV_apDiscoveryCompleteCB( TI_HANDLE hMeasurementSRV )

{

#ifdef TI_DBG

    measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

    TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": AP Discovery complete CB called.\n");

#endif /* TI_DBG */

}

/**

 * \author Ronen Kalish\n

 * \date 14-November-2005\n