--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/TWD/MacServices/MeasurementSrv.c Tue Jun 29 12:34:26 2010 +0100
@@ -0,0 +1,1085 @@
+/*
+ * 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
+ * \brief called when a measurement FW guard timer expires.
+ *
+ * Function Scope \e Public.\n
+ * \param hMeasuremntSRV - handle to the measurement SRV object.\n
+ * \param bTwdInitOccured - Indicates if TWDriver recovery occured since timer started.\n
+ */
+void MacServices_measurementSRV_startStopTimerExpired (TI_HANDLE hMeasurementSRV, TI_BOOL bTwdInitOccured)
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_INT32 i;
+
+ TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": FW guard timer expired.\n");
+
+ /* mark that the FW guard timer is not running */
+ pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;
+
+ /* if any other timer is running - stop it */
+ 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;
+
+ /*Error Reporting - call the centeral error function in the health monitor if a request for measurement was faield*/
+ pMeasurementSRV->failureEventFunc(pMeasurementSRV->failureEventObj ,MEASUREMENT_FAILURE);
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 15-November-2005\n
+ * \brief called when a measurement type timer expires.\n
+ *
+ * Function Scope \e Public.\n
+ * \param hMeasuremntSRV - handle to the measurement SRV object.\n
+ * \param bTwdInitOccured - Indicates if TWDriver recovery occured since timer started.\n
+ */
+void MacServices_measurementSRV_requestTimerExpired (TI_HANDLE hMeasurementSRV, TI_BOOL bTwdInitOccured)
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_INT32 requestIndex;
+
+ /* find the expired measurement type */
+ requestIndex = measurementSRVFindMinDuration( hMeasurementSRV );
+ if ( -1 == requestIndex )
+ {
+ /* indicates we can't find the request in the requets array. Shouldn't happen, but nothing to do */
+TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": Request timer expired and request index from findMinDuration is -1?!?");
+ return;
+ }
+
+TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": request timer expired, request index: %d.\n", requestIndex);
+
+ /* mark that the timer is not running and that this request has completed */
+ pMeasurementSRV->bRequestTimerRunning[ requestIndex ] = TI_FALSE;
+
+ /* collect results and send stop command if necessary */
+ switch (pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].msrType)
+ {
+ case MSR_TYPE_BEACON_MEASUREMENT:
+ measurementSRVHandleBeaconMsrComplete( hMeasurementSRV, requestIndex );
+ break;
+
+ case MSR_TYPE_CCA_LOAD_MEASUREMENT:
+ measurementSRVHandleChannelLoadComplete( hMeasurementSRV, requestIndex );
+ break;
+
+ case MSR_TYPE_NOISE_HISTOGRAM_MEASUREMENT:
+ measurementSRVHandleNoiseHistogramComplete( hMeasurementSRV, requestIndex );
+ break;
+
+ /* used here to avoid compilation warning only, does nothing */
+ case MSR_TYPE_BASIC_MEASUREMENT:
+ case MSR_TYPE_FRAME_MEASUREMENT:
+ case MSR_TYPE_MAX_NUM_OF_MEASURE_TYPES:
+ default:
+TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": measure type %d not supported for request %d\n", pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].msrType, requestIndex);
+ break;
+ }
+
+ /* if no measurement are running and no CBs are pending, send ALL TYPES COMPLETE event */
+ if ( TI_TRUE == measurementSRVIsMeasurementComplete( hMeasurementSRV ))
+ {
+ /* send the event */
+ measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState),
+ MSR_SRV_EVENT_ALL_TYPES_COMPLETE );
+ }
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 13-November-2005\n
+ * \brief Checks whether a beacon measurement is part of current measurement request
+ *
+ * Function Scope \e Private.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \return TI_TRUE if a beacon measurement is part of current request, TI_FALSE otherwise.\n
+ */
+TI_BOOL measurementSRVIsBeaconMeasureIncluded( TI_HANDLE hMeasurementSRV )
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_INT32 i;
+
+ for ( i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++ )
+ {
+ if ( MSR_TYPE_BEACON_MEASUREMENT == pMeasurementSRV->msrRequest.msrTypes[ i ].msrType )
+ {
+ return TI_TRUE;
+ }
+ }
+ return TI_FALSE;
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 15-November-2005\n
+ * \brief Finds the index for the measurement request with the shortest period
+ * (the one that has now completed).\n
+ *
+ * Function Scope \e Private.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \return index of the measurement request with the shortest duration.\n
+ */
+TI_INT32 measurementSRVFindMinDuration( TI_HANDLE hMeasurementSRV )
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_INT32 i, minIndex;
+ TI_UINT32 minValue;
+
+
+ minIndex = minValue = 0; /* minIndex is initialized only to avoid compilation warning! */
+
+ /* find the index with the minimum duration */
+ for ( i = 0; i < pMeasurementSRV->msrRequest.numberOfTypes; i++ )
+ {
+ if ( TI_TRUE == pMeasurementSRV->bRequestTimerRunning[ i ] )
+ {
+ if ( (0 == minValue) ||
+ (pMeasurementSRV->msrRequest.msrTypes[ i ].duration < minValue))
+ {
+ minValue = pMeasurementSRV->msrRequest.msrTypes[ i ].duration;
+ minIndex = i;
+ }
+ }
+ }
+
+ /* if no entry with positive duration exists, return -1 */
+ if ( 0 == minValue )
+ {
+ return -1;
+ }
+ else
+ { /* otherwise, return the index of the type with the shortest duration */
+ return minIndex;
+ }
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 15-November-2005\n
+ * \brief Handles an AP discovery timer expiry, by setting necessary values in the
+ * reply struct.\n
+ *
+ * Function Scope \e Private.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \param requestIndex - index of the beacon request in the request structure.\n
+ */
+void measurementSRVHandleBeaconMsrComplete( TI_HANDLE hMeasurementSRV, TI_INT32 requestIndex )
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_INT32 status;
+
+
+TRACE0(pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Sending AP Discovery Stop to the HAL...");
+
+ /* send stop AP discovery command */
+ status = cmdBld_CmdApDiscoveryStop (pMeasurementSRV->hCmdBld, NULL, NULL);
+ if ( TI_OK != status )
+ {
+TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": status %d received from cmdBld_CmdApDiscoveryStop\n", status);
+ }
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 15-November-2005\n
+ * \brief Handles a channel load timer expiry, by requesting channel load
+ * results from the FW.\n
+ *
+ * Function Scope \e Private.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \param requestIndex - index of the channel load request in the request structure.\n
+ */
+void measurementSRVHandleChannelLoadComplete( TI_HANDLE hMeasurementSRV, TI_INT32 requestIndex )
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TTwdParamInfo tTwdParam;
+ TI_STATUS status;
+
+ /* Getting the Medium Occupancy Register */
+ tTwdParam.paramType = TWD_MEDIUM_OCCUPANCY_PARAM_ID;
+ tTwdParam.content.interogateCmdCBParams.fCb = (void *)MacServices_measurementSRV_channelLoadParamCB;
+ tTwdParam.content.interogateCmdCBParams.hCb = hMeasurementSRV;
+ tTwdParam.content.interogateCmdCBParams.pCb = (TI_UINT8*)(&(pMeasurementSRV->mediumOccupancyResults));
+ status = cmdBld_GetParam (pMeasurementSRV->hCmdBld, &tTwdParam);
+
+ if ( status != TI_OK )
+ {
+TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": whalCtrl_GetParam returned status %d\n", status);
+
+ /* mark that the specific measurment type has failed */
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
+
+ /* if all measurement types has finished, an event will be send by request timer expired */
+ }
+ else
+ {
+ /* mark that channel load param CB is pending */
+ pMeasurementSRV->pendingParamCBs |= MSR_SRV_WAITING_CHANNEL_LOAD_RESULTS;
+ }
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 15-November-2005\n
+ * \brief Handles a noise histogram timer expiry, by requesting noise histogram
+ * reaults from the FW.\n
+ *
+ * Function Scope \e Private.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \param requestIndex - index of the beacon request in the request structure.\n
+ */
+void measurementSRVHandleNoiseHistogramComplete( TI_HANDLE hMeasurementSRV, TI_INT32 requestIndex )
+{
+ measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TTwdParamInfo tTwdParam;
+ TNoiseHistogram pNoiseHistParams;
+ TI_STATUS status;
+
+ /* Set Noise Histogram Cmd Params */
+ pNoiseHistParams.cmd = STOP_NOISE_HIST;
+ pNoiseHistParams.sampleInterval = 0;
+ os_memoryZero( pMeasurementSRV->hOS, &(pNoiseHistParams.ranges[0]), MEASUREMENT_NOISE_HISTOGRAM_NUM_OF_RANGES );
+
+ /* Send a Stop command to the FW */
+ status = cmdBld_CmdNoiseHistogram (pMeasurementSRV->hCmdBld, &pNoiseHistParams, NULL, NULL);
+
+ if ( TI_OK != status )
+ {
+TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": whalCtrl_NoiseHistogramCmd returned status %d\n", status);
+
+ /* mark that the specific measurment type has failed */
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
+
+ /* if all measurement types has finished, an event will be send by request timer expired */
+ }
+
+ /* Get measurement results */
+ tTwdParam.paramType = TWD_NOISE_HISTOGRAM_PARAM_ID;
+ tTwdParam.content.interogateCmdCBParams.fCb = (void *)MacServices_measurementSRV_noiseHistCallBack;
+ tTwdParam.content.interogateCmdCBParams.hCb = hMeasurementSRV;
+ tTwdParam.content.interogateCmdCBParams.pCb = (TI_UINT8*)&pMeasurementSRV->noiseHistogramResults;
+ status = cmdBld_GetParam (pMeasurementSRV->hCmdBld, &tTwdParam);
+
+ if ( TI_OK == status )
+ {
+ /* setting On the Waitng for Noise Histogram Results Bit */
+ pMeasurementSRV->pendingParamCBs |= MSR_SRV_WAITING_NOISE_HIST_RESULTS;
+
+TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": sent noise histogram stop command.\n");
+ }
+ else
+ {
+TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": whalCtrl_GetParam returned status %d\n", status);
+
+ /* mark that the specific measurment type has failed */
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
+
+ /* if all measurement types has finished, an event will be send by request timer expired */
+ }
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 16-November-2005\n
+ * \brief Callback for channel load get param call.\n
+ *
+ * Function Scope \e Public.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \param status - the get_param call status.\n
+ * \param CB_buf - pointer to the results buffer (already on the measurement SRV object)
+ */
+void MacServices_measurementSRV_channelLoadParamCB( TI_HANDLE hMeasurementSRV, TI_STATUS status,
+ TI_UINT8* CB_buf )
+{
+ measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_UINT32 mediumUsageInMs, periodInMs;
+ TI_INT32 requestIndex;
+
+ /* when this CB is called as a result of the nulify call at the measurement beginning,
+ the handle will be NULL. In this case, nothing needs to be done. */
+ if ( NULL == hMeasurementSRV )
+ {
+ return;
+ }
+
+ TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Channel load CB called, status:%d\n", status);
+ TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "result address (reported): 0x%x, result address (assumed): 0x%x, results (reported):\n",CB_buf, &(pMeasurementSRV->mediumOccupancyResults));
+ TRACE_INFO_HEX(pMeasurementSRV->hReport, CB_buf, sizeof(TMediumOccupancy));
+
+ /* setting Off the Waitng for Channel Load Results Bit */
+ pMeasurementSRV->pendingParamCBs &= ~MSR_SRV_WAITING_CHANNEL_LOAD_RESULTS;
+
+ /* find the request index */
+ requestIndex = measurementSRVFindIndexByType( hMeasurementSRV, MSR_TYPE_CCA_LOAD_MEASUREMENT );
+ if ( -1 == requestIndex )
+ {
+ /* indicates we can't find the request in the requets array. Shouldn't happen, but nothing to do */
+ TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": request index from measurementSRVFindIndexByType is -1?!?");
+ return;
+ }
+
+ if ( (TI_OK == status) && (0 != pMeasurementSRV->mediumOccupancyResults.Period))
+ {
+ /* calculate results */
+ mediumUsageInMs = pMeasurementSRV->mediumOccupancyResults.MediumUsage / 1000;
+ periodInMs = pMeasurementSRV->mediumOccupancyResults.Period / 1000;
+
+ TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": MediumUsage = %d Period = %d\n",mediumUsageInMs, periodInMs);
+
+ if ( periodInMs <= pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].duration )
+ {
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.CCABusyFraction =
+ ( 255 * pMeasurementSRV->mediumOccupancyResults.MediumUsage ) /
+ pMeasurementSRV->mediumOccupancyResults.Period;
+ }
+ else
+ {
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.CCABusyFraction =
+ ( 255 * pMeasurementSRV->mediumOccupancyResults.MediumUsage ) /
+ (pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].duration * 1000);
+ }
+ }
+ else
+ {
+ TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": channel load failed. Status=%d, period=%d\n", status, pMeasurementSRV->mediumOccupancyResults.Period);
+
+ /* mark result status */
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
+ }
+
+ /* if no measurement are running and no CBs are pending,
+ send ALL TYPES COMPLETE event */
+ if ( TI_TRUE == measurementSRVIsMeasurementComplete( hMeasurementSRV ))
+ {
+ /* send the event */
+ measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState),
+ MSR_SRV_EVENT_ALL_TYPES_COMPLETE );
+ }
+}
+
+/**
+ * \date 03-January-2005\n
+ * \brief Dummy callback for channel load get param call. Used to clear the channel load tracker.\n
+ *
+ * Function Scope \e Public.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \param status - the get_param call status.\n
+ * \param CB_buf - pointer to the results buffer (already on the measurement SRV object)
+ */
+void MacServices_measurementSRV_dummyChannelLoadParamCB( TI_HANDLE hMeasurementSRV, TI_STATUS status,
+ TI_UINT8* CB_buf )
+{
+#ifdef TI_DBG
+ measurementSRV_t *pMeasurementSRV = (measurementSRV_t*) hMeasurementSRV;
+
+TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Dummy Channel Load callback called (status = %d)\n", status);
+#endif /* TI_DBG */
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 16-November-2005\n
+ * \brief Callback for noise histogram get param call.\n
+ *
+ * Function Scope \e Public.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \param status - the get_param call status.\n
+ * \param CB_buf - pointer to the results buffer (already on the measurement SRV object)
+ */
+void MacServices_measurementSRV_noiseHistCallBack( TI_HANDLE hMeasurementSRV, TI_STATUS status,
+ TI_UINT8* CB_buf )
+{
+ measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_UINT8 index;
+ TI_UINT32 sumOfSamples;
+ TI_INT32 requestIndex;
+
+ TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": noise histogram CB called, status: %d\n", status);
+ TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "result address (reported): 0x%x, result address (assumed): 0x%x, results (reported):\n", CB_buf, &(pMeasurementSRV->noiseHistogramResults));
+ TRACE_INFO_HEX( pMeasurementSRV->hReport, CB_buf, sizeof(TNoiseHistogramResults));
+
+ /* setting Off the Waitng for noise histogram Results Bit */
+ pMeasurementSRV->pendingParamCBs &= ~MSR_SRV_WAITING_NOISE_HIST_RESULTS;
+
+ /* find the request index */
+ requestIndex = measurementSRVFindIndexByType( hMeasurementSRV, MSR_TYPE_NOISE_HISTOGRAM_MEASUREMENT );
+ if ( -1 == requestIndex )
+ {
+ /* indicates we can't find the request in the requets array. Shouldn't happen, but nothing to do */
+ TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": request index from measurementSRVFindIndexByType is -1?!?");
+ return;
+ }
+
+ if ( TI_OK == status )
+ {
+ sumOfSamples = pMeasurementSRV->noiseHistogramResults.numOfLostCycles;
+
+ /* Print For Debug */
+TRACE4( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": numOfLostCycles = %d numOfTxHwGenLostCycles = %d numOfRxLostCycles = %d numOfExceedLastThresholdLostCycles = %d\n", pMeasurementSRV->noiseHistogramResults.numOfLostCycles, pMeasurementSRV->noiseHistogramResults.numOfTxHwGenLostCycles, pMeasurementSRV->noiseHistogramResults.numOfRxLostCycles, pMeasurementSRV->noiseHistogramResults.numOfLostCycles - (pMeasurementSRV->noiseHistogramResults.numOfTxHwGenLostCycles + pMeasurementSRV->noiseHistogramResults.numOfRxLostCycles));
+
+ for ( index = 0; index < NUM_OF_NOISE_HISTOGRAM_COUNTERS; index++ )
+ {
+ sumOfSamples += pMeasurementSRV->noiseHistogramResults.counters[ index ];
+
+ /* Print For Debug */
+TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Counter #%d = %x\n", index, pMeasurementSRV->noiseHistogramResults.counters[index]);
+ }
+
+ /* If there weren't enough samples --> Reject the Request */
+ if ( (sumOfSamples - pMeasurementSRV->noiseHistogramResults.numOfLostCycles) <
+ NOISE_HISTOGRAM_THRESHOLD )
+ {
+TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_WARNING, ": noise histogram CB, rejecting request because %d samples received.\n", sumOfSamples - pMeasurementSRV->noiseHistogramResults.numOfLostCycles);
+
+ /* set negative result status */
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
+ }
+ else
+ {
+ for (index = 0; index < NUM_OF_NOISE_HISTOGRAM_COUNTERS; index++)
+ {
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ index ] =
+ ( 255 * pMeasurementSRV->noiseHistogramResults.counters[ index ]) / sumOfSamples;
+ }
+
+TRACE8( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Valid noise histogram reply. RPIDensity: %d %d %d %d %d %d %d %d\n", pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ 0 ], pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ 1 ], pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ 2 ], pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ 3 ], pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ 4 ], pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ 5 ], pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ 6 ], pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ 7 ]);
+ }
+ }
+ else
+ {
+TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_WARNING, ": noise histogram CB with status: %d, rejecting request.\n", status);
+ /* set negative result status */
+ pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
+ }
+
+ /* if no measurement are running and no CBs are pending,
+ send ALL TYPES COMPLETE event */
+ if ( TI_TRUE == measurementSRVIsMeasurementComplete( hMeasurementSRV ))
+ {
+ /* send the event */
+ measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState),
+ MSR_SRV_EVENT_ALL_TYPES_COMPLETE );
+ }
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 16-November-2005\n
+ * \brief Checks whether all measuremtn types had completed and all param CBs had been called.\n
+ *
+ * Function Scope \e Public.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \param status - the get_param call status.\n
+ * \param CB_buf - pointer to the results buffer (already on the measurement SRV object)
+ */
+TI_BOOL measurementSRVIsMeasurementComplete( TI_HANDLE hMeasurementSRV )
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_INT32 i;
+
+ /* verify that no request is currently running */
+ for ( i = 0; i < pMeasurementSRV->msrRequest.numberOfTypes; i++ )
+ {
+ if ( TI_TRUE == pMeasurementSRV->bRequestTimerRunning[ i ] )
+ {
+ return TI_FALSE;
+ }
+ }
+
+ /* verify that no CBs are pending */
+ if ( 0 != (pMeasurementSRV->pendingParamCBs &
+ (MSR_SRV_WAITING_CHANNEL_LOAD_RESULTS | MSR_SRV_WAITING_NOISE_HIST_RESULTS)))
+ {
+ return TI_FALSE;
+ }
+
+ return TI_TRUE;
+}
+
+/**
+ * \author Ronen Kalish\n
+ * \date 17-November-2005\n
+ * \brief Finds a measure type index in the measure request array.\n
+ *
+ * Function Scope \e Public.\n
+ * \param hMeasurementSRV - handle to the measurement SRV object.\n
+ * \param type - the measure type to look for.\n
+ * \return the type index, -1 if not found.\n
+ */
+TI_INT32 measurementSRVFindIndexByType( TI_HANDLE hMeasurementSRV, EMeasurementType type )
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+ TI_INT32 i;
+
+ for ( i = 0; i < pMeasurementSRV->msrRequest.numberOfTypes; i++ )
+ {
+ if ( type == pMeasurementSRV->msrRequest.msrTypes[ i ].msrType )
+ {
+ return i;
+ }
+ }
+ return -1;
+}
+
+
+
+/****************************************************************************************
+ * measurementSRVRegisterFailureEventCB *
+ ****************************************************************************************
+DESCRIPTION: Registers a failure event callback for scan error notifications.
+
+
+INPUT: - hMeasurementSRV - handle to the Measurement SRV object.
+ - failureEventCB - the failure event callback function.\n
+ - hFailureEventObj - handle to the object passed to the failure event callback function.
+
+OUTPUT:
+RETURN: void.
+****************************************************************************************/
+
+void measurementSRVRegisterFailureEventCB( TI_HANDLE hMeasurementSRV,
+ void * failureEventCB, TI_HANDLE hFailureEventObj )
+{
+ measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
+
+ pMeasurementSRV->failureEventFunc = (TFailureEventCb)failureEventCB;
+ pMeasurementSRV->failureEventObj = hFailureEventObj;
+}
+
+