1 /** \file ScanCncnOidSM.c 2 * \brief This file include the scan concentrator OID request SM module implementation 3 * \author Ronen Kalish 4 * \date 11-May-2006 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 "ScanCncnOidSM.h" 42 #include "ScanCncn.h" 43 #include "report.h" 44 #include "osApi.h" 45 #include "fsm.h" 46 #include "siteMgrApi.h" 47 #include "regulatoryDomainApi.h" 48 49 static TI_STATUS actionUnexpected( TI_HANDLE hScanCncn ); 50 51 /** 52 * \author Ronen Kalish\n 53 * \date 14-May-2006\n 54 * \brief Initialize the scan concentrator OID scan SM. 55 * 56 * Function Scope \e Public.\n 57 * \param hScanCncn - handle to the scan concentrator object.\n 58 * \return OK if successful, NOK otherwise.\n 59 */ 60 TI_STATUS scanConcentratorOidSM_init( TI_HANDLE hScanCncn ) 61 { 62 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 63 64 fsm_actionCell_t smMatrix[ OID_SCAN_NUM_OF_STATES ][ OID_SCAN_NUM_OF_EVENTS ] = 65 { 66 /* next state and actions for IDLE state */ 67 { 68 {OID_SCAN_STATE_SCAN_ON_G, scanConcentratorOidSM_actionStartGScan}, //"START_SCAN", 69 {OID_SCAN_STATE_IDLE, actionUnexpected}, //"SCAN_COMPLETE", 70 {OID_SCAN_STATE_IDLE, actionUnexpected}, //"SCAN_FAILED", 71 }, 72 73 /* next state and actions for SCAN_ON_G state */ 74 { 75 {OID_SCAN_STATE_SCAN_ON_G, actionUnexpected}, //"START_SCAN", 76 {OID_SCAN_STATE_SCAN_ON_A, scanConcentratorOidSM_actionStartAScan}, //"SCAN_COMPLETE", 77 {OID_SCAN_STATE_SCAN_ON_A, scanConcentratorOidSM_actionStartAScan}, //"SCAN_FAILED", 78 }, 79 80 /* next state and actions for SCAN_ON_A state */ 81 { 82 {OID_SCAN_STATE_SCAN_ON_A, actionUnexpected}, //"START_SCAN", 83 {OID_SCAN_STATE_IDLE, scanConcentratorOidSM_actionCleanup}, //"SCAN_COMPLETE", 84 {OID_SCAN_STATE_IDLE, scanConcentratorOidSM_actionCleanup}, //"SCAN_FAILED", 85 } 86 }; 87 88 /* initialize current state */ 89 pScanConcentrator->oidSMState = OID_SCAN_STATE_IDLE; 90 pScanConcentrator->bOidScanRunning = FALSE; 91 pScanConcentrator->oidScanLastTimeStamp = 0; 92 93 /* configure the state machine */ 94 return fsm_Config( pScanConcentrator->hOidSM, (fsm_Matrix_t)smMatrix, 95 OID_SCAN_NUM_OF_STATES, OID_SCAN_NUM_OF_EVENTS, 96 (fsm_eventActivation_t)scanConcentratorOidSM_SMEvent, pScanConcentrator->hOS ); 97 } 98 99 #ifdef REPORT_LOG 100 /* state descriptions, for state machine logging */ 101 static char stateDesc[ OID_SCAN_NUM_OF_STATES ][ MAX_DESC_STRING_LEN ] = 102 { 103 "STATE_IDLE", 104 "STATE_SCAN_ON_G", 105 "STATE_SCAN_ON_A" 106 }; 107 108 /* event descriptions, for state machine logging */ 109 static char eventDesc[ OID_SCAN_NUM_OF_EVENTS ][ MAX_DESC_STRING_LEN ] = 110 { 111 "EVENT_START_SCAN", 112 "EVENT_SCAN_COMPLETE", 113 "EVENT_SCAN_FAILED" 114 }; 115 #endif 116 117 /** 118 * \author Ronen Kalish\n 119 * \date 11-May-2006\n 120 * \brief Processes an event. 121 * 122 * Function Scope \e Public.\n 123 * \param hScanCncn - handle to the scan concentrator object.\n 124 * \param currentState - the current OID request SM state.\n 125 * \param event - the event to handle.\n 126 * \return OK if successful, NOK otherwise.\n 127 */ 128 TI_STATUS scanConcentratorOidSM_SMEvent( TI_HANDLE hScanCncn, scan_oidSMStates_e* currentState, 129 scan_oidSMEvents_e event ) 130 { 131 scanConcentrator_t *pScanConcentrator = (scanConcentrator_t *)hScanCncn; 132 TI_STATUS status = OK; 133 UINT8 nextState; 134 135 /* obtain the next state */ 136 status = fsm_GetNextState( pScanConcentrator->hOidSM, (UINT8)*currentState, 137 (UINT8)event, &nextState ); 138 if ( status != OK ) 139 { 140 WLAN_REPORT_SM( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, ("Failed getting OID scan next state.\n") ); 141 return NOK; 142 } 143 144 /* report the move */ 145 WLAN_REPORT_SM( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, 146 ("OID SCAN: <%s, %s> --> %s\n\n", 147 stateDesc[(UINT8)*currentState], 148 eventDesc[(UINT8)event], 149 stateDesc[nextState]) ); 150 151 /* move */ 152 return fsm_Event( pScanConcentrator->hOidSM, (UINT8*)currentState, (UINT8)event, hScanCncn ); 153 } 154 155 /** 156 * \author Ronen Kalish\n 157 * \date 11-May-2006\n 158 * \brief SM action - starts a scan on G band 159 * 160 * Function Scope \e Public.\n 161 * \param hScanCncn - handle to the scan concentrator object.\n 162 * \return OK if successful, NOK otherwise.\n 163 */ 164 TI_STATUS scanConcentratorOidSM_actionStartGScan( TI_HANDLE hScanCncn ) 165 { 166 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 167 paramInfo_t param; 168 int validChannelsCount; 169 BOOL regulatoryDomainEnabled; 170 171 /* if the STA is not configured for G band or dual band, send a scan complete event to the SM */ 172 param.paramType = SITE_MGR_DESIRED_DOT11_MODE_PARAM; 173 siteMgr_getParam( pScanConcentrator->hSiteManager, ¶m ); 174 if ( (DOT11_G_MODE != param.content.siteMgrDot11Mode) && (DOT11_DUAL_MODE != param.content.siteMgrDot11Mode) ) 175 { 176 WLAN_REPORT_INFORMATION( pScanConcentrator->hOS, SCAN_CNCN_MODULE_LOG, 177 ("Scan OID SM: STA does not work on 2.4 GHz, continuing to 5.0 GHz scan\n") ); 178 scanConcentratorOidSM_SMEvent( hScanCncn, (scan_oidSMStates_e*)&(pScanConcentrator->oidSMState), OID_SCAN_EVENT_SCAN_FAILED ); 179 return OK; 180 } 181 182 /* build scan command header */ 183 pScanConcentrator->oidScanParams.band = RADIO_BAND_2_4_GHZ; 184 pScanConcentrator->oidScanParams.desiredSsid.len = 0; 185 pScanConcentrator->oidScanParams.desiredSsid.ssidString[ 0 ] = '\0'; /* broadcast scan */ 186 pScanConcentrator->oidScanParams.Tid = 0; 187 188 /* query the regulatory domain if 802.11d is in use */ 189 param.paramType = REGULATORY_DOMAIN_ENABLED_PARAM; 190 regulatoryDomain_getParam( pScanConcentrator->hRegulatoryDomain,¶m ); 191 regulatoryDomainEnabled = param.content.regulatoryDomainEnabled; 192 193 /* Get country code status */ 194 param.paramType = REGULATORY_DOMAIN_IS_COUNTRY_FOUND; 195 param.content.eRadioBand = RADIO_BAND_2_4_GHZ; 196 regulatoryDomain_getParam(pScanConcentrator->hRegulatoryDomain,¶m); 197 198 /* scan type is passive if 802.11d is enabled and country IE was not yet found, active otherwise */ 199 if ( (TRUE == regulatoryDomainEnabled) && 200 (FALSE == param.content.bIsCountryFound) ) 201 { 202 pScanConcentrator->oidScanParams.scanType = SCAN_TYPE_NORMAL_PASSIVE; 203 } 204 else 205 { 206 pScanConcentrator->oidScanParams.scanType = SCAN_TYPE_NORMAL_ACTIVE; 207 /* also set number and rate of probe requests */ 208 pScanConcentrator->oidScanParams.probeReqNumber = SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_G; 209 pScanConcentrator->oidScanParams.probeRequestRate = SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_G; 210 } 211 212 /* add supported channels on G */ 213 if ( SCAN_TYPE_NORMAL_PASSIVE == pScanConcentrator->oidScanParams.scanType ) 214 { 215 validChannelsCount = scanConcentratorOidSM_FillAllAvailableChannels( hScanCncn, RADIO_BAND_2_4_GHZ, SCAN_TYPE_NORMAL_PASSIVE, 216 &(pScanConcentrator->oidScanParams.channelEntry[0]), 217 SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_G, 218 SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_G, 219 SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_G, 220 SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_G ); 221 } 222 else 223 { 224 validChannelsCount = scanConcentratorOidSM_FillAllAvailableChannels( hScanCncn, RADIO_BAND_2_4_GHZ, SCAN_TYPE_NORMAL_ACTIVE, 225 &(pScanConcentrator->oidScanParams.channelEntry[0]), 226 SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_G, 227 SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_G, 228 SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_G, 229 SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_G ); 230 } 231 pScanConcentrator->oidScanParams.numOfChannels = validChannelsCount; 232 233 /* check that some channels are available */ 234 if ( validChannelsCount > 0 ) 235 { 236 scan_cncnResultStatus_e res; 237 238 /* 239 * Prepare scan complete's aging, by increasing the scanned sites 240 * scan attemps counter. The counter will be checked upon scan complete, 241 * and the sites with no update scan results will be dropped. 242 */ 243 siteMgr_setNotReceivedParameter( pScanConcentrator->hSiteManager, &(pScanConcentrator->oidScanParams.desiredSsid), 244 RADIO_BAND_2_4_GHZ ); 245 246 /* send command to scan concentrator APP SM */ 247 res = scanConcentrator_scan(hScanCncn, SCAN_SCC_APP, &(pScanConcentrator->oidScanParams) ); 248 249 /* if scan failed, send scan failed event to the SM */ 250 if ( SCAN_CRS_SCAN_RUNNING != res ) 251 { 252 scanConcentratorOidSM_SMEvent( hScanCncn, (scan_oidSMStates_e*)&(pScanConcentrator->oidSMState), OID_SCAN_EVENT_SCAN_FAILED ); 253 } 254 } 255 else 256 { 257 /* no channels to scan, send a scan failed event */ 258 scanConcentratorOidSM_SMEvent( hScanCncn, (scan_oidSMStates_e*)&(pScanConcentrator->oidSMState), OID_SCAN_EVENT_SCAN_FAILED ); 259 } 260 261 return OK; 262 } 263 264 /** 265 * \author Ronen Kalish\n 266 * \date 11-May-2006\n 267 * \brief SM action - starts a scan on A band 268 * 269 * Function Scope \e Public.\n 270 * \param hScanCncn - handle to the scan concentrator object.\n 271 * \return OK if successful, NOK otherwise.\n 272 */ 273 TI_STATUS scanConcentratorOidSM_actionStartAScan( TI_HANDLE hScanCncn ) 274 { 275 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 276 paramInfo_t param; 277 int validChannelsCount; 278 BOOL regulatoryDomainEnabled; 279 280 /* if the STA is not configured for G band or dual band, send a scan complete event to the SM */ 281 param.paramType = SITE_MGR_DESIRED_DOT11_MODE_PARAM; 282 siteMgr_getParam( pScanConcentrator->hSiteManager, ¶m ); 283 if ( (DOT11_A_MODE != param.content.siteMgrDot11Mode) && (DOT11_DUAL_MODE != param.content.siteMgrDot11Mode) ) 284 { 285 WLAN_REPORT_INFORMATION( pScanConcentrator->hOS, SCAN_CNCN_MODULE_LOG, 286 ("Scan OID SM: STA does not work on 5.0 GHz, quitting\n") ); 287 scanConcentratorOidSM_SMEvent( hScanCncn, (scan_oidSMStates_e*)&(pScanConcentrator->oidSMState), OID_SCAN_EVENT_SCAN_FAILED ); 288 return OK; 289 } 290 291 /* build scan command header */ 292 pScanConcentrator->oidScanParams.band = RADIO_BAND_5_0_GHZ; 293 pScanConcentrator->oidScanParams.desiredSsid.len = 0; 294 pScanConcentrator->oidScanParams.desiredSsid.ssidString[ 0 ] = '\0'; /* broadcast scan */ 295 pScanConcentrator->oidScanParams.Tid = 0; 296 297 /* query the regulatory domain if 802.11d is in use */ 298 param.paramType = REGULATORY_DOMAIN_ENABLED_PARAM; 299 regulatoryDomain_getParam( pScanConcentrator->hRegulatoryDomain,¶m ); 300 regulatoryDomainEnabled = param.content.regulatoryDomainEnabled; 301 302 /* Get country code status */ 303 param.paramType = REGULATORY_DOMAIN_IS_COUNTRY_FOUND; 304 param.content.eRadioBand = RADIO_BAND_5_0_GHZ; 305 regulatoryDomain_getParam(pScanConcentrator->hRegulatoryDomain,¶m); 306 307 /* scan type is passive if 802.11d is enabled and country IE was not yet found, active otherwise */ 308 if ( (TRUE == regulatoryDomainEnabled) && 309 (FALSE == param.content.bIsCountryFound) ) 310 { 311 pScanConcentrator->oidScanParams.scanType = SCAN_TYPE_NORMAL_PASSIVE; 312 } 313 else 314 { 315 pScanConcentrator->oidScanParams.scanType = SCAN_TYPE_NORMAL_ACTIVE; 316 /* also set number and rate of probe requests */ 317 pScanConcentrator->oidScanParams.probeReqNumber = SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_A; 318 pScanConcentrator->oidScanParams.probeRequestRate = SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_A; 319 } 320 321 /* add supported channels on G */ 322 if ( SCAN_TYPE_NORMAL_PASSIVE == pScanConcentrator->oidScanParams.scanType ) 323 { 324 validChannelsCount = scanConcentratorOidSM_FillAllAvailableChannels( hScanCncn, RADIO_BAND_5_0_GHZ, SCAN_TYPE_NORMAL_PASSIVE, 325 &(pScanConcentrator->oidScanParams.channelEntry[0]), 326 SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_A, 327 SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_A, 328 SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_A, 329 SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_A ); 330 } 331 else 332 { 333 validChannelsCount = scanConcentratorOidSM_FillAllAvailableChannels( hScanCncn, RADIO_BAND_5_0_GHZ, SCAN_TYPE_NORMAL_ACTIVE, 334 &(pScanConcentrator->oidScanParams.channelEntry[0]), 335 SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_A, 336 SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_A, 337 SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_A, 338 SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_A ); 339 } 340 pScanConcentrator->oidScanParams.numOfChannels = validChannelsCount; 341 342 /* check that some channels are available */ 343 if ( validChannelsCount > 0 ) 344 { 345 scan_cncnResultStatus_e res; 346 347 /* 348 * Prepare scan complete's aging, by increasing the scanned sites 349 * scan attemps counter. The counter will be checked upon scan complete, 350 * and the sites with no update scan results will be dropped. 351 */ 352 siteMgr_setNotReceivedParameter( pScanConcentrator->hSiteManager, &(pScanConcentrator->oidScanParams.desiredSsid), 353 RADIO_BAND_5_0_GHZ ); 354 355 /* send command to scan concentrator APP SM */ 356 res = scanConcentrator_scan(hScanCncn, SCAN_SCC_APP, &(pScanConcentrator->oidScanParams) ); 357 358 /* if scan failed, send scan failed event to the SM */ 359 if ( SCAN_CRS_SCAN_RUNNING != res ) 360 { 361 scanConcentratorOidSM_SMEvent( hScanCncn, (scan_oidSMStates_e*)&(pScanConcentrator->oidSMState), OID_SCAN_EVENT_SCAN_FAILED ); 362 } 363 } 364 else 365 { 366 /* no channels to scan, send a scan failed event */ 367 scanConcentratorOidSM_SMEvent( hScanCncn, (scan_oidSMStates_e*)&(pScanConcentrator->oidSMState), OID_SCAN_EVENT_SCAN_FAILED ); 368 } 369 370 return OK; 371 } 372 373 /** 374 * \author Ronen Kalish\n 375 * \date 14-May-2006\n 376 * \brief SM action - Cleans up an OID scan operation 377 * 378 * Function Scope \e Public.\n 379 * \param hScanCncn - handle to the scan concentrator object.\n 380 * \return OK if successful, NOK otherwise.\n 381 */ 382 TI_STATUS scanConcentratorOidSM_actionCleanup( TI_HANDLE hScanCncn ) 383 { 384 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 385 386 /* mark that OID scan process is no longer running */ 387 pScanConcentrator->bOidScanRunning = FALSE; 388 389 390 return OK; 391 } 392 393 /** 394 * \author Ronen Kalish\n 395 * \date 14-May-2006\n 396 * \brief Fills a chhanel array with valid channels (and their params) according to band and scan type\n 397 * 398 * Function Scope \e Public.\n 399 * \param hScanCncn - handle to the scan concentrator object.\n 400 * \param band - band to extract channels for.\n 401 * \param scanType - scan type tp ectract channels for.\n 402 * \param channelArray - where to store allowed channels information.\n 403 * \param maxDwellTime - maximum dwell time value to be used for each channel.\n 404 * \param minDwellTime - minimum dwell time value to be used for each channel.\n 405 * \param ETCondition - early termination condition value to be used for each channel.\n 406 * \param ETFrameNumber - early termination frame number value to be used for each channel.\n 407 * \return Number of allowed channels (that were placed in the given channels array).\n 408 */ 409 UINT32 scanConcentratorOidSM_FillAllAvailableChannels( TI_HANDLE hScanCncn, radioBand_e band, scan_Type_e scanType, 410 scan_channelEntry_u* channelArray, UINT32 maxDwellTime, 411 UINT32 minChannelTime, scan_ETCondition_e ETCondition, 412 UINT8 ETFrameNumber ) 413 { 414 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 415 int i, j, allowedChannelsCount, validChannelsCnt = 0; 416 paramInfo_t param; 417 UINT8 tempChannelList[ SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND ]; 418 419 /* get the numnber of supported channels for this band */ 420 param.paramType = REGULATORY_DOMAIN_ALL_SUPPORTED_CHANNELS; 421 param.content.siteMgrRadioBand = band; 422 regulatoryDomain_getParam( pScanConcentrator->hRegulatoryDomain, ¶m ); 423 allowedChannelsCount = param.content.supportedChannels.sizeOfList; 424 425 /* for the time being don't scan more channels than fit in one command */ 426 if ( allowedChannelsCount > SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND ) 427 { 428 allowedChannelsCount = SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND; 429 } 430 431 /* Copy allowed channels to reuse param var */ 432 os_memoryCopy( pScanConcentrator->hOS, tempChannelList, 433 param.content.supportedChannels.listOfChannels, allowedChannelsCount ); 434 435 /* preapre the param var to request channel allowance for the requested scan type */ 436 param.paramType = REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES; 437 param.content.channelCapabilityReq.band = band; 438 439 /* add default values to channels allowed for the requested scan type and band */ 440 for ( i = 0; i < allowedChannelsCount; i++ ) 441 { 442 /* get specific channel allowance for scan type */ 443 if ( (scanType == SCAN_TYPE_NORMAL_PASSIVE) || 444 (scanType == SCAN_TYPE_TRIGGERED_PASSIVE) || 445 (scanType == SCAN_TYPE_SPS) ) 446 { 447 param.content.channelCapabilityReq.scanOption = PASSIVE_SCANNING; 448 } 449 else 450 { 451 param.content.channelCapabilityReq.scanOption = ACTIVE_SCANNING; 452 } 453 param.content.channelCapabilityReq.channelNum = tempChannelList[ i ]; 454 455 regulatoryDomain_getParam( pScanConcentrator->hRegulatoryDomain, ¶m ); 456 if ( TRUE == param.content.channelCapabilityRet.channelValidity ) 457 { 458 /* add the channel ID */ 459 channelArray[ validChannelsCnt ].normalChannelEntry.channel = tempChannelList[ i ]; 460 461 /* add other default parameters */ 462 channelArray[ validChannelsCnt ].normalChannelEntry.minChannelDwellTime = minChannelTime; 463 channelArray[ validChannelsCnt ].normalChannelEntry.maxChannelDwellTime = maxDwellTime; 464 channelArray[ validChannelsCnt ].normalChannelEntry.earlyTerminationEvent = ETCondition; 465 channelArray[ validChannelsCnt ].normalChannelEntry.ETMaxNumOfAPframes = ETFrameNumber; 466 channelArray[ validChannelsCnt ].normalChannelEntry.txPowerDbm = 467 param.content.channelCapabilityRet.maxTxPowerDbm; 468 /* Fill broadcast BSSID */ 469 for ( j = 0; j < 6; j++ ) 470 { 471 channelArray[ validChannelsCnt ].normalChannelEntry.bssId.addr[ j ] = 0xff; 472 } 473 validChannelsCnt++; 474 } 475 } 476 477 /* return the number of channels that are actually allowed for the requested scan type on the requested band */ 478 return validChannelsCnt; 479 } 480 481 /** 482 * \author Ronen Kalish\n 483 * \date 11-Jan-2005\n 484 * \brief Handles an unexpected event.\n 485 486 * 487 * Function Scope \e Private.\n 488 * \param hScanCncn - handle to the scan concentrator object.\n 489 * \return always OK.\n 490 */ 491 TI_STATUS actionUnexpected( TI_HANDLE hScanCncn ) 492 { 493 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn; 494 495 WLAN_REPORT_SM( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, ("OID scan state machine error, unexpected Event\n\n") ); 496 497 return OK; 498 } 499 500 501 502
