/*

 * MeasurementSrvSM.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 state machine implementation.

 *  \author Ronen Kalish

 *  \date 13-November-2005

 */

#define __FILE_ID__  FILE_ID_112

#include "osApi.h"

#include "report.h"

#include "MeasurementSrvSM.h"

#include "MeasurementSrv.h"

#include "PowerSrv_API.h"

#include "timer.h"

#include "fsm.h"

#include "TWDriverInternal.h"

#include "CmdBld.h"

TI_STATUS actionUnexpected( TI_HANDLE hMeasurementSrv );

TI_STATUS actionNop( TI_HANDLE hMeasurementSrv );

static void measurementSRVSM_requestMeasureStartResponseCB(TI_HANDLE hMeasurementSRV, TI_UINT16 uMboxStatus);

/**

 * \author Ronen Kalish\n

 * \date 08-November-2005\n

 * \brief Initialize the measurement SRV SM.\n

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSrv - handle to the Measurement SRV object.\n

 * \return TI_OK if successful, TI_NOK otherwise.\n

 */

TI_STATUS measurementSRVSM_init( TI_HANDLE hMeasurementSRV )

{

   measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

    fsm_actionCell_t    smMatrix[ MSR_SRV_NUM_OF_STATES ][ MSR_SRV_NUM_OF_EVENTS ] =

    {

        /* next state and actions for IDLE state */

        {   

            {MSR_SRV_STATE_WAIT_FOR_DRIVER_MODE, measurementSRVSM_requestDriverMode},     /*"MESSURE_START_REQUEST"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"DRIVER_MODE_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"DRIVER_MODE_FAILURE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"START_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"START_FAILURE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"ALL_TYPES_COMPLETE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"STOP_COMPLETE"*/

            {MSR_SRV_STATE_IDLE, measurementSRVSRVSM_dummyStop}                           /*"MEASURE_STOP_REQUEST"*/

        },

        /* next state and actions for WAIT_FOR_DRIVER_MODE state */

        {   

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"MESSURE_START_REQUEST"*/

            {MSR_SRV_STATE_WAIT_FOR_MEASURE_START, measurementSRVSM_requestMeasureStart}, /*"DRIVER_MODE_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, measurementSRVSM_DriverModeFailure},                     /*"DRIVER_MODE_FAILURE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"START_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"START_FAILURE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"ALL_TYPES_COMPLETE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"STOP_COMPLETE"*/

            {MSR_SRV_STATE_IDLE, measurementSRVSM_stopFromWaitForDriverMode}              /*"MEASURE_STOP_REQUEST"*/

        },

        /* next state and actions for WAIT_FOR_MEASURE_START state */

        {    

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"MESSURE_START_REQUEST"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"DRIVER_MODE_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"DRIVER_MODE_FAILURE"*/

            {MSR_SRV_STATE_MEASURE_IN_PROGRESS, measurementSRVSM_startMeasureTypes},      /*"START_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, measurementSRVSM_measureStartFailure},                   /*"START_FAILURE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"ALL_TYPES_COMPLETE"*/

            {MSR_SRV_STATE_IDLE, measurementSRVSM_completeMeasure},                       /*"STOP_COMPLETE"*/

            {MSR_SRV_STATE_WAIT_FOR_MEASURE_STOP, measurementSRVSM_stopFromWaitForMeasureStart}

                                                                                          /*"MEASURE_STOP_REQUEST"*/

        },

        /* next state and actions for MEASURE_IN_PROGRESS state */

        {   

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"MESSURE_START_REQUEST"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"DRIVER_MODE_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"DRIVER_MODE_FAILURE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"START_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"START_FAILURE"*/

            {MSR_SRV_STATE_WAIT_FOR_MEASURE_STOP, measurementSRVSM_requestMeasureStop},   /*"ALL_TYPES_COMPLETE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"STOP_COMPLETE"*/

            {MSR_SRV_STATE_WAIT_FOR_MEASURE_STOP, measurementSRVSM_stopFromMeasureInProgress}

                                                                                          /*"MEASURE_STOP_REQUEST"*/

        },

        /* next state and actions for WAIT_FOR_MEASURE_STOP state */

        {   

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"MESSURE_START_REQUEST"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"DRIVER_MODE_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"DRIVER_MODE_FAILURE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"START_SUCCESS"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"START_FAILURE"*/

            {MSR_SRV_STATE_IDLE, actionUnexpected},                                       /*"ALL_TYPES_COMPLETE"*/

            {MSR_SRV_STATE_IDLE, measurementSRVSM_completeMeasure},                       /*"STOP_COMPLETE"*/

            {MSR_SRV_STATE_WAIT_FOR_MEASURE_STOP, measurementSRVSRVSM_dummyStop}          /*"MEASURE_STOP_REQUEST"*/

        }

    };

    /* initialize current state */

    pMeasurementSRV->SMState = MSR_SRV_STATE_IDLE;

    /* configure the state machine */

    return fsm_Config( pMeasurementSRV->SM, (fsm_Matrix_t)smMatrix, 

                       (TI_UINT8)MSR_SRV_NUM_OF_STATES, (TI_UINT8)MSR_SRV_NUM_OF_EVENTS, 

                       (fsm_eventActivation_t)measurementSRVSM_SMEvent, pMeasurementSRV->hOS );

}

