1/**************************************************************************** 2**+-----------------------------------------------------------------------+** 3**| |** 4**| Copyright(c) 1998 - 2008 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****************************************************************************/ 35 36/** \file smeSmApi.c 37 * \brief SME SM API implementation 38 * 39 * The state machine itself is implemented in the file smeSm.c. 40 * 41 * \see smeSmApi.h 42 */ 43 44#include "report.h" 45#include "osTIType.h" 46#include "osApi.h" 47#include "smeSm.h" 48#include "smeApi.h" 49#include "smeSmApi.h" 50#include "utils.h" 51#include "802_11Defs.h" 52#include "regulatoryDomainApi.h" 53#include "siteMgrApi.h" 54#include "connApi.h" 55#include "EvHandler.h" 56#include "TI_IPC_Api.h" 57 58 59#define WLAN_INTER_SCAN_DELTA 10 60 61/* State machine definitions */ 62#define SME_INIT_BIT 1 63#define SM_INIT_BIT 2 64#define TIMER_INIT_BIT 3 65 66/* Local functions prototypes */ 67 68static void release_module(smeSm_t *pSmeSm, UINT32 initVec); 69 70void smeSm_InterScanTimeoutCB(TI_HANDLE hSmeSm); 71 72 73/* Interface functions Implementation */ 74 75/************************************************************************ 76 * smeSm_create * 77 ************************************************************************ 78DESCRIPTION: SME SM module creation function, called by the config mgr in creation phase 79 performs the following: 80 - Allocate the SME SM handle 81 - Create the SME state machine 82 83INPUT: hOs - Handle to OS 84 85 86OUTPUT: 87 88RETURN: Handle to the SME SM module on success, NULL otherwise 89 90************************************************************************/ 91TI_HANDLE smeSm_create(TI_HANDLE hOs) 92{ 93 smeSm_t *pSmeSm; 94 UINT32 initVec; 95 96 initVec = 0; 97 98 pSmeSm = os_memoryAlloc(hOs, sizeof(smeSm_t)); 99 if (pSmeSm == NULL) 100 return NULL; 101 os_memoryZero(hOs, pSmeSm, sizeof(smeSm_t)); /* Dm: Fix */ 102 103 initVec |= (1 << SME_INIT_BIT); 104 105 pSmeSm->pFsm = smeSm_smCreate(hOs); 106 if (pSmeSm->pFsm == NULL) 107 { 108 release_module(pSmeSm, initVec); 109 return NULL; 110 } 111 112 initVec |= (1 << SM_INIT_BIT); 113 114 pSmeSm->hOs = hOs; 115 116 pSmeSm->interScanTimeoutTimer = os_timerCreate(hOs, smeSm_InterScanTimeoutCB, pSmeSm); 117 if(pSmeSm->interScanTimeoutTimer == NULL) 118 { 119 release_module(pSmeSm, initVec); 120 WLAN_OS_REPORT(("FATAL ERROR: smeSm_create(): Error Creating smeSm - Aborting\n")); 121 return NULL; 122 } 123 initVec |= (1 << TIMER_INIT_BIT); 124 125 return(pSmeSm); 126} 127 128/************************************************************************ 129 * smeSm_config * 130 ************************************************************************ 131DESCRIPTION: SME SM module configuration function, called by the config mgr in configuration phase 132 performs the following: 133 - Reset & initiailzes local variables 134 - Init the handles to be used by the module 135 136INPUT: hSmeSm - SME SM handle 137 List of handles to be used by the module 138 139OUTPUT: 140 141RETURN: OK on success, NOK otherwise 142 143************************************************************************/ 144TI_STATUS smeSm_config(TI_HANDLE hSmeSm, 145 TI_HANDLE hConn, 146 TI_HANDLE hScanCncn, 147 TI_HANDLE hSiteMgr, 148 TI_HANDLE hHalCtrl, 149 TI_HANDLE hReport, 150 TI_HANDLE hOs, 151 TI_HANDLE hEvHandler, 152 TI_HANDLE hScr, 153 TI_HANDLE hApConn, 154 TI_HANDLE hCurrBss, 155 TI_HANDLE hPowerMgr, 156 TI_HANDLE hRegulatoryDomain, 157 smeInitParams_t* smeInitParams) 158 159{ 160 TI_STATUS status; 161 int index; 162 163 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 164 165 pSmeSm->state = SME_SM_STATE_IDLE; 166 pSmeSm->hConn = hConn; 167 pSmeSm->hScanCncn = hScanCncn; 168 pSmeSm->hSiteMgr = hSiteMgr; 169 pSmeSm->hHalCtrl = hHalCtrl; 170 pSmeSm->hReport = hReport; 171 pSmeSm->hOs = hOs; 172 pSmeSm->hEvHandler = hEvHandler; 173 pSmeSm->hScr = hScr; 174 pSmeSm->hApConn = hApConn; 175 pSmeSm->hCurrBss = hCurrBss; 176 pSmeSm->hPowerMgr = hPowerMgr; 177 pSmeSm->hRegulatoryDomain = hRegulatoryDomain; 178 179 /* interscan timeout values */ 180 pSmeSm->scanEnabled = (scanEnabledOptions_e)smeInitParams->EnableFirstConnScan; 181 pSmeSm->interScanTimeoutMin = smeInitParams->InterScanIntervalMin; 182 pSmeSm->interScanTimeoutMax = smeInitParams->InterScanIntervalMax; 183 pSmeSm->interScanTimeoutDelta = smeInitParams->InterScanIntervalDelta; 184 pSmeSm->shutDownStatus = 0; 185 186 187 /* 188 * Setting scan parameters for band 2.4Ghtz 189 */ 190 os_memoryCopy(hOs, &(pSmeSm->scanParamsBG), &(smeInitParams->scanParamsBG), sizeof(sme_scan_Params_t)); 191 /* The channel list is represented as char string terminate in zeros. */ 192 193 for( index = 0; 194 ((index < MAX_NUMBER_OF_CHANNELS_PER_SCAN )&&(pSmeSm->scanParamsBG.channelsList[index] != 0)); 195 index++ ); 196 197 pSmeSm->scanParamsBG.numOfChannels = index; 198 199 /* 200 * Setting scan parameters for band 5.0Ghtz 201 */ 202 os_memoryCopy(hOs, &(pSmeSm->scanParamsA), &(smeInitParams->scanParamsA), sizeof(sme_scan_Params_t)); 203 204 for( index = 0; 205 ((index < MAX_NUMBER_OF_CHANNELS_PER_SCAN )&&(pSmeSm->scanParamsA.channelsList[index] != 0)); 206 index++ ); 207 208 pSmeSm->scanParamsA.numOfChannels = index; 209 210 211 212 /* register to scan result callback */ 213 scanConcentrator_registerScanResultCB( pSmeSm->hScanCncn, SCAN_SCC_DRIVER, smeSm_scanComplete, hSmeSm ); 214 215 status = smeSm_smConfig(pSmeSm); 216 217 if (status != OK) 218 WLAN_REPORT_INIT(hReport, SME_SM_MODULE_LOG, (".....Sme state machine configuration Failure\n")); 219 else 220 WLAN_REPORT_INIT(hReport, SME_SM_MODULE_LOG, (".....Sme state machine configuration Success\n")); 221 222 return status; 223} 224 225/************************************************************************ 226 * smeSm_getDriverShutdownStatus * 227 ************************************************************************ 228DESCRIPTION: Return shutdown status of driver. 229 230INPUT: hSmeSm - SME SM handle. 231 232OUTPUT: 233 234RETURN: shutdown status of driver (SME/HAL) 235 236************************************************************************/ 237UINT8 smeSm_getDriverShutdownStatus (TI_HANDLE hSmeSm) 238{ 239 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 240 return (pSmeSm->shutDownStatus); 241} 242 243 244/************************************************************************ 245 * smeSm_unLoad * 246 ************************************************************************ 247DESCRIPTION: SME SM module unload function, called by the config mgr in the unlod phase 248 performs the following: 249 - Free all memory allocated by the module 250 251INPUT: hSmeSm - SME SM handle. 252 253 254OUTPUT: 255 256RETURN: OK on success, NOK otherwise 257 258************************************************************************/ 259TI_STATUS smeSm_unLoad(TI_HANDLE hSmeSm) 260{ 261 UINT32 initVec; 262 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 263 264 if (!pSmeSm) 265 return OK; 266 267 initVec = 0xFFFF; 268 release_module(pSmeSm, initVec); 269 270 return OK; 271} 272 273/*********************************************************************** 274 * smeSm_start 275 *********************************************************************** 276DESCRIPTION: Called by the configuration module in order to start the driver 277 Calls the SME SM with a start event 278 279INPUT: hSmeSm - SME SM handle. 280 281OUTPUT: 282 283RETURN: OK on success, NOK otherwise 284 285************************************************************************/ 286TI_STATUS smeSm_start(TI_HANDLE hSmeSm) 287{ 288 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 289 290 pSmeSm->radioOn = TRUE; 291 pSmeSm->immediateShutdownRequired = FALSE; 292 293 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_START, pSmeSm); 294} 295 296 297 298/*********************************************************************** 299 * smeSm_restart 300 *********************************************************************** 301DESCRIPTION: Called by the configuration module in order to start the driver 302 Calls the SME SM with a start event 303 304INPUT: hSmeSm - SME SM handle. 305 306OUTPUT: 307 308RETURN: OK on success, NOK otherwise 309 310************************************************************************/ 311TI_STATUS smeSm_reselect(TI_HANDLE hSmeSm) 312{ 313 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 314 paramInfo_t param; 315 316 /* For new SSID reset interScanTimeout */ 317 pSmeSm->interScanTimeout = pSmeSm->interScanTimeoutMin; 318 319 /* 320 Junk SSID is used for disabling connection attempts, if it is 321 set the driver will be stopped at "inter scan" state. 322 */ 323 324 param.paramType = SITE_MGR_DESIRED_SSID_PARAM; 325 siteMgr_getParam(pSmeSm->hSiteMgr, ¶m); 326 327 if (utils_isJunkSSID(¶m.content.siteMgrDesiredSSID)) 328 { 329 pSmeSm->connectEnabled = FALSE; 330 331 WLAN_REPORT_INFORMATION(pSmeSm->hReport, SME_SM_MODULE_LOG, 332 ("Sme Set JUNK SSID\n")); 333 334 if( pSmeSm->state == SME_SM_STATE_SCANNING ) 335 /* If in scanning stop the scan, the disconnect event will 336 be sent by the scan complete function. */ 337 scanConcentrator_stopScan( pSmeSm->hScanCncn, SCAN_SCC_DRIVER ); 338 else 339 smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_DISCONNECT, pSmeSm); 340 } 341 else 342 { 343 pSmeSm->connectEnabled = TRUE; 344 smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_RESELECT, pSmeSm); 345 } 346 347 return OK; 348} 349 350 351/*********************************************************************** 352 * smeSm_stop 353 *********************************************************************** 354DESCRIPTION: Called by the configuration module in order to stop the driver 355 Calls the SME SM with a stop event 356 357INPUT: hSmeSm - SME SM handle. 358 359OUTPUT: 360 361RETURN: OK on success, NOK otherwise 362 363************************************************************************/ 364TI_STATUS smeSm_stop(TI_HANDLE hSmeSm) 365{ 366 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 367 368 pSmeSm->radioOn = FALSE; 369 pSmeSm->immediateShutdownRequired = FALSE; 370 371 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_STOP, pSmeSm); 372} 373 374/*********************************************************************** 375 * smeSm_stopAndShutdown 376 *********************************************************************** 377DESCRIPTION: Called by the configuration module in order to stop the driver 378 Calls the SME SM with a stop event 379 380INPUT: hSmeSm - SME SM handle. 381 382OUTPUT: 383 384RETURN: OK on success, NOK otherwise 385 386************************************************************************/ 387void smeSm_stopAndShutdown(TI_HANDLE hSmeSm) 388{ 389 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 390 391 pSmeSm->radioOn = FALSE; 392 pSmeSm->immediateShutdownRequired = TRUE; 393 394 smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_STOP, pSmeSm); 395} 396 397/*********************************************************************** 398 * smeSm_scanComplete 399 *********************************************************************** 400DESCRIPTION: Called by the site manager When scan is completed 401 Calls the SME SM with a scan complete event 402 403INPUT: hSmeSm - SME SM handle. 404 405OUTPUT: 406 407RETURN: OK on success, NOK otherwise 408 409************************************************************************/ 410void smeSm_scanComplete( TI_HANDLE hSmeSm, scan_cncnResultStatus_e status, 411 scan_frameInfo_t *frameInfo, UINT16 SPSStatus ) 412{ 413 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 414 415 /* if this call is due to a scan result received, simply store it in the site mngr */ 416 if ( SCAN_CRS_RECEIVED_FRAME == status ) 417 { 418 siteMgr_updateSite( pSmeSm->hSiteMgr, frameInfo->bssId, frameInfo->parsedIEs, frameInfo->channel, frameInfo->band, FALSE); 419 if ( BEACON == frameInfo->parsedIEs->subType ) 420 { 421 siteMgr_saveBeaconBuffer( pSmeSm->hSiteMgr, frameInfo->bssId, frameInfo->buffer, frameInfo->bufferLength ); 422 } 423 else 424 { 425 siteMgr_saveProbeRespBuffer( pSmeSm->hSiteMgr, frameInfo->bssId, frameInfo->buffer, frameInfo->bufferLength ); 426 } 427#ifdef TI_DBG 428 /* update statistics - count one more result that was received */ 429 pSmeSm->smeStats.currentNumberOfScanResults++; 430#endif 431 return; 432 } 433 434#ifdef TI_DBG 435 /* update statistics - update scan results histogram */ 436 if ( SCAN_RESULT_HISTOGRAM_SIZE <= pSmeSm->smeStats.currentNumberOfScanResults ) 437 { 438 pSmeSm->smeStats.scanResulCountHistogram[ SCAN_RESULT_HISTOGRAM_SIZE -1 ]++; 439 } 440 else 441 { 442 pSmeSm->smeStats.scanResulCountHistogram[ pSmeSm->smeStats.currentNumberOfScanResults ]++; 443 } 444 pSmeSm->smeStats.currentNumberOfScanResults = 0; 445#endif 446 447 WLAN_REPORT_INFORMATION(pSmeSm->hReport, SME_SM_MODULE_LOG, 448 ("smeSm_scanComplete\n")); 449 450 siteMgr_removeNotReceivedSites(pSmeSm->hSiteMgr); 451 452 if ( pSmeSm->connectEnabled ) 453 { 454 /* check for rescan and perform scan when it is on */ 455 if ( TRUE == pSmeSm->reScanFlag ) 456 { 457 WLAN_REPORT_INFORMATION( pSmeSm->hReport, SME_SM_MODULE_LOG, 458 ("SME_SM: doing additional scan due to reScanFlag = ON\n") ); 459 pSmeSm->reScanFlag = FALSE; 460 sme_startScan(pSmeSm); 461 } 462 /* check for dual band rescan */ 463 else if ( TRUE == pSmeSm->dualBandReScanFlag ) 464 { 465 WLAN_REPORT_INFORMATION( pSmeSm->hReport, SME_SM_MODULE_LOG, 466 ("SME_SM: doing additional scan due to dualBandReScanFlag = ON\n") ); 467 sme_startScan(pSmeSm); 468 } 469 else 470 { 471 smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_SCAN_COMPLETE, pSmeSm); 472 } 473 } 474 else 475 { 476 /* If connection is disabled then send disconnect event, the SM will 477 * move into inter scan state 478 */ 479 pSmeSm->reScanFlag = FALSE; /* (Just to make sure) */ 480 pSmeSm->dualBandReScanFlag = FALSE; 481 smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_DISCONNECT, pSmeSm); 482 } 483} 484 485 486/*********************************************************************** 487 * smeSm_reportConnStatus 488 *********************************************************************** 489DESCRIPTION: Called by the connection module when connection status changes 490 Calls the SME SM with a connection suceess or connection failure based on the status 491 492INPUT: hSmeSm - SME SM handle. 493 statusType - Connection status 494 uStatusCode - extra information to statusType (usually status code of the packet) 495 496OUTPUT: 497 498RETURN: OK on success, NOK otherwise 499 500************************************************************************/ 501TI_STATUS smeSm_reportConnStatus(TI_HANDLE hSmeSm, mgmtStatus_e statusType, UINT32 uStatusCode) 502{ 503 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 504 505 WLAN_REPORT_INFORMATION(pSmeSm->hReport, SME_SM_MODULE_LOG, 506 ("%s statusType = %d, uStatusCode = %d \n",__FUNCTION__, statusType, uStatusCode)); 507 508 switch(statusType) 509 { 510 case STATUS_SUCCESSFUL: 511 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_CONN_SUCCESS, pSmeSm); 512 513 /* 514 * The next section handles connection failures, all cases are sending same event to SM. 515 */ 516 case STATUS_AUTH_REJECT: 517 case STATUS_ASSOC_REJECT: 518 case STATUS_SECURITY_FAILURE: 519 case STATUS_AP_DEAUTHENTICATE: 520 case STATUS_AP_DISASSOCIATE: 521 case STATUS_ROAMING_TRIGGER: 522 pSmeSm->DisAssoc.mgmtStatus = statusType; 523 pSmeSm->DisAssoc.uStatusCode = uStatusCode; 524 /* Note that in case of unspecified status we won't update the status. This is done since this function could be called twice */ 525 /* for example: apConn called this function and than SME called conn_stop and this function is called again */ 526 case STATUS_UNSPECIFIED: 527 528 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_CONN_FAILURE, pSmeSm); 529 530 default: 531 WLAN_REPORT_WARNING(pSmeSm->hReport, SME_SM_MODULE_LOG, 532 ("%s unknown statusType = %d\n",__FUNCTION__, statusType)); 533 534 break; 535 } 536 537 return OK; 538} 539 540/*********************************************************************** 541 * smeSm_reportSelectStatus 542 *********************************************************************** 543DESCRIPTION: Called by the selection function 544 Calls the SME SM with a selection suceess or selection failure based on the status 545 546INPUT: hSmeSm - SME SM handle. 547 status - selection status 548 549OUTPUT: 550 551RETURN: OK on success, NOK otherwise 552 553************************************************************************/ 554TI_STATUS smeSm_reportSelectStatus(TI_HANDLE hSmeSm, 555 mgmtStatus_e status) 556{ 557 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 558 559 if (status == SELECT_STATUS_SUCCESS) 560 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_SELECT_SUCCESS, pSmeSm); 561 else 562 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_SELECT_FAILURE, pSmeSm); 563} 564 565 566/*********************************************************************** 567 * smeSm_startScan 568 *********************************************************************** 569DESCRIPTION: Timer callback, on expiration of which, scan started 570 571INPUT: hSmeSm - SME SM handle. 572 573OUTPUT: 574 575RETURN: OK on success, NOK otherwise 576 577************************************************************************/ 578void smeSm_InterScanTimeoutCB(TI_HANDLE hSmeSm) 579{ 580 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 581 582 if ( pSmeSm->connectEnabled ) 583 { 584 pSmeSm->interScanTimeout += pSmeSm->interScanTimeoutDelta; 585 586 if( pSmeSm->interScanTimeout > pSmeSm->interScanTimeoutMax ) 587 pSmeSm->interScanTimeout = pSmeSm->interScanTimeoutMax; 588 589 smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_RESELECT, pSmeSm); 590 } 591} 592 593 594/*********************************************************************** 595 * release_module 596 *********************************************************************** 597DESCRIPTION: Called by the un load function 598 Go over the vector, for each bit that is set, release the corresponding module. 599 600INPUT: hConn - SME SM handle. 601 pSmeSm - Vector that contains a bit set for each module thah had been initiualized 602 603OUTPUT: 604 605RETURN: OK on success, NOK otherwise 606 607************************************************************************/ 608static void release_module(smeSm_t *pSmeSm, UINT32 initVec) 609{ 610 611 if (initVec & (1 << SM_INIT_BIT)) 612 smeSm_smUnLoad(pSmeSm->hOs, pSmeSm->pFsm); 613 614 if (initVec & (1 << TIMER_INIT_BIT)) 615 { 616 os_timerStop(pSmeSm->hOs, pSmeSm->interScanTimeoutTimer); 617 utils_nullTimerDestroy(pSmeSm->hOs, pSmeSm->interScanTimeoutTimer); 618 } 619 620 if (initVec & (1 << SME_INIT_BIT)) 621 utils_nullMemoryFree(pSmeSm->hOs, pSmeSm, sizeof(smeSm_t)); 622 623 624 initVec = 0; 625} 626 627/*********************************************************************** 628 * smeSm_setParam 629 *********************************************************************** 630DESCRIPTION: SME SM set param function, called by the following: 631 - config mgr in order to set a parameter from the OS abstraction layer. 632 - Form inside the driver 633 634INPUT: hSmeSm - SME SM handle. 635 pParam - Pointer to the parameter 636 637OUTPUT: 638 639RETURN: OK on success, NOK otherwise 640 641************************************************************************/ 642TI_STATUS smeSm_setParam(TI_HANDLE hSmeSm, 643 paramInfo_t *pParam) 644{ 645 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 646 647 switch(pParam->paramType) 648 { 649 case SME_SCAN_ENABLED_PARAM: 650 if (pSmeSm->scanEnabled != pParam->content.smeSMScanEnabled) 651 { 652 if ((pParam->content.smeSMScanEnabled == SCAN_ENABLED) && 653 (pSmeSm->scanEnabled == SKIP_NEXT_SCAN)) 654 { 655 /* Requested to st scanEnable to TRUE; 656 if we are about to skip the nextcoming scan, ignore the request */ 657 break; 658 } 659 if ((pParam->content.smeSMScanEnabled == SKIP_NEXT_SCAN) && 660 (pSmeSm->scanEnabled == SCAN_DISABLED)) 661 { 662 /* Requested to st scanEnable to SKIP_NEXT_SCAN 663 while it is currently set to FALSE - error, ignore the request */ 664 WLAN_REPORT_ERROR( pSmeSm->hReport, SME_SM_MODULE_LOG, 665 ("Set param, error changing scan enabled param from %d to %d\n", 666 pSmeSm->scanEnabled, pParam->content.smeSMScanEnabled)); 667 break; 668 } 669 pSmeSm->scanEnabled = pParam->content.smeSMScanEnabled; 670 } 671 break; 672 673 default: 674 WLAN_REPORT_ERROR( pSmeSm->hReport, SME_SM_MODULE_LOG, 675 ("Set param, Params is not supported, %d\n\n", pParam->paramType)); 676 return PARAM_NOT_SUPPORTED; 677 } 678 679 return OK; 680} 681 682/*********************************************************************** 683 * smeSm_getParam 684 *********************************************************************** 685DESCRIPTION: SME SM get param function, called by the following: 686 - config mgr in order to get a parameter from the OS abstraction layer. 687 - Fomr inside the dirver 688 689INPUT: hSmeSm - SME SM handle. 690 pParam - Pointer to the parameter 691 692OUTPUT: 693 694RETURN: OK on success, NOK otherwise 695 696************************************************************************/ 697TI_STATUS smeSm_getParam(TI_HANDLE hSmeSm, 698 paramInfo_t *pParam) 699{ 700 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm; 701 702 switch(pParam->paramType) 703 { 704 case SITE_MGR_CONNECTION_STATUS_PARAM: 705 switch (pSmeSm->state) 706 { 707 case SME_SM_STATE_IDLE: 708 case SME_SM_STATE_INTER_SCAN: 709 pParam->content.smeSmConnectionStatus = eDot11Idle; 710 break; 711 case SME_SM_STATE_SCANNING: 712 pParam->content.smeSmConnectionStatus = eDot11Scaning; 713 break; 714 case SME_SM_STATE_CONNECTING: 715 pParam->content.smeSmConnectionStatus = eDot11Connecting; 716 break; 717 default: 718 pParam->content.smeSmConnectionStatus = eDot11Associated; 719 break; 720 } 721 break; 722 723 case SME_SM_STATE_PARAM: 724 pParam->content.smeSmState = pSmeSm->state; 725 break; 726 727 case SME_SCAN_ENABLED_PARAM: 728 pParam->content.smeSMScanEnabled = pSmeSm->scanEnabled; 729 break; 730 731 default: 732 WLAN_REPORT_ERROR(pSmeSm->hReport, SME_SM_MODULE_LOG, ("Get param, Params is not supported, %d\n\n", pParam->paramType)); 733 return PARAM_NOT_SUPPORTED; 734 } 735 736 return OK; 737} 738