1 /*
2 * MeasurementSrv.c
3 *
4 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * * Neither the name Texas Instruments nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 /** \file measurementSrv.c
35 * \brief This file include the measurement SRV interface functions implementation.
36 * \author Ronen Kalish
37 * \date 09-November-2005
38 */
39
40 #define __FILE_ID__ FILE_ID_110
41 #include "tidef.h"
42 #include "MeasurementSrv.h"
43 #include "MeasurementSrvSM.h"
44 #include "report.h"
45 #include "timer.h"
46 #include "osApi.h"
47 #include "MacServices.h"
48 #include "measurementSrvDbgPrint.h"
49 #include "eventMbox_api.h"
50 #include "CmdBld.h"
51
52 /**
53 * \author Ronen Kalish\n
54 * \date 08-November-2005\n
55 * \brief Creates the measurement SRV object
56 *
57 * Function Scope \e Public.\n
58 * \param hOS - handle to the OS object.\n
59 * \return a handle to the measurement SRV object, NULL if an error occurred.\n
60 */
MacServices_measurementSRV_create(TI_HANDLE hOS)61 TI_HANDLE MacServices_measurementSRV_create( TI_HANDLE hOS )
62 {
63 measurementSRV_t* pMeasurementSRV;
64
65 /* allocate the measurement SRV object */
66 pMeasurementSRV = os_memoryAlloc( hOS, sizeof(measurementSRV_t));
67 if ( NULL == pMeasurementSRV )
68 {
69 WLAN_OS_REPORT( ("ERROR: Failed to create measurement SRV object."));
70 return NULL;
71 }
72
73 /* nullify the object */
74 os_memoryZero( hOS, pMeasurementSRV, sizeof(measurementSRV_t));
75
76 /* store OS handle */
77 pMeasurementSRV->hOS = hOS;
78
79 /* allocate the SM */
80 if ( TI_OK != fsm_Create( hOS, &(pMeasurementSRV->SM), MSR_SRV_NUM_OF_STATES, MSR_SRV_NUM_OF_EVENTS ))
81 {
82 pMeasurementSRV->SM = NULL;
83 WLAN_OS_REPORT(("Failed to create measurement SRV state machine.\n"));
84 MacServices_measurementSRV_destroy( pMeasurementSRV );
85 return NULL;
86 }
87
88 return (TI_HANDLE)pMeasurementSRV;
89 }
90
91 /**
92 * \author Ronen Kalish\n
93 * \date 08-November-2005\n
94 * \brief Initializes the measurement SRV object
95 *
96 * Function Scope \e Public.\n
97 * \param hMeasurementSRV - handle to the measurement SRV object.\n
98 * \param hReport - handle to the report object.\n
99 * \param hCmdBld - handle to the Command Builder object.\n
100 * \param hPowerSaveSRV - handle to the power save SRV object.\n
101 */
MacServices_measurementSRV_init(TI_HANDLE hMeasurementSRV,TI_HANDLE hReport,TI_HANDLE hCmdBld,TI_HANDLE hEventMbox,TI_HANDLE hPowerSaveSRV,TI_HANDLE hTimer)102 TI_STATUS MacServices_measurementSRV_init (TI_HANDLE hMeasurementSRV,
103 TI_HANDLE hReport,
104 TI_HANDLE hCmdBld,
105 TI_HANDLE hEventMbox,
106 TI_HANDLE hPowerSaveSRV,
107 TI_HANDLE hTimer)
108 {
109 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
110 TI_INT32 i;
111
112 /* store handles */
113 pMeasurementSRV->hReport = hReport;
114 pMeasurementSRV->hCmdBld = hCmdBld;
115 pMeasurementSRV->hEventMbox = hEventMbox;
116 pMeasurementSRV->hPowerSaveSRV = hPowerSaveSRV;
117 pMeasurementSRV->hTimer = hTimer;
118
119 /* Initialize the state machine */
120 measurementSRVSM_init (hMeasurementSRV);
121
122 /* allocate the module timers */
123 pMeasurementSRV->hStartStopTimer = tmr_CreateTimer (pMeasurementSRV->hTimer);
124 if (pMeasurementSRV->hStartStopTimer == NULL)
125 {
126 TRACE0(pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, "MacServices_measurementSRV_init(): Failed to create hStartStopTimer!\n");
127 return TI_NOK;
128 }
129 pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;
130
131 for (i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++)
132 {
133 pMeasurementSRV->hRequestTimer[i] = tmr_CreateTimer (pMeasurementSRV->hTimer);
134 if (pMeasurementSRV->hRequestTimer[i] == NULL)
135 {
136 TRACE0(pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, "MacServices_measurementSRV_init(): Failed to create hRequestTimer!\n");
137 return TI_NOK;
138 }
139 pMeasurementSRV->bRequestTimerRunning[i] = TI_FALSE;
140 }
141
142 /* register HAL callbacks */
143 /* Register and Enable the Measure Start event in HAL */
144
145
146 eventMbox_RegisterEvent (pMeasurementSRV->hEventMbox,
147 TWD_OWN_EVENT_MEASUREMENT_START,
148 (void *)MacServices_measurementSRV_measureStartCB,
149 hMeasurementSRV);
150 eventMbox_UnMaskEvent (pMeasurementSRV->hEventMbox, TWD_OWN_EVENT_MEASUREMENT_START, NULL, NULL);
151
152 /* Register and Enable the Measurement Complete event in HAL.
153 This event will be received when the Measurement duration expired,
154 or after Stop Measure command. */
155
156 eventMbox_RegisterEvent (pMeasurementSRV->hEventMbox,
157 TWD_OWN_EVENT_MEASUREMENT_COMPLETE,
158 (void *)MacServices_measurementSRV_measureCompleteCB,
159 hMeasurementSRV);
160 eventMbox_UnMaskEvent (pMeasurementSRV->hEventMbox, TWD_OWN_EVENT_MEASUREMENT_COMPLETE, NULL, NULL);
161
162 /* Register and Enable the AP Discovery Complete event in HAL */
163 eventMbox_RegisterEvent (pMeasurementSRV->hEventMbox,
164 TWD_OWN_EVENT_AP_DISCOVERY_COMPLETE,
165 (void *)MacServices_measurementSRV_apDiscoveryCompleteCB,
166 hMeasurementSRV);
167 eventMbox_UnMaskEvent (pMeasurementSRV->hEventMbox, TWD_OWN_EVENT_AP_DISCOVERY_COMPLETE, NULL, NULL);
168
169 TRACE0(hReport, REPORT_SEVERITY_INIT , ".....Measurement SRV configured successfully.\n");
170
171 return TI_OK;
172 }
173
174 /**
175 * \brief Restart the measurement SRV object upon recovery.
176 *
177 * Function Scope \e Public.\n
178 * \param hMeasurementSRV - handle to the measurement SRV object.\n
179 */
measurementSRV_restart(TI_HANDLE hMeasurementSRV)180 void measurementSRV_restart( TI_HANDLE hMeasurementSRV)
181 {
182 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
183 TI_INT32 i;
184
185 /* if a timer is running, stop it */
186 if (pMeasurementSRV->bStartStopTimerRunning)
187 {
188 tmr_StopTimer (pMeasurementSRV->hStartStopTimer);
189 pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;
190 }
191 for (i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++)
192 {
193 if (pMeasurementSRV->bRequestTimerRunning[i])
194 {
195 tmr_StopTimer (pMeasurementSRV->hRequestTimer[i]);
196 pMeasurementSRV->bRequestTimerRunning[i] = TI_FALSE;
197 }
198 }
199
200
201 /* Initialize the state machine */
202 /* initialize current state */
203 pMeasurementSRV->SMState = MSR_SRV_STATE_IDLE;
204
205 /* mark that all timers are not running */
206 pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;
207 for ( i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++ )
208 {
209 pMeasurementSRV->bRequestTimerRunning[ i ] = TI_FALSE;
210 }
211
212 }
213
214 /**
215 * \author Ronen Kalish\n
216 * \date 08-November-2005\n
217 * \brief Destroys the measurement SRV object
218 *
219 * Function Scope \e Public.\n
220 * \param hMeasurementSRV - handle to the measurement SRV object.\n
221 */
MacServices_measurementSRV_destroy(TI_HANDLE hMeasurementSRV)222 void MacServices_measurementSRV_destroy( TI_HANDLE hMeasurementSRV )
223 {
224 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
225 TI_INT32 i;
226
227 /* sanity cehcking */
228 if ( NULL == hMeasurementSRV )
229 {
230 return;
231 }
232
233 /* release state machine */
234 if ( NULL != pMeasurementSRV->SM )
235 {
236 fsm_Unload( pMeasurementSRV->hOS, pMeasurementSRV->SM );
237 }
238
239 /* release timers */
240 for ( i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++ )
241 {
242 if (pMeasurementSRV->hRequestTimer[i])
243 {
244 tmr_DestroyTimer (pMeasurementSRV->hRequestTimer[i]);
245 }
246 }
247 if (pMeasurementSRV->hStartStopTimer)
248 {
249 tmr_DestroyTimer (pMeasurementSRV->hStartStopTimer);
250 }
251
252 /* release object space */
253 os_memoryFree( pMeasurementSRV->hOS, (TI_HANDLE)pMeasurementSRV, sizeof(measurementSRV_t));
254 }
255
256 /**
257 * \author Ronen Kalish\n
258 * \date 09-November-2005\n
259 * \brief Starts a measurement operation.\n
260 *
261 * Function Scope \e Public.\n
262 * \param hMacServices - handle to the MacServices object.\n
263 * \param pMsrRequest - a structure containing measurement parameters.\n
264 * \param timeToRequestexpiryMs - the time (in milliseconds) the measurement SRV has to start the request.\n
265 * \param cmdResponseCBFunc - callback function to used for command response.\n
266 * \param cmdResponseCBObj - handle to pass to command response CB.\n
267 * \param cmdCompleteCBFunc - callback function to be used for command complete.\n
268 * \param cmdCompleteCBObj - handle to pass to command complete CB.\n
269 * \return TI_OK if successful (various, TBD codes if not).\n
270 */
MacServices_measurementSRV_startMeasurement(TI_HANDLE hMacServices,TMeasurementRequest * pMsrRequest,TI_UINT32 timeToRequestExpiryMs,TCmdResponseCb cmdResponseCBFunc,TI_HANDLE cmdResponseCBObj,TMeasurementSrvCompleteCb cmdCompleteCBFunc,TI_HANDLE cmdCompleteCBObj)271 TI_STATUS MacServices_measurementSRV_startMeasurement( TI_HANDLE hMacServices,
272 TMeasurementRequest* pMsrRequest,
273 TI_UINT32 timeToRequestExpiryMs,
274 TCmdResponseCb cmdResponseCBFunc,
275 TI_HANDLE cmdResponseCBObj,
276 TMeasurementSrvCompleteCb cmdCompleteCBFunc,
277 TI_HANDLE cmdCompleteCBObj )
278 {
279 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)((MacServices_t*)hMacServices)->hMeasurementSRV;
280 TI_INT32 i;
281
282 #ifdef TI_DBG
283 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Received measurement request.\n");
284 measurementSRVPrintRequest( (TI_HANDLE)pMeasurementSRV, pMsrRequest );
285 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);
286 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "cmd complete CB: 0x%x, cmd complete handle: 0x%x\n", cmdCompleteCBFunc, cmdCompleteCBObj);
287 #endif
288
289 /* mark that request is in progress */
290 pMeasurementSRV->bInRequest = TI_TRUE;
291
292 /* mark to send NULL data when exiting driver mode (can be changed to TI_FALSE
293 only when explictly stopping the measurement */
294 pMeasurementSRV->bSendNullDataWhenExitPs = TI_TRUE;
295
296 /* Nullify return status */
297 pMeasurementSRV->returnStatus = TI_OK;
298
299 /* copy request parameters */
300 os_memoryCopy (pMeasurementSRV->hOS,
301 (void *)&pMeasurementSRV->msrRequest,
302 (void *)pMsrRequest,
303 sizeof(TMeasurementRequest));
304
305 /* Mark the current time stamp and the duration to start to cehck expiry later */
306 pMeasurementSRV->requestRecptionTimeStampMs = os_timeStampMs( pMeasurementSRV->hOS );
307 pMeasurementSRV->timeToRequestExpiryMs = timeToRequestExpiryMs;
308
309 /* copy callbacks */
310 pMeasurementSRV->commandResponseCBFunc = cmdResponseCBFunc;
311 pMeasurementSRV->commandResponseCBObj = cmdResponseCBObj;
312 pMeasurementSRV->measurmentCompleteCBFunc = cmdCompleteCBFunc;
313 pMeasurementSRV->measurementCompleteCBObj = cmdCompleteCBObj;
314
315 /* initialize reply */
316 pMeasurementSRV->msrReply.numberOfTypes = pMsrRequest->numberOfTypes;
317 for ( i = 0; i < pMsrRequest->numberOfTypes; i++ )
318 {
319 pMeasurementSRV->msrReply.msrTypes[ i ].msrType = pMeasurementSRV->msrRequest.msrTypes[ i ].msrType;
320 pMeasurementSRV->msrReply.msrTypes[ i ].status = TI_OK;
321 }
322
323 /* nullify the pending CBs bitmap */
324 pMeasurementSRV->pendingParamCBs = 0;
325
326 /* send a start measurement event to the SM */
327 measurementSRVSM_SMEvent( (TI_HANDLE)pMeasurementSRV, &(pMeasurementSRV->SMState),
328 MSR_SRV_EVENT_MEASURE_START_REQUEST );
329
330 /* mark that request has been sent */
331 pMeasurementSRV->bInRequest = TI_FALSE;
332
333 return pMeasurementSRV->returnStatus;
334 }
335
336 /**
337 * \author Ronen Kalish\n
338 * \date 09-November-2005\n
339 * \brief Stops a measurement operation in progress.\n
340 *
341 * Function Scope \e Public.\n
342 * \param hMacServices - handle to the MacServices object.\n
343 * \param bSendNullData - whether to send NULL data when exiting driver mode.\n
344 * \param cmdResponseCBFunc - callback function to used for command response.\n
345 * \param cmdResponseCBObj - handle to pass to command response CB.\n
346 * \return TI_OK if successful (various, TBD codes if not).\n
347 */
MacServices_measurementSRV_stopMeasurement(TI_HANDLE hMacServices,TI_BOOL bSendNullData,TCmdResponseCb cmdResponseCBFunc,TI_HANDLE cmdResponseCBObj)348 TI_STATUS MacServices_measurementSRV_stopMeasurement( TI_HANDLE hMacServices,
349 TI_BOOL bSendNullData,
350 TCmdResponseCb cmdResponseCBFunc,
351 TI_HANDLE cmdResponseCBObj )
352 {
353 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)((MacServices_t*)hMacServices)->hMeasurementSRV;
354
355 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Received measurement stop request.\n");
356 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "Send null data:, cmd response CB: 0x%x, cmd response handle: 0x%x\n", cmdResponseCBFunc, cmdResponseCBObj);
357
358 /* store callbacks */
359 pMeasurementSRV->commandResponseCBFunc = cmdResponseCBFunc;
360 pMeasurementSRV->commandResponseCBObj = cmdResponseCBObj;
361
362 /* store NULL data indication */
363 pMeasurementSRV->bSendNullDataWhenExitPs = bSendNullData;
364
365 /* mark that current return status is TI_OK */
366 pMeasurementSRV->returnStatus = TI_OK;
367
368 /* mark that a stop request is in progress */
369 pMeasurementSRV->bInRequest = TI_TRUE;
370
371 /* send a stop event to the SM */
372 measurementSRVSM_SMEvent( (TI_HANDLE)pMeasurementSRV, &(pMeasurementSRV->SMState),
373 MSR_SRV_EVENT_MEASURE_STOP_REQUEST );
374
375 /*mark that stop request has completed */
376 pMeasurementSRV->bInRequest = TI_FALSE;
377
378 return pMeasurementSRV->returnStatus;
379 }
380
381 /**
382 * \author Ronen Kalish\n
383 * \date 09-November-2005\n
384 * \brief Notifies the measurement SRV of a FW reset (recovery).\n
385 *
386 * Function Scope \e Public.\n
387 * \param hMacServices - handle to the MacServices object.\n
388 */
MacServices_measurementSRV_FWReset(TI_HANDLE hMacServices)389 void MacServices_measurementSRV_FWReset( TI_HANDLE hMacServices )
390 {
391 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)((MacServices_t*)hMacServices)->hMeasurementSRV;
392 TI_INT32 i;
393
394 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Received FW reset indication.\n");
395
396 /* if a timer is running, stop it */
397 if (pMeasurementSRV->bStartStopTimerRunning)
398 {
399 tmr_StopTimer (pMeasurementSRV->hStartStopTimer);
400 pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;
401 }
402 for (i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++)
403 {
404 if (pMeasurementSRV->bRequestTimerRunning[i])
405 {
406 tmr_StopTimer (pMeasurementSRV->hRequestTimer[i]);
407 pMeasurementSRV->bRequestTimerRunning[i] = TI_FALSE;
408 }
409 }
410
411 /* change SM state to idle */
412 pMeasurementSRV->SMState = MSR_SRV_STATE_IDLE;
413 }
414
415 /**
416 * \author Ronen Kalish\n
417 * \date 09-November-2005\n
418 * \brief callback function used by the power manager to notify driver mode result
419 *
420 * Function Scope \e Public.\n
421 * \param hMeasurementSRV - handle to the measurement SRV object.\n
422 * \param PSMode - the power save mode the STA is currently in.\n
423 * \param psStatus - the power save request status.\n
424 */
MacServices_measurementSRV_powerSaveCB(TI_HANDLE hMeasurementSRV,TI_UINT8 PSMode,TI_UINT8 psStatus)425 void MacServices_measurementSRV_powerSaveCB( TI_HANDLE hMeasurementSRV, TI_UINT8 PSMode, TI_UINT8 psStatus )
426 {
427 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
428
429 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Power save SRV CB called. PS mode:%d status: %d\n", PSMode, psStatus);
430
431 /* if driver mode entry succeedded */
432 if ( ENTER_POWER_SAVE_SUCCESS == psStatus )
433 {
434 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": PS successful.\n");
435
436 /* send a RIVER_MODE_SUCCESS event */
437 measurementSRVSM_SMEvent( (TI_HANDLE)pMeasurementSRV, &(pMeasurementSRV->SMState),
438 MSR_SRV_EVENT_DRIVER_MODE_SUCCESS );
439 }
440 /* driver mode entry failed */
441 else
442 {
443 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": PS failed, status %d.\n", psStatus);
444
445 /* Set the return status to TI_NOK */
446 pMeasurementSRV->returnStatus = (TI_STATUS)psStatus;
447
448 /* send a DRIVER_MODE_FAILURE event */
449 measurementSRVSM_SMEvent( (TI_HANDLE)pMeasurementSRV, &(pMeasurementSRV->SMState),
450 MSR_SRV_EVENT_DRIVER_MODE_FAILURE );
451 }
452 }
453
454 /**
455 * \author Ronen Kalish\n
456 * \date 14-November-2005\n
457 * \brief callback function used by the HAL for measure start event (sent when the FW
458 * has started measurement operation, i.e. switched channel and changed RX filters).\n
459 *
460 * Function Scope \e Public.\n
461 * \param hMeasurementSRV - handle to the measurement SRV object.\n
462 */
MacServices_measurementSRV_measureStartCB(TI_HANDLE hMeasurementSRV)463 void MacServices_measurementSRV_measureStartCB( TI_HANDLE hMeasurementSRV )
464 {
465 measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
466
467 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": measure start CB called.\n");
468
469 /* stop the FW guard timer */
470 tmr_StopTimer (pMeasurementSRV->hStartStopTimer);
471 pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;
472
473 /* clear the CB function, so that it won't be called on stop as well! */
474 pMeasurementSRV->commandResponseCBFunc = NULL;
475 pMeasurementSRV->commandResponseCBObj = NULL;
476
477 measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState),
478 MSR_SRV_EVENT_START_SUCCESS );
479 }
480
481 /**
482 * \author Ronen Kalish\n
483 * \date 14-November-2005\n
484 * \brief callback function used by the HAL for measure stop event (sent when the FW
485 * has finished measurement operation, i.e. switched channel to serving channel and changed back RX filters).\n
486 *
487 * Function Scope \e Public.\n
488 * \param hMeasurementSRV - handle to the measurement SRV object.\n
489 */
MacServices_measurementSRV_measureCompleteCB(TI_HANDLE hMeasurementSRV)490 void MacServices_measurementSRV_measureCompleteCB( TI_HANDLE hMeasurementSRV )
491 {
492 measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
493
494 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": measure complete CB called.\n");
495
496 /* stop the FW guard timer */
497 tmr_StopTimer (pMeasurementSRV->hStartStopTimer);
498 pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;
499
500 measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState),
501 MSR_SRV_EVENT_STOP_COMPLETE );
502 }
503
504 /**
505 * \author Ronen Kalish\n
506 * \date 14-November-2005\n
507 * \brief callback function used by the HAL for AP discovery stop event (sent when the FW
508 * has finished AP discovery operation).\n
509 *
510 * Function Scope \e Public.\n
511 * \param hMeasurementSRV - handle to the measurement SRV object.\n
512 */
MacServices_measurementSRV_apDiscoveryCompleteCB(TI_HANDLE hMeasurementSRV)513 void MacServices_measurementSRV_apDiscoveryCompleteCB( TI_HANDLE hMeasurementSRV )
514 {
515 #ifdef TI_DBG
516 measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
517
518 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": AP Discovery complete CB called.\n");
519 #endif /* TI_DBG */
520 }
521
522 /**
523 * \author Ronen Kalish\n
524 * \date 14-November-2005\n
525 * \brief called when a measurement FW guard timer expires.
526 *
527 * Function Scope \e Public.\n
528 * \param hMeasuremntSRV - handle to the measurement SRV object.\n
529 * \param bTwdInitOccured - Indicates if TWDriver recovery occured since timer started.\n
530 */
MacServices_measurementSRV_startStopTimerExpired(TI_HANDLE hMeasurementSRV,TI_BOOL bTwdInitOccured)531 void MacServices_measurementSRV_startStopTimerExpired (TI_HANDLE hMeasurementSRV, TI_BOOL bTwdInitOccured)
532 {
533 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
534 TI_INT32 i;
535
536 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": FW guard timer expired.\n");
537
538 /* mark that the FW guard timer is not running */
539 pMeasurementSRV->bStartStopTimerRunning = TI_FALSE;
540
541 /* if any other timer is running - stop it */
542 for (i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++)
543 {
544 if (pMeasurementSRV->bRequestTimerRunning[i])
545 {
546 tmr_StopTimer (pMeasurementSRV->hRequestTimer[i]);
547 pMeasurementSRV->bRequestTimerRunning[i] = TI_FALSE;
548 }
549 }
550
551 /* change SM state to idle */
552 pMeasurementSRV->SMState = MSR_SRV_STATE_IDLE;
553
554 /*Error Reporting - call the centeral error function in the health monitor if a request for measurement was faield*/
555 pMeasurementSRV->failureEventFunc(pMeasurementSRV->failureEventObj ,MEASUREMENT_FAILURE);
556 }
557
558 /**
559 * \author Ronen Kalish\n
560 * \date 15-November-2005\n
561 * \brief called when a measurement type timer expires.\n
562 *
563 * Function Scope \e Public.\n
564 * \param hMeasuremntSRV - handle to the measurement SRV object.\n
565 * \param bTwdInitOccured - Indicates if TWDriver recovery occured since timer started.\n
566 */
MacServices_measurementSRV_requestTimerExpired(TI_HANDLE hMeasurementSRV,TI_BOOL bTwdInitOccured)567 void MacServices_measurementSRV_requestTimerExpired (TI_HANDLE hMeasurementSRV, TI_BOOL bTwdInitOccured)
568 {
569 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
570 TI_INT32 requestIndex;
571
572 /* find the expired measurement type */
573 requestIndex = measurementSRVFindMinDuration( hMeasurementSRV );
574 if ( -1 == requestIndex )
575 {
576 /* indicates we can't find the request in the requets array. Shouldn't happen, but nothing to do */
577 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": Request timer expired and request index from findMinDuration is -1?!?");
578 return;
579 }
580
581 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": request timer expired, request index: %d.\n", requestIndex);
582
583 /* mark that the timer is not running and that this request has completed */
584 pMeasurementSRV->bRequestTimerRunning[ requestIndex ] = TI_FALSE;
585
586 /* collect results and send stop command if necessary */
587 switch (pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].msrType)
588 {
589 case MSR_TYPE_BEACON_MEASUREMENT:
590 measurementSRVHandleBeaconMsrComplete( hMeasurementSRV, requestIndex );
591 break;
592
593 case MSR_TYPE_CCA_LOAD_MEASUREMENT:
594 measurementSRVHandleChannelLoadComplete( hMeasurementSRV, requestIndex );
595 break;
596
597 case MSR_TYPE_NOISE_HISTOGRAM_MEASUREMENT:
598 measurementSRVHandleNoiseHistogramComplete( hMeasurementSRV, requestIndex );
599 break;
600
601 /* used here to avoid compilation warning only, does nothing */
602 case MSR_TYPE_BASIC_MEASUREMENT:
603 case MSR_TYPE_FRAME_MEASUREMENT:
604 case MSR_TYPE_MAX_NUM_OF_MEASURE_TYPES:
605 default:
606 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": measure type %d not supported for request %d\n", pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].msrType, requestIndex);
607 break;
608 }
609
610 /* if no measurement are running and no CBs are pending, send ALL TYPES COMPLETE event */
611 if ( TI_TRUE == measurementSRVIsMeasurementComplete( hMeasurementSRV ))
612 {
613 /* send the event */
614 measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState),
615 MSR_SRV_EVENT_ALL_TYPES_COMPLETE );
616 }
617 }
618
619 /**
620 * \author Ronen Kalish\n
621 * \date 13-November-2005\n
622 * \brief Checks whether a beacon measurement is part of current measurement request
623 *
624 * Function Scope \e Private.\n
625 * \param hMeasurementSRV - handle to the measurement SRV object.\n
626 * \return TI_TRUE if a beacon measurement is part of current request, TI_FALSE otherwise.\n
627 */
measurementSRVIsBeaconMeasureIncluded(TI_HANDLE hMeasurementSRV)628 TI_BOOL measurementSRVIsBeaconMeasureIncluded( TI_HANDLE hMeasurementSRV )
629 {
630 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
631 TI_INT32 i;
632
633 for ( i = 0; i < MAX_NUM_OF_MSR_TYPES_IN_PARALLEL; i++ )
634 {
635 if ( MSR_TYPE_BEACON_MEASUREMENT == pMeasurementSRV->msrRequest.msrTypes[ i ].msrType )
636 {
637 return TI_TRUE;
638 }
639 }
640 return TI_FALSE;
641 }
642
643 /**
644 * \author Ronen Kalish\n
645 * \date 15-November-2005\n
646 * \brief Finds the index for the measurement request with the shortest period
647 * (the one that has now completed).\n
648 *
649 * Function Scope \e Private.\n
650 * \param hMeasurementSRV - handle to the measurement SRV object.\n
651 * \return index of the measurement request with the shortest duration.\n
652 */
measurementSRVFindMinDuration(TI_HANDLE hMeasurementSRV)653 TI_INT32 measurementSRVFindMinDuration( TI_HANDLE hMeasurementSRV )
654 {
655 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
656 TI_INT32 i, minIndex;
657 TI_UINT32 minValue;
658
659
660 minIndex = minValue = 0; /* minIndex is initialized only to avoid compilation warning! */
661
662 /* find the index with the minimum duration */
663 for ( i = 0; i < pMeasurementSRV->msrRequest.numberOfTypes; i++ )
664 {
665 if ( TI_TRUE == pMeasurementSRV->bRequestTimerRunning[ i ] )
666 {
667 if ( (0 == minValue) ||
668 (pMeasurementSRV->msrRequest.msrTypes[ i ].duration < minValue))
669 {
670 minValue = pMeasurementSRV->msrRequest.msrTypes[ i ].duration;
671 minIndex = i;
672 }
673 }
674 }
675
676 /* if no entry with positive duration exists, return -1 */
677 if ( 0 == minValue )
678 {
679 return -1;
680 }
681 else
682 { /* otherwise, return the index of the type with the shortest duration */
683 return minIndex;
684 }
685 }
686
687 /**
688 * \author Ronen Kalish\n
689 * \date 15-November-2005\n
690 * \brief Handles an AP discovery timer expiry, by setting necessary values in the
691 * reply struct.\n
692 *
693 * Function Scope \e Private.\n
694 * \param hMeasurementSRV - handle to the measurement SRV object.\n
695 * \param requestIndex - index of the beacon request in the request structure.\n
696 */
measurementSRVHandleBeaconMsrComplete(TI_HANDLE hMeasurementSRV,TI_INT32 requestIndex)697 void measurementSRVHandleBeaconMsrComplete( TI_HANDLE hMeasurementSRV, TI_INT32 requestIndex )
698 {
699 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
700 TI_INT32 status;
701
702
703 TRACE0(pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Sending AP Discovery Stop to the HAL...");
704
705 /* send stop AP discovery command */
706 status = cmdBld_CmdApDiscoveryStop (pMeasurementSRV->hCmdBld, NULL, NULL);
707 if ( TI_OK != status )
708 {
709 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": status %d received from cmdBld_CmdApDiscoveryStop\n", status);
710 }
711 }
712
713 /**
714 * \author Ronen Kalish\n
715 * \date 15-November-2005\n
716 * \brief Handles a channel load timer expiry, by requesting channel load
717 * results from the FW.\n
718 *
719 * Function Scope \e Private.\n
720 * \param hMeasurementSRV - handle to the measurement SRV object.\n
721 * \param requestIndex - index of the channel load request in the request structure.\n
722 */
measurementSRVHandleChannelLoadComplete(TI_HANDLE hMeasurementSRV,TI_INT32 requestIndex)723 void measurementSRVHandleChannelLoadComplete( TI_HANDLE hMeasurementSRV, TI_INT32 requestIndex )
724 {
725 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
726 TTwdParamInfo tTwdParam;
727 TI_STATUS status;
728
729 /* Getting the Medium Occupancy Register */
730 tTwdParam.paramType = TWD_MEDIUM_OCCUPANCY_PARAM_ID;
731 tTwdParam.content.interogateCmdCBParams.fCb = (void *)MacServices_measurementSRV_channelLoadParamCB;
732 tTwdParam.content.interogateCmdCBParams.hCb = hMeasurementSRV;
733 tTwdParam.content.interogateCmdCBParams.pCb = (TI_UINT8*)(&(pMeasurementSRV->mediumOccupancyResults));
734 status = cmdBld_GetParam (pMeasurementSRV->hCmdBld, &tTwdParam);
735
736 if ( status != TI_OK )
737 {
738 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": whalCtrl_GetParam returned status %d\n", status);
739
740 /* mark that the specific measurment type has failed */
741 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
742
743 /* if all measurement types has finished, an event will be send by request timer expired */
744 }
745 else
746 {
747 /* mark that channel load param CB is pending */
748 pMeasurementSRV->pendingParamCBs |= MSR_SRV_WAITING_CHANNEL_LOAD_RESULTS;
749 }
750 }
751
752 /**
753 * \author Ronen Kalish\n
754 * \date 15-November-2005\n
755 * \brief Handles a noise histogram timer expiry, by requesting noise histogram
756 * reaults from the FW.\n
757 *
758 * Function Scope \e Private.\n
759 * \param hMeasurementSRV - handle to the measurement SRV object.\n
760 * \param requestIndex - index of the beacon request in the request structure.\n
761 */
measurementSRVHandleNoiseHistogramComplete(TI_HANDLE hMeasurementSRV,TI_INT32 requestIndex)762 void measurementSRVHandleNoiseHistogramComplete( TI_HANDLE hMeasurementSRV, TI_INT32 requestIndex )
763 {
764 measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
765 TTwdParamInfo tTwdParam;
766 TNoiseHistogram pNoiseHistParams;
767 TI_STATUS status;
768
769 /* Set Noise Histogram Cmd Params */
770 pNoiseHistParams.cmd = STOP_NOISE_HIST;
771 pNoiseHistParams.sampleInterval = 0;
772 os_memoryZero( pMeasurementSRV->hOS, &(pNoiseHistParams.ranges[0]), MEASUREMENT_NOISE_HISTOGRAM_NUM_OF_RANGES );
773
774 /* Send a Stop command to the FW */
775 status = cmdBld_CmdNoiseHistogram (pMeasurementSRV->hCmdBld, &pNoiseHistParams, NULL, NULL);
776
777 if ( TI_OK != status )
778 {
779 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": whalCtrl_NoiseHistogramCmd returned status %d\n", status);
780
781 /* mark that the specific measurment type has failed */
782 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
783
784 /* if all measurement types has finished, an event will be send by request timer expired */
785 }
786
787 /* Get measurement results */
788 tTwdParam.paramType = TWD_NOISE_HISTOGRAM_PARAM_ID;
789 tTwdParam.content.interogateCmdCBParams.fCb = (void *)MacServices_measurementSRV_noiseHistCallBack;
790 tTwdParam.content.interogateCmdCBParams.hCb = hMeasurementSRV;
791 tTwdParam.content.interogateCmdCBParams.pCb = (TI_UINT8*)&pMeasurementSRV->noiseHistogramResults;
792 status = cmdBld_GetParam (pMeasurementSRV->hCmdBld, &tTwdParam);
793
794 if ( TI_OK == status )
795 {
796 /* setting On the Waitng for Noise Histogram Results Bit */
797 pMeasurementSRV->pendingParamCBs |= MSR_SRV_WAITING_NOISE_HIST_RESULTS;
798
799 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": sent noise histogram stop command.\n");
800 }
801 else
802 {
803 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": whalCtrl_GetParam returned status %d\n", status);
804
805 /* mark that the specific measurment type has failed */
806 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
807
808 /* if all measurement types has finished, an event will be send by request timer expired */
809 }
810 }
811
812 /**
813 * \author Ronen Kalish\n
814 * \date 16-November-2005\n
815 * \brief Callback for channel load get param call.\n
816 *
817 * Function Scope \e Public.\n
818 * \param hMeasurementSRV - handle to the measurement SRV object.\n
819 * \param status - the get_param call status.\n
820 * \param CB_buf - pointer to the results buffer (already on the measurement SRV object)
821 */
MacServices_measurementSRV_channelLoadParamCB(TI_HANDLE hMeasurementSRV,TI_STATUS status,TI_UINT8 * CB_buf)822 void MacServices_measurementSRV_channelLoadParamCB( TI_HANDLE hMeasurementSRV, TI_STATUS status,
823 TI_UINT8* CB_buf )
824 {
825 measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
826 TI_UINT32 mediumUsageInMs, periodInMs;
827 TI_INT32 requestIndex;
828
829 /* when this CB is called as a result of the nulify call at the measurement beginning,
830 the handle will be NULL. In this case, nothing needs to be done. */
831 if ( NULL == hMeasurementSRV )
832 {
833 return;
834 }
835
836 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Channel load CB called, status:%d\n", status);
837 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "result address (reported): 0x%x, result address (assumed): 0x%x, results (reported):\n", CB_buf, &(pMeasurementSRV->mediumOccupancyResults));
838 TRACE_INFO_HEX( pMeasurementSRV->hReport, CB_buf, sizeof(TMediumOccupancy));
839
840 /* setting Off the Waitng for Channel Load Results Bit */
841 pMeasurementSRV->pendingParamCBs &= ~MSR_SRV_WAITING_CHANNEL_LOAD_RESULTS;
842
843 /* find the request index */
844 requestIndex = measurementSRVFindIndexByType( hMeasurementSRV, MSR_TYPE_CCA_LOAD_MEASUREMENT );
845 if ( -1 == requestIndex )
846 {
847 /* indicates we can't find the request in the requets array. Shouldn't happen, but nothing to do */
848 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": request index from measurementSRVFindIndexByType is -1?!?");
849 return;
850 }
851
852 if ( (TI_OK == status) && (0 != pMeasurementSRV->mediumOccupancyResults.Period))
853 {
854 /* calculate results */
855 mediumUsageInMs = pMeasurementSRV->mediumOccupancyResults.MediumUsage / 1000;
856 periodInMs = pMeasurementSRV->mediumOccupancyResults.Period / 1000;
857
858 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": MediumUsage = %d Period = %d\n",mediumUsageInMs, periodInMs);
859
860 if ( periodInMs <= pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].duration )
861 {
862 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.CCABusyFraction =
863 ( 255 * pMeasurementSRV->mediumOccupancyResults.MediumUsage ) /
864 pMeasurementSRV->mediumOccupancyResults.Period;
865 }
866 else
867 {
868 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.CCABusyFraction =
869 ( 255 * pMeasurementSRV->mediumOccupancyResults.MediumUsage ) /
870 (pMeasurementSRV->msrRequest.msrTypes[ requestIndex ].duration * 1000);
871 }
872 }
873 else
874 {
875 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": channel load failed. Status=%d, period=%d\n", status, pMeasurementSRV->mediumOccupancyResults.Period);
876
877 /* mark result status */
878 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
879 }
880
881 /* if no measurement are running and no CBs are pending,
882 send ALL TYPES COMPLETE event */
883 if ( TI_TRUE == measurementSRVIsMeasurementComplete( hMeasurementSRV ))
884 {
885 /* send the event */
886 measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState),
887 MSR_SRV_EVENT_ALL_TYPES_COMPLETE );
888 }
889 }
890
891 /**
892 * \date 03-January-2005\n
893 * \brief Dummy callback for channel load get param call. Used to clear the channel load tracker.\n
894 *
895 * Function Scope \e Public.\n
896 * \param hMeasurementSRV - handle to the measurement SRV object.\n
897 * \param status - the get_param call status.\n
898 * \param CB_buf - pointer to the results buffer (already on the measurement SRV object)
899 */
MacServices_measurementSRV_dummyChannelLoadParamCB(TI_HANDLE hMeasurementSRV,TI_STATUS status,TI_UINT8 * CB_buf)900 void MacServices_measurementSRV_dummyChannelLoadParamCB( TI_HANDLE hMeasurementSRV, TI_STATUS status,
901 TI_UINT8* CB_buf )
902 {
903 #ifdef TI_DBG
904 measurementSRV_t *pMeasurementSRV = (measurementSRV_t*) hMeasurementSRV;
905
906 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Dummy Channel Load callback called (status = %d)\n", status);
907 #endif /* TI_DBG */
908 }
909
910 /**
911 * \author Ronen Kalish\n
912 * \date 16-November-2005\n
913 * \brief Callback for noise histogram get param call.\n
914 *
915 * Function Scope \e Public.\n
916 * \param hMeasurementSRV - handle to the measurement SRV object.\n
917 * \param status - the get_param call status.\n
918 * \param CB_buf - pointer to the results buffer (already on the measurement SRV object)
919 */
MacServices_measurementSRV_noiseHistCallBack(TI_HANDLE hMeasurementSRV,TI_STATUS status,TI_UINT8 * CB_buf)920 void MacServices_measurementSRV_noiseHistCallBack( TI_HANDLE hMeasurementSRV, TI_STATUS status,
921 TI_UINT8* CB_buf )
922 {
923 measurementSRV_t *pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
924 TI_UINT8 index;
925 TI_UINT32 sumOfSamples;
926 TI_INT32 requestIndex;
927
928 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": noise histogram CB called, status: %d\n", status);
929 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, "result address (reported): 0x%x, result address (assumed): 0x%x, results (reported):\n", CB_buf, &(pMeasurementSRV->noiseHistogramResults));
930 TRACE_INFO_HEX( pMeasurementSRV->hReport, CB_buf, sizeof(TNoiseHistogramResults));
931
932 /* setting Off the Waitng for noise histogram Results Bit */
933 pMeasurementSRV->pendingParamCBs &= ~MSR_SRV_WAITING_NOISE_HIST_RESULTS;
934
935 /* find the request index */
936 requestIndex = measurementSRVFindIndexByType( hMeasurementSRV, MSR_TYPE_NOISE_HISTOGRAM_MEASUREMENT );
937 if ( -1 == requestIndex )
938 {
939 /* indicates we can't find the request in the requets array. Shouldn't happen, but nothing to do */
940 TRACE0( pMeasurementSRV->hReport, REPORT_SEVERITY_ERROR, ": request index from measurementSRVFindIndexByType is -1?!?");
941 return;
942 }
943
944 if ( TI_OK == status )
945 {
946 sumOfSamples = pMeasurementSRV->noiseHistogramResults.numOfLostCycles;
947
948 /* Print For Debug */
949 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));
950
951 for ( index = 0; index < NUM_OF_NOISE_HISTOGRAM_COUNTERS; index++ )
952 {
953 sumOfSamples += pMeasurementSRV->noiseHistogramResults.counters[ index ];
954
955 /* Print For Debug */
956 TRACE2( pMeasurementSRV->hReport, REPORT_SEVERITY_INFORMATION, ": Counter #%d = %x\n", index, pMeasurementSRV->noiseHistogramResults.counters[index]);
957 }
958
959 /* If there weren't enough samples --> Reject the Request */
960 if ( (sumOfSamples - pMeasurementSRV->noiseHistogramResults.numOfLostCycles) <
961 NOISE_HISTOGRAM_THRESHOLD )
962 {
963 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_WARNING, ": noise histogram CB, rejecting request because %d samples received.\n", sumOfSamples - pMeasurementSRV->noiseHistogramResults.numOfLostCycles);
964
965 /* set negative result status */
966 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
967 }
968 else
969 {
970 for (index = 0; index < NUM_OF_NOISE_HISTOGRAM_COUNTERS; index++)
971 {
972 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].replyValue.RPIDensity[ index ] =
973 ( 255 * pMeasurementSRV->noiseHistogramResults.counters[ index ]) / sumOfSamples;
974 }
975
976 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 ]);
977 }
978 }
979 else
980 {
981 TRACE1( pMeasurementSRV->hReport, REPORT_SEVERITY_WARNING, ": noise histogram CB with status: %d, rejecting request.\n", status);
982 /* set negative result status */
983 pMeasurementSRV->msrReply.msrTypes[ requestIndex ].status = TI_NOK;
984 }
985
986 /* if no measurement are running and no CBs are pending,
987 send ALL TYPES COMPLETE event */
988 if ( TI_TRUE == measurementSRVIsMeasurementComplete( hMeasurementSRV ))
989 {
990 /* send the event */
991 measurementSRVSM_SMEvent( hMeasurementSRV, &(pMeasurementSRV->SMState),
992 MSR_SRV_EVENT_ALL_TYPES_COMPLETE );
993 }
994 }
995
996 /**
997 * \author Ronen Kalish\n
998 * \date 16-November-2005\n
999 * \brief Checks whether all measuremtn types had completed and all param CBs had been called.\n
1000 *
1001 * Function Scope \e Public.\n
1002 * \param hMeasurementSRV - handle to the measurement SRV object.\n
1003 * \param status - the get_param call status.\n
1004 * \param CB_buf - pointer to the results buffer (already on the measurement SRV object)
1005 */
measurementSRVIsMeasurementComplete(TI_HANDLE hMeasurementSRV)1006 TI_BOOL measurementSRVIsMeasurementComplete( TI_HANDLE hMeasurementSRV )
1007 {
1008 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
1009 TI_INT32 i;
1010
1011 /* verify that no request is currently running */
1012 for ( i = 0; i < pMeasurementSRV->msrRequest.numberOfTypes; i++ )
1013 {
1014 if ( TI_TRUE == pMeasurementSRV->bRequestTimerRunning[ i ] )
1015 {
1016 return TI_FALSE;
1017 }
1018 }
1019
1020 /* verify that no CBs are pending */
1021 if ( 0 != (pMeasurementSRV->pendingParamCBs &
1022 (MSR_SRV_WAITING_CHANNEL_LOAD_RESULTS | MSR_SRV_WAITING_NOISE_HIST_RESULTS)))
1023 {
1024 return TI_FALSE;
1025 }
1026
1027 return TI_TRUE;
1028 }
1029
1030 /**
1031 * \author Ronen Kalish\n
1032 * \date 17-November-2005\n
1033 * \brief Finds a measure type index in the measure request array.\n
1034 *
1035 * Function Scope \e Public.\n
1036 * \param hMeasurementSRV - handle to the measurement SRV object.\n
1037 * \param type - the measure type to look for.\n
1038 * \return the type index, -1 if not found.\n
1039 */
measurementSRVFindIndexByType(TI_HANDLE hMeasurementSRV,EMeasurementType type)1040 TI_INT32 measurementSRVFindIndexByType( TI_HANDLE hMeasurementSRV, EMeasurementType type )
1041 {
1042 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
1043 TI_INT32 i;
1044
1045 for ( i = 0; i < pMeasurementSRV->msrRequest.numberOfTypes; i++ )
1046 {
1047 if ( type == pMeasurementSRV->msrRequest.msrTypes[ i ].msrType )
1048 {
1049 return i;
1050 }
1051 }
1052 return -1;
1053 }
1054
1055
1056
1057 /****************************************************************************************
1058 * measurementSRVRegisterFailureEventCB *
1059 ****************************************************************************************
1060 DESCRIPTION: Registers a failure event callback for scan error notifications.
1061
1062
1063 INPUT: - hMeasurementSRV - handle to the Measurement SRV object.
1064 - failureEventCB - the failure event callback function.\n
1065 - hFailureEventObj - handle to the object passed to the failure event callback function.
1066
1067 OUTPUT:
1068 RETURN: void.
1069 ****************************************************************************************/
1070
measurementSRVRegisterFailureEventCB(TI_HANDLE hMeasurementSRV,void * failureEventCB,TI_HANDLE hFailureEventObj)1071 void measurementSRVRegisterFailureEventCB( TI_HANDLE hMeasurementSRV,
1072 void * failureEventCB, TI_HANDLE hFailureEventObj )
1073 {
1074 measurementSRV_t* pMeasurementSRV = (measurementSRV_t*)hMeasurementSRV;
1075
1076 pMeasurementSRV->failureEventFunc = (TFailureEventCb)failureEventCB;
1077 pMeasurementSRV->failureEventObj = hFailureEventObj;
1078 }
1079
1080
1081