/**

 * \author Ronen Kalish\n

 * \date 08-November-2005\n

 * \brief Processes an event.\n

 *

 * Function Scope \e Public.\n

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

 * \param currentState - the current scan SRV SM state.\n

 * \param event - the event to handle.\n

 * \return TI_OK if successful, TI_NOK otherwise.\n

 */

TI_STATUS measurementSRVSM_SMEvent( TI_HANDLE hMeasurementSrv, measurements_SRVSMStates_e* currentState, 

                                    measurement_SRVSMEvents_e event )

{

    measurementSRV_t *pMeasurementSRV = (measurementSRV_t *)hMeasurementSrv;

    TI_STATUS status = TI_OK;

    TI_UINT8 nextState;

    /* obtain the next state */

    status = fsm_GetNextState( pMeasurementSRV->SM, (TI_UINT8)*currentState, (TI_UINT8)event, &nextState );

    if ( status != TI_OK )

    {

        TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "measurementSRVSM_SMEvent: State machine error, failed getting next state\n");

        return TI_NOK;

    }

    /* report the move */

	TRACE3( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "measurementSRVSM_SMEvent: <currentState = %d, event = %d> --> nextState = %d\n", currentState, event, nextState);

    /* move */

    return fsm_Event( pMeasurementSRV->SM, (TI_UINT8*)currentState, (TI_UINT8)event, hMeasurementSrv );

}

/**

 * \author Ronen Kalish\n

 * \date 08-November-2005\n

 * \brief Handle a MEASURE_START_REQUEST event by requesting driver mode.\n

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSrv - handle to the Measurement SRV object.\n

 * \return always TI_OK.\n

 */

TI_STATUS measurementSRVSM_requestDriverMode( TI_HANDLE hMeasurementSRV )

{

    measurementSRV_t    *pMeasurementSRV  = (measurementSRV_t*)hMeasurementSRV;

    TI_STATUS           PSStatus;

    TTwdParamInfo       paramInfo;

    /* get the current channel */

    paramInfo.paramType = TWD_CURRENT_CHANNEL_PARAM_ID;

    cmdBld_GetParam (pMeasurementSRV->hCmdBld, &paramInfo);

    /* check if the request is on the serving channel */

    if ( paramInfo.content.halCtrlCurrentChannel == pMeasurementSRV->msrRequest.channel )

    {

        /* Switch Power Save SRV to driver mode w/o changing power save mode*/

        PSStatus = powerSrv_ReservePS( pMeasurementSRV->hPowerSaveSRV, POWER_SAVE_KEEP_CURRENT,

                                       TI_TRUE, hMeasurementSRV, MacServices_measurementSRV_powerSaveCB );

    }

    else

    {

        /* Switch Power Save SRV to driver mode with PS mode */      

        PSStatus = powerSrv_ReservePS( pMeasurementSRV->hPowerSaveSRV, POWER_SAVE_ON,

                                       TI_TRUE, hMeasurementSRV, MacServices_measurementSRV_powerSaveCB );

    }

    switch (PSStatus)

    {

        case POWER_SAVE_802_11_IS_CURRENT:

            TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Driver mode entered successfully\n");

            /* send a power save success event */

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

                                             MSR_SRV_EVENT_DRIVER_MODE_SUCCESS );

        case POWER_SAVE_802_11_PENDING:

        case TI_OK:

            TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Driver mode pending\n");

            break;

        default: /* Error */

            TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": Error %d when requesting driver mode\n",PSStatus);

            /* Set the return status to TI_NOK */

            pMeasurementSRV->returnStatus = PSStatus;

            /* send a power save failure event */

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

                                      MSR_SRV_EVENT_DRIVER_MODE_FAILURE );

            break;

    }

    return TI_OK;

}

