1 /** \file ScanCncnRoamingContSM.c
2 * \brief This file include the scan concentrator continuous scan for roaming module implementation
3 * \author Ronen Kalish
4 * \date 03-Jan-2005
5 */
6 /****************************************************************************
7 **+-----------------------------------------------------------------------+**
8 **| |**
9 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |**
10 **| All rights reserved. |**
11 **| |**
12 **| Redistribution and use in source and binary forms, with or without |**
13 **| modification, are permitted provided that the following conditions |**
14 **| are met: |**
15 **| |**
16 **| * Redistributions of source code must retain the above copyright |**
17 **| notice, this list of conditions and the following disclaimer. |**
18 **| * Redistributions in binary form must reproduce the above copyright |**
19 **| notice, this list of conditions and the following disclaimer in |**
20 **| the documentation and/or other materials provided with the |**
21 **| distribution. |**
22 **| * Neither the name Texas Instruments nor the names of its |**
23 **| contributors may be used to endorse or promote products derived |**
24 **| from this software without specific prior written permission. |**
25 **| |**
26 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |**
27 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |**
28 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |**
29 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |**
30 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |**
31 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |**
32 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |**
33 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |**
34 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |**
35 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |**
36 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |**
37 **| |**
38 **+-----------------------------------------------------------------------+**
39 ****************************************************************************/
40
41 #include "ScanCncnRoamingContSM.h"
42 #include "MacServices_api.h"
43 #include "report.h"
44 #include "siteMgrApi.h"
45 #include "healthMonitor.h"
46
47 static TI_STATUS actionUnexpected( TI_HANDLE hScanCncn );
48 static TI_STATUS actionNop( TI_HANDLE hScanCncn );
49
50 /**
51 * \author Ronen Kalish\n
52 * \date 02-Jan-2005\n
53 * \brief Initialize the scan concentrator continuous scan for roaming SM.
54 *
55 * Function Scope \e Public.\n
56 * \param hScanCncn - handle to the scan concentrator object.\n
57 * \return OK if successful, NOK otherwise.\n
58 */
scanConcentratorRoamingContSM_init(TI_HANDLE hScanCncn)59 TI_STATUS scanConcentratorRoamingContSM_init( TI_HANDLE hScanCncn )
60 {
61 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
62
63 fsm_actionCell_t smMatrix[ CONT_SCAN_NUM_OF_STATES ][ CONT_SCAN_NUM_OF_EVENTS ] =
64 {
65 /* next state and actions for IDLE state */
66 {
67 {CONT_SCAN_STATE_SCR_REQUEST, scanConcentratorRoamingContSM_requestSCR}, /*"START_SCAN",*/
68 {CONT_SCAN_STATE_IDLE, actionUnexpected}, /*"SCR_RUN",*/
69 {CONT_SCAN_STATE_IDLE, actionUnexpected}, /*"SCR_PEND", */
70 {CONT_SCAN_STATE_IDLE, actionUnexpected}, /*"SCR_REJECT",*/
71 {CONT_SCAN_STATE_IDLE, actionUnexpected}, /*"ABORT_SCAN"*/
72 {CONT_SCAN_STATE_IDLE, actionUnexpected}, /*"FW_RESET"*/
73 {CONT_SCAN_STATE_IDLE, actionNop}, /*"STOP_SCAN"*/
74 {CONT_SCAN_STATE_IDLE, actionUnexpected} /*"SCAN_COMPLETE"*/
75
76 },
77
78 /* next state and actions for SCR_REQUEST state */
79 {
80 {CONT_SCAN_STATE_SCR_REQUEST, actionUnexpected}, /*"START_SCAN",*/
81 {CONT_SCAN_STATE_SCANNING, scanConcentratorRoamingContSM_startScan}, /*"SCR_RUN",*/
82 {CONT_SCAN_STATE_SCR_WAIT, actionNop}, /*"SCR_PEND", */
83 {CONT_SCAN_STATE_IDLE, scanConcentratorRoamingContSM_scanRejected}, /*"SCR_REJECT",*/
84 {CONT_SCAN_STATE_SCR_REQUEST, actionUnexpected}, /*"ABORT_SCAN"*/
85 {CONT_SCAN_STATE_SCR_REQUEST, actionUnexpected}, /*"FW_RESET"*/
86 {CONT_SCAN_STATE_SCR_REQUEST, actionUnexpected}, /*"STOP_SCAN"*/
87 {CONT_SCAN_STATE_SCR_REQUEST, actionUnexpected} /*"SCAN_COMPLETE"*/
88 },
89
90 /* next state and actions for SCR_WAIT state */
91 {
92 {CONT_SCAN_STATE_SCR_WAIT, actionUnexpected}, /*"START_SCAN",*/
93 {CONT_SCAN_STATE_SCANNING, scanConcentratorRoamingContSM_startScan}, /*"SCR_RUN",*/
94 {CONT_SCAN_STATE_SCR_WAIT, actionNop}, /*"SCR_PEND", */
95 {CONT_SCAN_STATE_IDLE, scanConcentratorRoamingContSM_scanRejected}, /*"SCR_REJECT",*/
96 {CONT_SCAN_STATE_SCR_WAIT, actionUnexpected}, /*"ABORT_SCAN"*/
97 {CONT_SCAN_STATE_SCR_WAIT, actionUnexpected}, /*"FW_RESET"*/
98 {CONT_SCAN_STATE_IDLE, scanConcentratorRoamingContSM_scanRejected}, /*"STOP_SCAN"*/
99 {CONT_SCAN_STATE_SCR_WAIT, actionUnexpected} /*"SCAN_COMPLETE"*/
100 },
101
102 /* next state and actions for SCANNING state */
103 {
104 {CONT_SCAN_STATE_SCANNING, actionUnexpected}, /*"START_SCAN",*/
105 {CONT_SCAN_STATE_SCANNING, actionUnexpected}, /*"SCR_RUN",*/
106 {CONT_SCAN_STATE_SCANNING, actionUnexpected}, /*"SCR_PEND", */
107 {CONT_SCAN_STATE_SCANNING, actionUnexpected}, /*"SCR_REJECT",*/
108 {CONT_SCAN_STATE_STOPPING, scanConcentratorRoamingContSM_abortScan}, /*"ABORT_SCAN"*/
109 {CONT_SCAN_STATE_SCANNING, scanConcentratorRoamingContSM_recoveryDuringScan}, /*"FW_RESET"*/
110 {CONT_SCAN_STATE_STOPPING, scanConcentratorRoamingContSM_abortScan}, /*"STOP_SCAN"*/
111 {CONT_SCAN_STATE_IDLE, scanConcentratorRoamingContSM_scanComplete} /*"SCAN_COMPLETE"*/
112 },
113
114 /* next state and actions for STOPPING state */
115 {
116 {CONT_SCAN_STATE_STOPPING, actionUnexpected}, /*"START_SCAN",*/
117 {CONT_SCAN_STATE_STOPPING, actionUnexpected}, /*"SCR_RUN",*/
118 {CONT_SCAN_STATE_STOPPING, actionUnexpected}, /*"SCR_PEND", */
119 {CONT_SCAN_STATE_STOPPING, actionUnexpected}, /*"SCR_REJECT",*/
120 {CONT_SCAN_STATE_STOPPING, actionNop}, /*"ABORT_SCAN"*/
121 {CONT_SCAN_STATE_STOPPING, scanConcentratorRoamingContSM_recoveryDuringScan}, /*"FW_RESET"*/
122 {CONT_SCAN_STATE_STOPPING, actionNop}, /*"STOP_SCAN"*/
123 {CONT_SCAN_STATE_IDLE, scanConcentratorRoamingContSM_scanComplete} /*"SCAN_COMPLETE"*/
124 }
125 };
126
127 /* initialize current state */
128 pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ] = CONT_SCAN_STATE_IDLE;
129
130 /* configure the state machine */
131 return fsm_Config( pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_CONT ], (fsm_Matrix_t)smMatrix,
132 CONT_SCAN_NUM_OF_STATES, CONT_SCAN_NUM_OF_EVENTS,
133 (fsm_eventActivation_t)scanConcentratorRoamingContSM_SMEvent, pScanConcentrator->hOS );
134 }
135
136
137 #ifdef REPORT_LOG
138
139 /* state descriptions, for state machine logging */
140 static char stateDesc[ CONT_SCAN_NUM_OF_STATES ][ MAX_DESC_STRING_LEN ] =
141 {
142 "STATE_IDLE",
143 "STATE_SCR_REQUEST",
144 "STATE_SCR_WAIT",
145 "STATE_SCANNING",
146 "STATE_STOPPING"
147 };
148
149 /* event descriptions, for state machine logging */
150 static char eventDesc[ CONT_SCAN_NUM_OF_EVENTS ][ MAX_DESC_STRING_LEN ] =
151 {
152 "EVENT_START_SCAN",
153 "EVENT_SCR_RUN",
154 "EVENT_SCR_PEND",
155 "EVENT_SCR_REJECT",
156 "EVENT_ABORT_SCAN",
157 "EVENT_FW_RESET",
158 "EVENT_STOP_SCAN",
159 "EVENT_SCAN_COMPLETE"
160 };
161
162 #endif
163
164
165 /**
166 * \author Ronen Kalish\n
167 * \date 02-Jan-2005\n
168 * \brief Processes an event.
169 *
170 * Function Scope \e Public.\n
171 * \param hScanCncn - handle to the scan concentrator object.\n
172 * \param currentState - the current continuous scan for roaming SM state.\n
173 * \param event - the event to handle.\n
174 * \return OK if successful, NOK otherwise.\n
175 */
scanConcentratorRoamingContSM_SMEvent(TI_HANDLE hScanCncn,scan_contSMStates_e * currentState,scan_contSMEvents_e event)176 TI_STATUS scanConcentratorRoamingContSM_SMEvent( TI_HANDLE hScanCncn, scan_contSMStates_e* currentState,
177 scan_contSMEvents_e event )
178 {
179 scanConcentrator_t *pScanConcentrator = (scanConcentrator_t *)hScanCncn;
180 TI_STATUS status = OK;
181 UINT8 nextState;
182
183 /* obtain the next state */
184 status = fsm_GetNextState( pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_CONT ], *(UINT8*)currentState, (UINT8)event, &nextState );
185 if ( status != OK )
186 {
187 WLAN_REPORT_SM( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, ("Failed getting continuous scan for roaming next state.\n") );
188 return NOK;
189 }
190
191 /* report the move */
192 WLAN_REPORT_SM( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
193 ("CONT ROAMING SCAN: <%s, %s> --> %s\n\n",
194 stateDesc[(UINT8)*currentState],
195 eventDesc[(UINT8)event],
196 stateDesc[nextState]) );
197
198 /* move */
199 return fsm_Event( pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_CONT ], (UINT8*)currentState,
200 (UINT8)event, hScanCncn );
201 }
202
203 /**
204 * \author Ronen Kalish\n
205 * \date 02-Jan-2005\n
206 * \brief SM action - handles a start scan event (by requesting the SCR)
207 *
208 * Function Scope \e Public.\n
209 * \param hScanCncn - handle to the scan concentrator object.\n
210 * \return OK if successful, NOK otherwise.\n
211 */
scanConcentratorRoamingContSM_requestSCR(TI_HANDLE hScanCncn)212 TI_STATUS scanConcentratorRoamingContSM_requestSCR( TI_HANDLE hScanCncn )
213 {
214 scr_clientRequestStatus_e scrReplyStatus;
215 scr_pendReason_e scrPendReason;
216 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
217
218 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
219 ("CONT SM: Requesting SCR.\n") );
220
221 /* request the SCR as continuous roaming client, and act according to return status */
222 switch ( scrReplyStatus = scr_clientRequest( pScanConcentrator->hSCR, SCR_CID_CONT_SCAN, &scrPendReason ) )
223 {
224 case SCR_CRS_PEND:
225 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
226 ("CONT SM: SCR pending, pend Reason: %d.\n", scrPendReason) );
227
228 if ( SCR_PR_DIFFERENT_GROUP_RUNNING == scrPendReason )
229 {
230 /* send a reject event to the SM - will not scan if not in connected group */
231 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_FAILED;
232 return scanConcentratorRoamingContSM_SMEvent( hScanCncn,
233 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
234 CONT_SCAN_EVENT_SCR_REJECT );
235 }
236 else
237 {
238 /* send a pend event to the SM */
239 return scanConcentratorRoamingContSM_SMEvent( hScanCncn,
240 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
241 CONT_SCAN_EVENT_SCR_PEND );
242 }
243 /* break; - unreachable */
244
245 case SCR_CRS_RUN:
246 /* send a run event to the SM */
247 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
248 ("CONT SM: SCR acquired.\n") );
249 return scanConcentratorRoamingContSM_SMEvent( hScanCncn,
250 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
251 CONT_SCAN_EVENT_SCR_RUN );
252 /* break; - unreachable */
253
254 default:
255 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
256 ("CONT SM: SCR returned unrecognized status: %d.\n", scrReplyStatus) );
257 /* Notify scan complete to recover from this error */
258 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_FAILED;
259 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
260 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
261 CONT_SCAN_EVENT_SCAN_COMPLETE );
262 return NOK;
263 /* break; - unreachable */
264 }
265
266 /* return OK; - unreachable */
267 }
268
269 /**
270 * \author Ronen Kalish\n
271 * \date 02-Jan-2005\n
272 * \brief SM action - handles a SCR run event (by starting the actual scan)
273 *
274 * Function Scope \e Public.\n
275 * \param hScanCncn - handle to the scan concentrator object.\n
276 * \return OK if successful, NOK otherwise.\n
277 */
scanConcentratorRoamingContSM_startScan(TI_HANDLE hScanCncn)278 TI_STATUS scanConcentratorRoamingContSM_startScan( TI_HANDLE hScanCncn )
279 {
280 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
281 TI_STATUS status;
282
283 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
284 ("CONT SM: Sending scan command to scan SRV.\n") );
285
286 /* mark that this scan is currently running */
287 pScanConcentrator->currentRunningScanClient = SCAN_SCC_ROAMING_CONT;
288
289 /* register for scan results with the MLME parser */
290 if ( OK != mlmeParser_registerForBeaconAndProbeResp( pScanConcentrator->hMlme,
291 scanConcentrator_mlmeResultCB,
292 hScanCncn ) )
293 {
294 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
295 ("CONT SM: MLME result registration failed.\n") );
296
297 /* mark the return status */
298 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_FAILED;
299
300 /* could not start scan, send a scan complete event */
301 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
302 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
303 CONT_SCAN_EVENT_SCAN_COMPLETE );
304
305 return NOK;
306 }
307
308 /* stop built-in test timer, to avoid TX stuck due to heavy traffic and unknown scan result time originally at scanSrv*/
309 healthMonitor_suspendPeriodicTest( pScanConcentrator->hHealthMonitor );
310
311 /* call the scan SRV start scan */
312 if ( OK != (status = MacServices_scanSRV_scan( pScanConcentrator->hMacServices,
313 &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ]),
314 FALSE,
315 TRUE,
316 FALSE,
317 POWER_SAVE_ON,
318 TRUE ,
319 NULL,NULL)) )
320 {
321 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
322 ("CONT SM: scan SRV returned status %d, quitting continuous scan.\n", status) );
323
324 /* mark the return status */
325 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_FAILED;
326
327 /* unregister at the MLME for scan result frames */
328 mlmeParser_unregisterForBeaconAndProbeResp( pScanConcentrator->hMlme );
329
330 /* could not start scan, send a scan complete event */
331 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
332 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
333 CONT_SCAN_EVENT_SCAN_COMPLETE );
334
335 return NOK;
336 }
337
338 return OK;
339 }
340
341 /**
342 * \author Ronen Kalish\n
343 * \date 02-Jan-2005\n
344 * \brief SM action - handles a stop scan or abort scan event (by stopping the actual scan)
345 *
346 * Function Scope \e Public.\n
347 * \param hScanCncn - handle to the scan concentrator object.\n
348 * \return OK if successful, NOK otherwise.\n
349 */
scanConcentratorRoamingContSM_abortScan(TI_HANDLE hScanCncn)350 TI_STATUS scanConcentratorRoamingContSM_abortScan( TI_HANDLE hScanCncn )
351 {
352 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
353 BOOLEAN bSendNullData;
354
355 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
356 ("CONT SM: aborting scan.\n") );
357 bSendNullData = (pScanConcentrator->bAbortOrStop == SCAN_CNCN_STOP) ? TRUE : FALSE;
358
359 /* call the scan SRV stop scan */
360 MacServices_scanSRV_stopScan( pScanConcentrator->hMacServices, bSendNullData, NULL , NULL );
361
362 return OK;
363 }
364
365 /**
366 * \author Ronen Kalish\n
367 * \date 10-July-2005\n
368 * \brief SM action - handles a recovery event (calls the scan SRV abort on FW reset and than finishes scan)
369 *
370 * Function Scope \e Public.\n
371 * \param hScanCncn - handle to the scan concentrator object.\n
372 * \return OK if successful, NOK otherwise.\n
373 */
scanConcentratorRoamingContSM_recoveryDuringScan(TI_HANDLE hScanCncn)374 TI_STATUS scanConcentratorRoamingContSM_recoveryDuringScan( TI_HANDLE hScanCncn )
375 {
376 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
377
378 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
379 ("CONT SM: Recovery occured!.\n") );
380
381 /* reset the scan SRV */
382 MacServices_scanSRV_stopOnFWReset( pScanConcentrator->hMacServices );
383
384 /* send a scan complete event to the SM */
385 return scanConcentratorRoamingContSM_SMEvent( hScanCncn,
386 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
387 CONT_SCAN_EVENT_SCAN_COMPLETE );
388 }
389
390 /**
391 * \author Ronen Kalish\n
392 * \date 02-Jan-2005\n
393 * \brief SM action - handles a scan complete event (by releasing the SCR and calling the scan complete CB).
394 *
395 * Function Scope \e Public.\n
396 * \param hScanCncn - handle to the scan concentrator object.\n
397 * \return OK if successful, NOK otherwise.\n
398 */
scanConcentratorRoamingContSM_scanComplete(TI_HANDLE hScanCncn)399 TI_STATUS scanConcentratorRoamingContSM_scanComplete( TI_HANDLE hScanCncn )
400 {
401 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
402
403 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
404 ("CONT SM: Scan is complete.\n") );
405
406 /* unregister at the MLME for scan result frames */
407 mlmeParser_unregisterForBeaconAndProbeResp( pScanConcentrator->hMlme );
408
409 /* mark that this scan is no longer running */
410 pScanConcentrator->currentRunningScanClient = SCAN_SCC_NO_CLIENT;
411
412 /* release the SCR */
413 scr_clientComplete( pScanConcentrator->hSCR, SCR_CID_CONT_SCAN );
414
415 /* notify the scan complete to the scan mngr */
416 if ( FALSE == pScanConcentrator->bInRequest )
417 {
418 pScanConcentrator->scanResultCB[ SCAN_SCC_ROAMING_CONT ]( pScanConcentrator->scanResultCBObj[ SCAN_SCC_ROAMING_CONT ],
419 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ],
420 NULL, pScanConcentrator->SPSScanResult );
421 }
422
423 return OK;
424 }
425
426 /**
427 * \author Ronen Kalish\n
428 * \date 02-Jan-2005\n
429 * \brief SM action - handles a scan reject event (abort scan before scan actually started)\n
430 *
431 * Function Scope \e Public.\n
432 * \param hScanCncn - handle to the scan concentrator object.\n
433 * \return OK if successful, NOK otherwise.\n
434 */
scanConcentratorRoamingContSM_scanRejected(TI_HANDLE hScanCncn)435 TI_STATUS scanConcentratorRoamingContSM_scanRejected( TI_HANDLE hScanCncn )
436 {
437 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
438
439 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
440 ("CONT SM: Scan is rejected.\n") );
441
442 /* release the SCR */
443 scr_clientComplete( pScanConcentrator->hSCR, SCR_CID_CONT_SCAN );
444
445 /* notify the scan complete to the scan mngr */
446 if ( FALSE == pScanConcentrator->bInRequest )
447 {
448 pScanConcentrator->scanResultCB[ SCAN_SCC_ROAMING_CONT ]( pScanConcentrator->scanResultCBObj[ SCAN_SCC_ROAMING_CONT ],
449 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ],
450 NULL, pScanConcentrator->SPSScanResult );
451 }
452
453 return OK;
454 }
455
456 /**
457 * \author Ronen Kalish\n
458 * \date 11-Jan-2005\n
459 * \brief Handles an unexpected event.\n
460 *
461 * Function Scope \e Private.\n
462 * \param hScanCncn - handle to the scan concentrator object.\n
463 * \return always OK.\n
464 */
actionUnexpected(TI_HANDLE hScanCncn)465 TI_STATUS actionUnexpected( TI_HANDLE hScanCncn )
466 {
467 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
468
469 WLAN_REPORT_ERROR( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, ("Continuous scan for roaming state machine error, unexpected Event, state=%d\n\n",
470 pScanConcentrator->clientSMState[SCAN_SCC_ROAMING_CONT]) );
471
472 return OK;
473 }
474
475 /**
476 * \author Ronen Kalish\n
477 * \date 10-Jan-2005\n
478 * \brief Handles an event that doesn't require any action.\n
479 *
480 * Function Scope \e Private.\n
481 * \param hScanCncn - handle to the scan concentrator object.\n
482 * \return always OK.\n
483 */
actionNop(TI_HANDLE hScanCncn)484 TI_STATUS actionNop( TI_HANDLE hScanCncn )
485 {
486 return OK;
487 }
488
489