1 /** \file ScanCncnRoamingImmedSM.c 2 * \brief This file include the scan concentrator immediate 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 "ScanCncnRoamingImmedSM.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 extern BOOLEAN apConn_isPsRequiredBeforeScan(TI_HANDLE hAPConnection); 51 52 /** 53 * \author Ronen Kalish\n 54 * \date 02-Jan-2005\n 55 * \brief Initialize the scan concentrator immediate scan for roaming SM. 56 * 57 * Function Scope \e Public.\n 58 * \param hScanCncn - handle to the scan concentrator object.\n 59 * \return OK if successful, NOK otherwise.\n 60 */ 61 TI_STATUS scanConcentratorRoamingImmedSM_init( TI_HANDLE hScanCncn ) 62 { 63 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 64 65 fsm_actionCell_t smMatrix[ IMMED_SCAN_NUM_OF_STATES ][ IMMED_SCAN_NUM_OF_EVENTS ] = 66 { 67 /* next state and actions for IDLE state */ 68 { 69 {IMMED_SCAN_STATE_SCR_REQUEST, scanConcentratorRoamingImmedSM_requestSCR}, /*"START_SCAN",*/ 70 {IMMED_SCAN_STATE_IDLE, actionUnexpected}, /*"SCR_RUN",*/ 71 {IMMED_SCAN_STATE_IDLE, actionUnexpected}, /*"SCR_PEND", */ 72 {IMMED_SCAN_STATE_IDLE, actionUnexpected}, /*"SCR_REJECT",*/ 73 {IMMED_SCAN_STATE_IDLE, actionUnexpected}, /*"ABORT_SCAN"*/ 74 {IMMED_SCAN_STATE_IDLE, actionUnexpected}, /*"FW_RESET"*/ 75 {IMMED_SCAN_STATE_IDLE, actionNop}, /*"STOP_SCAN"*/ 76 {IMMED_SCAN_STATE_IDLE, actionUnexpected} /*"SCAN_COMPLETE"*/ 77 78 }, 79 80 /* next state and actions for SCR_REQUEST state */ 81 { 82 {IMMED_SCAN_STATE_SCR_REQUEST, actionUnexpected}, /*"START_SCAN",*/ 83 {IMMED_SCAN_STATE_SCANNING, scanConcentratorRoamingImmedSM_startScan}, /*"SCR_RUN",*/ 84 {IMMED_SCAN_STATE_SCR_WAIT, actionNop}, /*"SCR_PEND", */ 85 {IMMED_SCAN_STATE_IDLE, scanConcentratorRoamingImmedSM_scanRejected}, /*"SCR_REJECT",*/ 86 {IMMED_SCAN_STATE_SCR_REQUEST, actionUnexpected}, /*"ABORT_SCAN"*/ 87 {IMMED_SCAN_STATE_SCR_REQUEST, actionUnexpected}, /*"FW_RESET"*/ 88 {IMMED_SCAN_STATE_SCR_REQUEST, actionUnexpected}, /*"STOP_SCAN"*/ 89 {IMMED_SCAN_STATE_SCR_REQUEST, actionUnexpected} /*"SCAN_COMPLETE"*/ 90 }, 91 92 /* next state and actions for SCR_WAIT state */ 93 { 94 {IMMED_SCAN_STATE_SCR_WAIT, actionUnexpected}, /*"START_SCAN",*/ 95 {IMMED_SCAN_STATE_SCANNING, scanConcentratorRoamingImmedSM_startScan}, /*"SCR_RUN",*/ 96 {IMMED_SCAN_STATE_SCR_WAIT, actionNop}, /*"SCR_PEND", */ 97 {IMMED_SCAN_STATE_IDLE, scanConcentratorRoamingImmedSM_scanRejected}, /*"SCR_REJECT",*/ 98 {IMMED_SCAN_STATE_SCR_WAIT, actionUnexpected}, /*"ABORT_SCAN"*/ 99 {IMMED_SCAN_STATE_SCR_WAIT, actionUnexpected}, /*"FW_RESET"*/ 100 {IMMED_SCAN_STATE_IDLE, scanConcentratorRoamingImmedSM_scanRejected}, /*"STOP_SCAN"*/ 101 {IMMED_SCAN_STATE_SCR_WAIT, actionUnexpected} /*"SCAN_COMPLETE"*/ 102 }, 103 104 /* next state and actions for SCANNING state */ 105 { 106 {IMMED_SCAN_STATE_SCANNING, actionUnexpected}, /*"START_SCAN",*/ 107 {IMMED_SCAN_STATE_SCANNING, actionUnexpected}, /*"SCR_RUN",*/ 108 {IMMED_SCAN_STATE_SCANNING, actionUnexpected}, /*"SCR_PEND", */ 109 {IMMED_SCAN_STATE_SCANNING, actionUnexpected}, /*"SCR_REJECT",*/ 110 {IMMED_SCAN_STATE_STOPPING, scanConcentratorRoamingImmedSM_abortScan}, /*"ABORT_SCAN"*/ 111 {IMMED_SCAN_STATE_SCANNING, scanConcentratorRoamingImmedSM_recoveryDuringScan},/*"FW_RESET"*/ 112 {IMMED_SCAN_STATE_STOPPING, scanConcentratorRoamingImmedSM_abortScan}, /*"STOP_SCAN"*/ 113 {IMMED_SCAN_STATE_IDLE, scanConcentratorRoamingImmedSM_scanComplete} /*"SCAN_COMPLETE"*/ 114 }, 115 116 /* next state and actions for STOPPING state */ 117 { 118 {IMMED_SCAN_STATE_STOPPING, actionUnexpected}, /*"START_SCAN",*/ 119 {IMMED_SCAN_STATE_STOPPING, actionUnexpected}, /*"SCR_RUN",*/ 120 {IMMED_SCAN_STATE_STOPPING, actionUnexpected}, /*"SCR_PEND", */ 121 {IMMED_SCAN_STATE_STOPPING, actionUnexpected}, /*"SCR_REJECT",*/ 122 {IMMED_SCAN_STATE_STOPPING, actionNop}, /*"ABORT_SCAN"*/ 123 {IMMED_SCAN_STATE_STOPPING, scanConcentratorRoamingImmedSM_recoveryDuringScan},/*"FW_RESET"*/ 124 {IMMED_SCAN_STATE_STOPPING, actionNop}, /*"STOP_SCAN"*/ 125 {IMMED_SCAN_STATE_IDLE, scanConcentratorRoamingImmedSM_scanComplete} /*"SCAN_COMPLETE"*/ 126 } 127 }; 128 129 /* initialize current state */ 130 pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ] = IMMED_SCAN_STATE_IDLE; 131 132 /* configure the state machine */ 133 return fsm_Config( pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_IMMED ], (fsm_Matrix_t)smMatrix, 134 IMMED_SCAN_NUM_OF_STATES, IMMED_SCAN_NUM_OF_EVENTS, 135 (fsm_eventActivation_t)scanConcentratorRoamingImmedSM_SMEvent, pScanConcentrator->hOS ); 136 } 137 138 139 #ifdef REPORT_LOG 140 141 /* state descriptions, for state machine logging */ 142 static char stateDesc[ IMMED_SCAN_NUM_OF_STATES ][ MAX_DESC_STRING_LEN ] = 143 { 144 "STATE_IDLE", 145 "STATE_SCR_REQUEST", 146 "STATE_SCR_WAIT", 147 "STATE_SCANNING", 148 "STATE_STOPPING" 149 }; 150 151 /* event descriptions, for state machine logging */ 152 static char eventDesc[ IMMED_SCAN_NUM_OF_EVENTS ][ MAX_DESC_STRING_LEN ] = 153 { 154 "EVENT_START_SCAN", 155 "EVENT_SCR_RUN", 156 "EVENT_SCR_PEND", 157 "EVENT_SCR_REJECT", 158 "EVENT_ABORT_SCAN", 159 "EVENT_FW_RESET", 160 "EVENT_STOP_SCAN", 161 "EVENT_SCAN_COMPLETE" 162 }; 163 164 #endif 165 166 /** 167 * \author Ronen Kalish\n 168 * \date 02-Jan-2005\n 169 * \brief Processes an event. 170 * 171 * Function Scope \e Public.\n 172 * \param hScanCncn - handle to the scan concentrator object.\n 173 * \param currentState - the current immediate scan for roaming SM state.\n 174 * \param event - the event to handle.\n 175 * \return OK if successful, NOK otherwise.\n 176 */ 177 TI_STATUS scanConcentratorRoamingImmedSM_SMEvent( TI_HANDLE hScanCncn, scan_immedSMStates_e* currentState, 178 scan_immedSMEvents_e event ) 179 { 180 scanConcentrator_t *pScanConcentrator = (scanConcentrator_t *)hScanCncn; 181 TI_STATUS status = OK; 182 UINT8 nextState; 183 184 /* obtain the next state */ 185 status = fsm_GetNextState( pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_IMMED ], 186 *(UINT8*)currentState, (UINT8)event, &nextState ); 187 if ( status != OK ) 188 { 189 WLAN_REPORT_SM( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 190 ("Failed getting immediate scan for roaming next state.\n") ); 191 return NOK; 192 } 193 194 /* report the move */ 195 WLAN_REPORT_SM( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 196 ("IMMED ROAMING SCAN: <%s, %s> --> %s\n\n", 197 stateDesc[(UINT8)*currentState], 198 eventDesc[(UINT8)event], 199 stateDesc[nextState]) ); 200 201 /* move */ 202 return fsm_Event( pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_IMMED ], (UINT8*)currentState, 203 (UINT8)event, hScanCncn ); 204 } 205 206 /** 207 * \author Ronen Kalish\n 208 * \date 02-Jan-2005\n 209 * \brief SM action - handles a start scan event (by requesting the SCR) 210 * 211 * Function Scope \e Public.\n 212 * \param hScanCncn - handle to the scan concentrator object.\n 213 * \return OK if successful, NOK otherwise.\n 214 */ 215 TI_STATUS scanConcentratorRoamingImmedSM_requestSCR( TI_HANDLE hScanCncn ) 216 { 217 scr_clientRequestStatus_e scrReplyStatus; 218 scr_pendReason_e scrPendReason; 219 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 220 221 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 222 ("IMMED SM: Requesting SCR.\n") ); 223 224 /* request the SCR as immediate roaming client, and act according to return status */ 225 switch ( scrReplyStatus = scr_clientRequest( pScanConcentrator->hSCR, SCR_CID_IMMED_SCAN, &scrPendReason ) ) 226 { 227 case SCR_CRS_PEND: 228 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 229 ("IMMED SM: SCR pending, pend Reason: %d.\n", scrPendReason) ); 230 231 if ( SCR_PR_DIFFERENT_GROUP_RUNNING == scrPendReason ) 232 { 233 /* send a reject event to the SM - will not scan if not in connected group */ 234 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] = SCAN_CRS_SCAN_FAILED; 235 return scanConcentratorRoamingImmedSM_SMEvent( hScanCncn, 236 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]), 237 IMMED_SCAN_EVENT_SCR_REJECT ); 238 } 239 else 240 { 241 /* send a pend event to the SM */ 242 return scanConcentratorRoamingImmedSM_SMEvent( hScanCncn, 243 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]), 244 IMMED_SCAN_EVENT_SCR_PEND ); 245 } 246 /* break; - unreachable */ 247 248 case SCR_CRS_RUN: 249 /* send a run event to the SM */ 250 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 251 ("IMMED SM: SCR acquired.\n") ); 252 return scanConcentratorRoamingImmedSM_SMEvent( hScanCncn, 253 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]), 254 IMMED_SCAN_EVENT_SCR_RUN ); 255 /* break; - unreachable */ 256 257 default: 258 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 259 ("IMMED SM: SCR returned unrecognized status: %d.\n", scrReplyStatus) ); 260 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] = SCAN_CRS_SCAN_FAILED; 261 /* Notify scan complete to recover from this error */ 262 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn, 263 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]), 264 IMMED_SCAN_EVENT_SCAN_COMPLETE ); 265 return NOK; 266 /* break; - unreachable */ 267 } 268 269 /* return OK; - unreachable */ 270 } 271 272 /** 273 * \author Ronen Kalish\n 274 * \date 02-Jan-2005\n 275 * \brief SM action - handles a SCR run event (by starting the actual scan) 276 * 277 * Function Scope \e Public.\n 278 * \param hScanCncn - handle to the scan concentrator object.\n 279 * \return OK if successful, NOK otherwise.\n 280 */ 281 TI_STATUS scanConcentratorRoamingImmedSM_startScan( TI_HANDLE hScanCncn ) 282 { 283 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 284 TI_STATUS status; 285 BOOLEAN psRequest; 286 287 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 288 ("IMMED SM: Sending scan command to scan SRV.\n") ); 289 290 /* mark that this scan is currently running */ 291 pScanConcentrator->currentRunningScanClient = SCAN_SCC_ROAMING_IMMED; 292 293 /* register for scan results with the MLME parser */ 294 if ( OK != mlmeParser_registerForBeaconAndProbeResp( pScanConcentrator->hMlme, 295 scanConcentrator_mlmeResultCB, 296 hScanCncn ) ) 297 { 298 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 299 ("IMMED SM: MLME result registration failed.\n") ); 300 301 /* mark the return status */ 302 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] = SCAN_CRS_SCAN_FAILED; 303 304 /* could not start scan, send a scan complete event */ 305 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn, 306 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]), 307 IMMED_SCAN_EVENT_SCAN_COMPLETE ); 308 309 return NOK; 310 } 311 312 /* stop built-in test timer, to avoid TX stuck due to heavy traffic and unknown scan result time originally at scanSrv*/ 313 healthMonitor_suspendPeriodicTest( pScanConcentrator->hHealthMonitor ); 314 315 psRequest = apConn_isPsRequiredBeforeScan(pScanConcentrator->hAPConn); 316 317 /* call the scan SRV start scan */ 318 if ( OK != (status = MacServices_scanSRV_scan( pScanConcentrator->hMacServices, 319 &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ]), 320 ( (SCAN_TYPE_TRIGGERED_ACTIVE == pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].scanType) || 321 (SCAN_TYPE_TRIGGERED_PASSIVE == pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].scanType) 322 ? FALSE : TRUE ), /* Triggered scan cannot be high priority */ 323 TRUE, 324 TRUE, 325 ( psRequest ? POWER_SAVE_ON : POWER_SAVE_KEEP_CURRENT ), 326 psRequest, 327 NULL,NULL)) ) 328 { 329 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 330 ("IMMED SM: scan SRV returned status %d, quitting immediate scan.\n", status) ); 331 332 /* mark the return status */ 333 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] = SCAN_CRS_SCAN_FAILED; 334 335 /* unregister at the MLME for scan result frames */ 336 mlmeParser_unregisterForBeaconAndProbeResp( pScanConcentrator->hMlme ); 337 338 /* could not start scan, send a scan complete event */ 339 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn, 340 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]), 341 IMMED_SCAN_EVENT_SCAN_COMPLETE ); 342 343 return NOK; 344 } 345 346 return OK; 347 } 348 349 /** 350 * \author Ronen Kalish\n 351 * \date 02-Jan-2005\n 352 * \brief SM action - handles a stop scan or abort scan event (by stopping the actual scan) 353 * 354 * Function Scope \e Public.\n 355 * \param hScanCncn - handle to the scan concentrator object.\n 356 * \return OK if successful, NOK otherwise.\n 357 */ 358 TI_STATUS scanConcentratorRoamingImmedSM_abortScan( TI_HANDLE hScanCncn ) 359 { 360 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 361 BOOLEAN bSendNullData; 362 363 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 364 ("IMMED SM: aborting scan.\n") ); 365 366 bSendNullData = (pScanConcentrator->bAbortOrStop == SCAN_CNCN_STOP) ? TRUE : FALSE; 367 368 /* call the scan SRV stop scan */ 369 MacServices_scanSRV_stopScan( pScanConcentrator->hMacServices, bSendNullData , NULL , NULL ); 370 371 return OK; 372 } 373 374 /** 375 * \author Ronen Kalish\n 376 * \date 10-July-2005\n 377 * \brief SM action - handles a recovery event (calls the scan SRV abort on FW reset and than finishes scan) 378 * 379 * Function Scope \e Public.\n 380 * \param hScanCncn - handle to the scan concentrator object.\n 381 * \return OK if successful, NOK otherwise.\n 382 */ 383 TI_STATUS scanConcentratorRoamingImmedSM_recoveryDuringScan( TI_HANDLE hScanCncn ) 384 { 385 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 386 387 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 388 ("IMMED SM: Recovery occured!.\n") ); 389 390 /* reset the scan SRV */ 391 MacServices_scanSRV_stopOnFWReset( pScanConcentrator->hMacServices ); 392 393 /* send a scan complete event to the SM */ 394 return scanConcentratorRoamingImmedSM_SMEvent( hScanCncn, 395 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]), 396 IMMED_SCAN_EVENT_SCAN_COMPLETE ); 397 } 398 399 /** 400 * \author Ronen Kalish\n 401 * \date 02-Jan-2005\n 402 * \brief SM action - handles a scan complete event (by releasing the SCR and calling the scan complete CB). 403 * 404 * Function Scope \e Public.\n 405 * \param hScanCncn - handle to the scan concentrator object.\n 406 * \return OK if successful, NOK otherwise.\n 407 */ 408 TI_STATUS scanConcentratorRoamingImmedSM_scanComplete( TI_HANDLE hScanCncn ) 409 { 410 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 411 412 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 413 ("IMMED SM: Scan is complete.\n") ); 414 415 /* unregister at the MLME for scan result frames */ 416 mlmeParser_unregisterForBeaconAndProbeResp( pScanConcentrator->hMlme ); 417 418 /* mark that this scan is no longer running */ 419 pScanConcentrator->currentRunningScanClient = SCAN_SCC_NO_CLIENT; 420 421 /* release the SCR */ 422 scr_clientComplete( pScanConcentrator->hSCR, SCR_CID_IMMED_SCAN ); 423 424 /* notify the scan complete to the scan mngr */ 425 if ( FALSE == pScanConcentrator->bInRequest ) 426 { 427 pScanConcentrator->scanResultCB[ SCAN_SCC_ROAMING_IMMED ]( pScanConcentrator->scanResultCBObj[ SCAN_SCC_ROAMING_IMMED ], 428 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ], 429 NULL, 0xffff ); 430 } 431 432 return OK; 433 } 434 435 /** 436 * \author Ronen Kalish\n 437 * \date 02-Jan-2005\n 438 * \brief SM action - handles a scan reject event (abort scan before scan actually started)\n 439 * 440 * Function Scope \e Public.\n 441 * \param hScanCncn - handle to the scan concentrator object.\n 442 * \return OK if successful, NOK otherwise.\n 443 */ 444 TI_STATUS scanConcentratorRoamingImmedSM_scanRejected( TI_HANDLE hScanCncn ) 445 { 446 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 447 448 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 449 ("IMMED SM: Scan is rejected.\n") ); 450 451 /* release the SCR */ 452 scr_clientComplete( pScanConcentrator->hSCR, SCR_CID_IMMED_SCAN ); 453 454 /* notify the scan complete to the scan mngr */ 455 if ( FALSE == pScanConcentrator->bInRequest ) 456 { 457 pScanConcentrator->scanResultCB[ SCAN_SCC_ROAMING_IMMED ]( pScanConcentrator->scanResultCBObj[ SCAN_SCC_ROAMING_IMMED ], 458 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ], 459 NULL, 0xffff ); 460 } 461 462 return OK; 463 } 464 465 /** 466 * \author Ronen Kalish\n 467 * \date 11-Jan-2005\n 468 * \brief Handles an unexpected event.\n 469 * 470 * Function Scope \e Private.\n 471 * \param hScanCncn - handle to the scan concentrator object.\n 472 * \return always OK.\n 473 */ 474 TI_STATUS actionUnexpected( TI_HANDLE hScanCncn ) 475 { 476 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 477 478 WLAN_REPORT_ERROR( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 479 ("Immediate scan for roaming state machine error, unexpected Event, state=%d\n\n", 480 pScanConcentrator->clientSMState[SCAN_SCC_ROAMING_IMMED]) ); 481 482 return OK; 483 } 484 485 /** 486 * \author Ronen Kalish\n 487 * \date 10-Jan-2005\n 488 * \brief Handles an event that doesn't require any action.\n 489 * 490 * Function Scope \e Private.\n 491 * \param hScanCncn - handle to the scan concentrator object.\n 492 * \return always OK.\n 493 */ 494 TI_STATUS actionNop( TI_HANDLE hScanCncn ) 495 { 496 return OK; 497 } 498 499