/**

 * \author Ronen Kalish\n

 * \date 08-November-2005\n

 * \brief Handle a DRIVER_MODE_SUCCESS event by sending start measure command to the FW.\n

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSrv - handle to the Measurement SRV object.\n

 * \return always TI_OK.\n

 */

TI_STATUS measurementSRVSM_requestMeasureStart( TI_HANDLE hMeasurementSRV )

{

    measurementSRV_t     *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

    TMeasurementParams    pMeasurementCmd;

    TI_STATUS             status;

    TI_UINT32                currentTime = os_timeStampMs( pMeasurementSRV->hOS );

    /* check if request time has expired (note: timer wrap-around is also handled)*/

    if ( (pMeasurementSRV->requestRecptionTimeStampMs + pMeasurementSRV->timeToRequestExpiryMs)

                    < currentTime )

    {

        TI_INT32 i;

        TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": request time has expired, request expiry time:%d, current time:%d\n", pMeasurementSRV->requestRecptionTimeStampMs + pMeasurementSRV->timeToRequestExpiryMs, currentTime);

        /* mark that all measurement types has failed */

        for ( i = 0; i < pMeasurementSRV->msrRequest.numberOfTypes; i++ )

        {

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

        }

        /* send a measurement complete event */

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

                                  MSR_SRV_EVENT_STOP_COMPLETE );

        return TI_OK;

    }

    pMeasurementCmd.channel = pMeasurementSRV->msrRequest.channel;

    pMeasurementCmd.band = pMeasurementSRV->msrRequest.band;

    pMeasurementCmd.duration = 0; /* Infinite */

    pMeasurementCmd.eTag = pMeasurementSRV->msrRequest.eTag;

    if ( measurementSRVIsBeaconMeasureIncluded( hMeasurementSRV ))

    {  /* Beacon Measurement is one of the types */

		/* get the current channel */

		TTwdParamInfo	paramInfo;

		paramInfo.paramType = TWD_CURRENT_CHANNEL_PARAM_ID;

		cmdBld_GetParam (pMeasurementSRV->hCmdBld, &paramInfo);

		pMeasurementCmd.ConfigOptions = RX_CONFIG_OPTION_FOR_MEASUREMENT; 

		/* check if the request is on the serving channel */

		if ( paramInfo.content.halCtrlCurrentChannel == pMeasurementSRV->msrRequest.channel )

		{

			/* Set the RX Filter to the join one, so that any packets will 

            be received on the serving channel - beacons and probe requests for

			the measurmenet, and also data (for normal operation) */

            pMeasurementCmd.FilterOptions = RX_FILTER_OPTION_JOIN;

		}

		else

		{

			/* not on the serving channle - only beacons and rpobe responses are required */

			pMeasurementCmd.FilterOptions = RX_FILTER_OPTION_DEF_PRSP_BCN; 

		}

    }

    else

    {  /* No beacon measurement - use the current RX Filter */

        pMeasurementCmd.ConfigOptions = 0xffffffff;

        pMeasurementCmd.FilterOptions = 0xffffffff;

    }

    /* Send start measurement command */

    status = cmdBld_CmdMeasurement (pMeasurementSRV->hCmdBld,

                                    &pMeasurementCmd,

                                    (void *)measurementSRVSM_requestMeasureStartResponseCB, 

                                    pMeasurementSRV);

    if ( TI_OK != status )

    {

        TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": Failed to send measurement start command, statud=%d,\n", status);

        /* keep the faulty return status */

        pMeasurementSRV->returnStatus = status;

        /* send a measurement start fail event */

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

                                         MSR_SRV_EVENT_START_FAILURE );

    }

    TRACE6( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": measure start command sent. Params:\n channel=%d, band=%d, duration=%d, \n configOptions=0x%x, filterOptions=0x%x, status=%d, \n", pMeasurementCmd.channel, pMeasurementCmd.band, pMeasurementCmd.duration, pMeasurementCmd.ConfigOptions, pMeasurementCmd.FilterOptions, status);

    /* start the FW guard timer */

    pMeasurementSRV->bStartStopTimerRunning = TI_TRUE;

    tmr_StartTimer (pMeasurementSRV->hStartStopTimer,

                    MacServices_measurementSRV_startStopTimerExpired,

                    (TI_HANDLE)pMeasurementSRV,

                    MSR_FW_GUARD_TIME,

                    TI_FALSE);

    return TI_OK;

}

/**

 * \author Ronen Kalish\n

 * \date 08-November-2005\n

 * \brief Handle a START_SUCCESS event by starting different measure types and setting timers.\n

 *

 * Function Scope \e Public.\n

 * \param hMeasurementSrv - handle to the Measurement SRV object.\n

 * \return always TI_OK.\n

 */

TI_STATUS measurementSRVSM_startMeasureTypes( TI_HANDLE hMeasurementSRV )

{

    measurementSRV_t      *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;

    TI_UINT8                 requestIndex, rangeIndex;

    TI_INT8                  rangeUpperBound;

    TTwdParamInfo         tTwdParam;

    TI_STATUS             status;

    TNoiseHistogram       pNoiseHistParams;

    TApDiscoveryParams    pApDiscoveryParams;

    TI_UINT32                currentTime = os_timeStampMs( pMeasurementSRV->hOS );

    /* check if request time has expired (note: timer wrap-around is also handled)*/

    if ( (pMeasurementSRV->requestRecptionTimeStampMs + pMeasurementSRV->timeToRequestExpiryMs)

                    < currentTime )

    {

        TI_INT32 i;

        TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": request time has expired, request expiry time:%d, current time:%d\n", pMeasurementSRV->requestRecptionTimeStampMs + pMeasurementSRV->timeToRequestExpiryMs, currentTime);

        /* mark that all measurement types has failed */

        for ( i = 0; i < pMeasurementSRV->msrRequest.numberOfTypes; i++ )

        {

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

        }

        /* send a measurement complete event */

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

                                  MSR_SRV_EVENT_ALL_TYPES_COMPLETE );

        return TI_OK;

    }

    /* Going over all request types that should be executed in parallel 

    to start their timers and execute the measurement */

    for ( requestIndex = 0; requestIndex < pMeasurementSRV->msrRequest.numberOfTypes ; requestIndex++ )

    {

        switch (pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].msrType)

        {

        case MSR_TYPE_CCA_LOAD_MEASUREMENT:    

            /* Clearing the Medium Occupancy Register */

            tTwdParam.paramType = TWD_MEDIUM_OCCUPANCY_PARAM_ID;

            tTwdParam.content.interogateCmdCBParams.fCb = (void *)MacServices_measurementSRV_dummyChannelLoadParamCB;

            tTwdParam.content.interogateCmdCBParams.hCb = hMeasurementSRV;

            tTwdParam.content.interogateCmdCBParams.pCb = 

                    (TI_UINT8*)&pMeasurementSRV->mediumOccupancyResults;

            status = cmdBld_GetParam (pMeasurementSRV->hCmdBld, &tTwdParam);

            if( TI_OK == status  )

            {

                TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Medium Usage has been nullified, starting timer.\n");

                /* Start Timer */

                tmr_StartTimer (pMeasurementSRV->hRequestTimer[requestIndex],

                                MacServices_measurementSRV_requestTimerExpired,

                                (TI_HANDLE)pMeasurementSRV,

                                pMeasurementSRV->msrRequest.msrTypes[requestIndex].duration, 

                                TI_FALSE);

                pMeasurementSRV->bRequestTimerRunning[requestIndex] = TI_TRUE;

            }

            else

            {

                TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": TWD_GetParam (for channel load) returned status %d\n", status);

            }

            break;

        case MSR_TYPE_NOISE_HISTOGRAM_MEASUREMENT:

            /* Set Noise Histogram Cmd Params */

            pNoiseHistParams.cmd = START_NOISE_HIST;

            pNoiseHistParams.sampleInterval = DEF_SAMPLE_INTERVAL;

            os_memoryZero( pMeasurementSRV->hOS, &(pNoiseHistParams.ranges[0]), MEASUREMENT_NOISE_HISTOGRAM_NUM_OF_RANGES );

            /* Set Ranges */

            /* (-87) - First Range's Upper Bound */

            rangeUpperBound = -87;

            /* Previously we converted from RxLevel to dBm - now this isn't necessary */

            /* rangeUpperBound = TWD_convertRSSIToRxLevel( pMeasurementSRV->hTWD, -87); */

            for(rangeIndex = 0; rangeIndex < MEASUREMENT_NOISE_HISTOGRAM_NUM_OF_RANGES -1; rangeIndex++)

            {

                if(rangeUpperBound > 0)

                {

                    pNoiseHistParams.ranges[rangeIndex] = 0;

                }

                else

                {               

                    pNoiseHistParams.ranges[rangeIndex] = rangeUpperBound;

                }         

                rangeUpperBound += 5; 

            }

            pNoiseHistParams.ranges[rangeIndex] = 0xFE;

            /* Print for Debug */

            TRACE8(pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ":Noise histogram Measurement Ranges:\n%d %d %d %d %d %d %d %d\n", (TI_INT8) pNoiseHistParams.ranges[0], (TI_INT8) pNoiseHistParams.ranges[1], (TI_INT8) pNoiseHistParams.ranges[2], (TI_INT8) pNoiseHistParams.ranges[3], (TI_INT8) pNoiseHistParams.ranges[4], (TI_INT8) pNoiseHistParams.ranges[5], (TI_INT8) pNoiseHistParams.ranges[6], (TI_INT8) pNoiseHistParams.ranges[7]);

            /* Send a Start command to the FW */

            status = cmdBld_CmdNoiseHistogram (pMeasurementSRV->hCmdBld, &pNoiseHistParams, NULL, NULL);

            if ( TI_OK == status )

            {

                /* Print for Debug */

                TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Sent noise histogram command. Starting timer\n");

                /* Start Timer */

                tmr_StartTimer (pMeasurementSRV->hRequestTimer[requestIndex],

                                MacServices_measurementSRV_requestTimerExpired,

                                (TI_HANDLE)pMeasurementSRV,

                                pMeasurementSRV->msrRequest.msrTypes[requestIndex].duration, 

                                TI_FALSE);

                pMeasurementSRV->bRequestTimerRunning[requestIndex] = TI_TRUE;

            }

            else

            {

                TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": TWD_NoiseHistogramCmd returned status %d\n", status);

            }

            break;

        case MSR_TYPE_BEACON_MEASUREMENT:

            /* set all parameters in the AP discovery command */

            pApDiscoveryParams.scanDuration = pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].duration * 1000; 

            pApDiscoveryParams.numOfProbRqst = 1;

            pApDiscoveryParams.txdRateSet = HW_BIT_RATE_1MBPS;

            pApDiscoveryParams.ConfigOptions = RX_CONFIG_OPTION_FOR_MEASUREMENT;

            pApDiscoveryParams.FilterOptions = RX_FILTER_OPTION_DEF_PRSP_BCN;

            pApDiscoveryParams.txPowerDbm = pMeasurementSRV->msrRequest.txPowerDbm;

            pApDiscoveryParams.scanOptions = SCAN_ACTIVE; /* both scan type and band are 0 for active and */

                                                          /* 2.4 GHz, respectively, but 2.4 is not defined */

            /* band determined at the initiate measurement command not at that structure */

            /* scan mode go into the scan option field */

            if ( MSR_SCAN_MODE_PASSIVE == pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].scanMode )

            {

                pApDiscoveryParams.scanOptions |= SCAN_PASSIVE;

            }

            /* Send AP Discovery command */

            status = cmdBld_CmdApDiscovery (pMeasurementSRV->hCmdBld, &pApDiscoveryParams, NULL, NULL);

            if ( TI_OK == status )

            {

                TRACE7( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": AP discovery command sent. Params:\n scanDuration=%d, scanOptions=%d, numOfProbRqst=%d, txdRateSet=%d, txPowerDbm=%d, configOptions=%d, filterOptions=%d\n Starting timer...\n", pApDiscoveryParams.scanDuration, pApDiscoveryParams.scanOptions, pApDiscoveryParams.numOfProbRqst, pApDiscoveryParams.txdRateSet, pApDiscoveryParams.txPowerDbm, pApDiscoveryParams.ConfigOptions, pApDiscoveryParams.FilterOptions);

                /* Start Timer */

                tmr_StartTimer (pMeasurementSRV->hRequestTimer[requestIndex],

                                MacServices_measurementSRV_requestTimerExpired,

                                (TI_HANDLE)pMeasurementSRV,

                                pMeasurementSRV->msrRequest.msrTypes[requestIndex].duration, 

                                TI_FALSE);

                pMeasurementSRV->bRequestTimerRunning[ requestIndex ] = TI_TRUE;

            }

            else

            {

                TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": TWD_ApDiscoveryCmd returned status %d\n", status);

            }

            break;

        case MSR_TYPE_BASIC_MEASUREMENT: /* not supported in current implemntation */

        case MSR_TYPE_FRAME_MEASUREMENT: /* not supported in current implemntation */

        default:

            TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": Measurement type %d is not supported\n", pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].msrType);

            break;

        }        

    }

    /* if no measurement types are running, sen al types complete event.

       This can happen if all types failed to start */

    if ( TI_TRUE == measurementSRVIsMeasurementComplete( hMeasurementSRV ))

    {

        /* send the event */

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

                                  MSR_SRV_EVENT_ALL_TYPES_COMPLETE );

    }