diff options
Diffstat (limited to 'wilink_6_1/stad/src/Sta_Management/ScanCncnOsSm.c')
| -rw-r--r-- | wilink_6_1/stad/src/Sta_Management/ScanCncnOsSm.c | 515 |
1 files changed, 515 insertions, 0 deletions
diff --git a/wilink_6_1/stad/src/Sta_Management/ScanCncnOsSm.c b/wilink_6_1/stad/src/Sta_Management/ScanCncnOsSm.c new file mode 100644 index 0000000..8c33f71 --- /dev/null +++ b/wilink_6_1/stad/src/Sta_Management/ScanCncnOsSm.c @@ -0,0 +1,515 @@ +/* + * ScanCncnOsSm.c + * + * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name Texas Instruments nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +/** \file ScanCncnOsSm.c + * \brief Scan concentrator OS scan state machine implementation + * + * \see ScanCncnApp.c + */ + + +#define __FILE_ID__ FILE_ID_78 +#include "osTIType.h" +#include "GenSM.h" +#include "ScanCncnOsSm.h" +#include "ScanCncn.h" +#include "ScanCncnPrivate.h" +#include "report.h" +#include "osApi.h" +#include "siteMgrApi.h" +#include "regulatoryDomainApi.h" +#include "scanResultTable.h" + +#define SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_G RATE_MASK_UNSPECIFIED /* Let the FW select */ +#define SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_A RATE_MASK_UNSPECIFIED /* Let the FW select */ +#define SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_G 3 +#define SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_A 3 +#define SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_G 100000 +#define SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_A 100000 +#define SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_G 30000 +#define SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_A 30000 +#define SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_G 100000 +#define SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_A 100000 +#define SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_G 15000 +#define SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_A 15000 +#define SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_G SCAN_ET_COND_BEACON +#define SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_A SCAN_ET_COND_BEACON +#define SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_G SCAN_ET_COND_ANY_FRAME +#define SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_A SCAN_ET_COND_ANY_FRAME + +/* For WiFi WPA OOB scenario, 4 APs need to be configure on the same channel */ +#define SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_G 4 +#define SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_A 4 +#define SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_G 4 +#define SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_A 4 + +static void scanCncnOsSm_ActionStartGScan (TI_HANDLE hScanCncn); +static void scanCncnOsSm_ActionStartAScan (TI_HANDLE hScanCncn); +static void scanCncnOsSm_ActionCompleteScan (TI_HANDLE hScanCncn); +static void scanCncnOsSm_ActionUnexpected (TI_HANDLE hScanCncn); +TI_UINT32 scanCncnOsSm_FillAllAvailableChannels (TI_HANDLE hScanCncn, ERadioBand eBand, EScanType eScanType, + TScanChannelEntry *pChannelArray, TI_UINT32 uMaxDwellTime, + TI_UINT32 uMinChannelTime, EScanEtCondition eETCondition, + TI_UINT8 uETFrameNumber); + + +static TGenSM_actionCell tSmMatrix[ SCAN_CNCN_OS_SM_NUMBER_OF_STATES ][ SCAN_CNCN_OS_SM_NUMBER_OF_EVENTS ] = + { + { /* SCAN_CNCN_OS_SM_STATE_IDLE */ + { SCAN_CNCN_OS_SM_STATE_SCAN_ON_G, scanCncnOsSm_ActionStartGScan }, /* SCAN_CNCN_OS_SM_EVENT_START_SCAN */ + { SCAN_CNCN_OS_SM_STATE_IDLE, scanCncnOsSm_ActionUnexpected }, /* SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE */ + }, + { /* SCAN_CNCN_OS_SM_STATE_SCAN_ON_G */ + { SCAN_CNCN_OS_SM_STATE_SCAN_ON_G, scanCncnOsSm_ActionUnexpected }, /* SCAN_CNCN_OS_SM_EVENT_START_SCAN */ + { SCAN_CNCN_OS_SM_STATE_SCAN_ON_A, scanCncnOsSm_ActionStartAScan }, /* SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE */ + }, + { /* SCAN_CNCN_OS_SM_STATE_SCAN_ON_A */ + { SCAN_CNCN_OS_SM_STATE_SCAN_ON_A, scanCncnOsSm_ActionUnexpected }, /* SCAN_CNCN_OS_SM_EVENT_START_SCAN */ + { SCAN_CNCN_OS_SM_STATE_IDLE, scanCncnOsSm_ActionCompleteScan }, /* SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE */ + } + }; + +static TI_INT8 *uStateDescription[] = + { + "IDLE", + "SCAN_ON_G", + "SCAN_ON_A" + }; + +static TI_INT8 *uEventDescription[] = + { + "START", + "SCAN_COMPLETE" + }; + +/** + * \fn scanCncnOsSm_Create + * \brief Creates the OS scan state-machine + * + * creates the OS scan state-machine + * + * \param hScanCncn - handle to the scan concentrator object + * \return Handle to the newly created OS san SM, NULL if an error occured + * \sa scanCncnOsSm_Create, scanCncnOsSm_Destroy + */ +TI_HANDLE scanCncnOsSm_Create (TI_HANDLE hScanCncn) +{ + TScanCncn *pScanCncn = (TScanCncn*)hScanCncn; + + return genSM_Create (pScanCncn->hOS); +} + +/** + * \fn scanCncnOsSm_Init + * \brief Initialize the OS scan state-machine + * + * Initialize the OS scan state-machine + * + * \param hScanCncn - handle to the scan concentrator object + * \return None + * \sa scanCncnOsSm_Create + */ +void scanCncnOsSm_Init (TI_HANDLE hScanCncn) +{ + TScanCncn *pScanCncn = (TScanCncn*)hScanCncn; + + /* initialize the state-machine */ + genSM_Init (pScanCncn->hOSScanSm, pScanCncn->hReport); + genSM_SetDefaults (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_NUMBER_OF_STATES, SCAN_CNCN_OS_SM_NUMBER_OF_EVENTS, + (TGenSM_matrix)tSmMatrix, SCAN_CNCN_OS_SM_STATE_IDLE, "OS scan SM", uStateDescription, + uEventDescription, __FILE_ID__); +} + +/** + * \fn scanCncnOsSm_Destroy + * \brief Destroys the OS scan state-machine + * + * Destroys the OS scan state-machine + * + * \param hScanCncn - handle to the scan concentrator object + * \return None + * \sa scanCncnOsSm_Create + */ +void scanCncnOsSm_Destroy (TI_HANDLE hScanCncn) +{ + TScanCncn *pScanCncn = (TScanCncn*)hScanCncn; + + genSM_Unload (pScanCncn->hOSScanSm); +} + +/** + * \fn scanCncnOsSm_ActionStartGScan + * \brief Scan concentartor OS state machine start scan on G action function + * + * Scan concentartor OS state machine start scan on G action function. + * Starts a sacn on G using all allowed channels + * + * \param hScanCncn - handle to the scan concentartor object + * \return None + */ +void scanCncnOsSm_ActionStartGScan (TI_HANDLE hScanCncn) +{ + TScanCncn *pScanCncn = (TScanCncn*)hScanCncn; + paramInfo_t tParam; + TI_UINT32 uValidChannelsCount; + TI_BOOL bRegulatoryDomainEnabled; + + /* if the STA is not configured for G band or dual band, send a scan complete event to the SM */ + tParam.paramType = SITE_MGR_DESIRED_DOT11_MODE_PARAM; + siteMgr_getParam (pScanCncn->hSiteManager, &tParam); + if ((DOT11_G_MODE != tParam.content.siteMgrDot11Mode) && (DOT11_DUAL_MODE != tParam.content.siteMgrDot11Mode)) + { + TRACE0(pScanCncn->hReport , REPORT_SEVERITY_INFORMATION , "scanCncnOsSm_ActionStartGScan: STA does not work on 2.4 GHz, continuing to 5.0 GHz scan\n"); + genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn); + return; + } + + /* build scan command header */ + pScanCncn->tOsScanParams.band = RADIO_BAND_2_4_GHZ; + pScanCncn->tOsScanParams.Tid = 255; + + /* query the regulatory domain if 802.11d is in use */ + tParam.paramType = REGULATORY_DOMAIN_ENABLED_PARAM; + regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam ); + bRegulatoryDomainEnabled = tParam.content.regulatoryDomainEnabled; + + /* Get country code status */ + tParam.paramType = REGULATORY_DOMAIN_IS_COUNTRY_FOUND; + tParam.content.eRadioBand = RADIO_BAND_2_4_GHZ; + regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam); + + /* scan type is passive if 802.11d is enabled and country IE was not yet found, active otherwise */ + if ((TI_TRUE == bRegulatoryDomainEnabled) && (TI_FALSE == tParam.content.bIsCountryFound) ) + { + pScanCncn->tOsScanParams.scanType = SCAN_TYPE_TRIGGERED_PASSIVE; + } + /* All paramters in the func are hard coded, due to that we set to active if not passive */ + else + { + pScanCncn->tOsScanParams.scanType = SCAN_TYPE_TRIGGERED_ACTIVE; + /* also set number and rate of probe requests */ + pScanCncn->tOsScanParams.probeReqNumber = SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_G; + pScanCncn->tOsScanParams.probeRequestRate = SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_G; + } + + /* add supported channels on G */ + if (SCAN_TYPE_NORMAL_PASSIVE == pScanCncn->tOsScanParams.scanType ) + { + uValidChannelsCount = scanCncnOsSm_FillAllAvailableChannels (hScanCncn, RADIO_BAND_2_4_GHZ, + SCAN_TYPE_NORMAL_PASSIVE, &(pScanCncn->tOsScanParams.channelEntry[0]), + SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_G, + SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_G, + SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_G, + SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_G); + } + else + { + uValidChannelsCount = scanCncnOsSm_FillAllAvailableChannels (hScanCncn, RADIO_BAND_2_4_GHZ, + SCAN_TYPE_NORMAL_ACTIVE, &(pScanCncn->tOsScanParams.channelEntry[0]), + SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_G, + SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_G, + SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_G, + SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_G); + } + pScanCncn->tOsScanParams.numOfChannels = uValidChannelsCount; + + /* check that some channels are available */ + if ( uValidChannelsCount > 0 ) + { + EScanCncnResultStatus eResult; + + /* send command to scan concentrator APP SM */ + eResult = scanCncn_Start1ShotScan (hScanCncn, SCAN_SCC_APP_ONE_SHOT, &(pScanCncn->tOsScanParams)); + + /* if scan failed, send scan complete event to the SM */ + if (SCAN_CRS_SCAN_RUNNING != eResult) + { + TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionStartGScan: scan failed on 2.4 GHz, continuing to 5.0 GHz scan\n"); + genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn); + } + } + else + { + TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionStartGScan: no valid cahnnels on 2.4 GHz, continuing to 5.0 GHz scan\n"); + /* no channels to scan, send a scan complete event */ + genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn); + } +} + +/** + * \fn scanCncnOsSm_ActionStartAScan + * \brief Scan concentartor OS state machine start scan on A action function + * + * Scan concentartor OS state machine start scan on A action function. + * Starts a sacn on A using all allowed channels + * + * \param hScanCncn - handle to the scan concentartor object + * \return None + */ +void scanCncnOsSm_ActionStartAScan (TI_HANDLE hScanCncn) +{ + TScanCncn *pScanCncn = (TScanCncn*)hScanCncn; + paramInfo_t tParam; + TI_UINT32 uValidChannelsCount; + TI_BOOL bRegulatoryDomainEnabled; + + /* if the STA is not configured for G band or dual band, send a scan complete event to the SM */ + tParam.paramType = SITE_MGR_DESIRED_DOT11_MODE_PARAM; + siteMgr_getParam (pScanCncn->hSiteManager, &tParam); + if ((DOT11_A_MODE != tParam.content.siteMgrDot11Mode) && (DOT11_DUAL_MODE != tParam.content.siteMgrDot11Mode)) + { + TRACE0(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnOsSm_ActionStartAScan: STA does not work on 5.0 GHz, quitting\n"); + genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn); + return; + } + + /* build scan command header */ + pScanCncn->tOsScanParams.band = RADIO_BAND_5_0_GHZ; + pScanCncn->tOsScanParams.Tid = 0; + + /* query the regulatory domain if 802.11d is in use */ + tParam.paramType = REGULATORY_DOMAIN_ENABLED_PARAM; + regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam ); + bRegulatoryDomainEnabled = tParam.content.regulatoryDomainEnabled; + + /* Get country code status */ + tParam.paramType = REGULATORY_DOMAIN_IS_COUNTRY_FOUND; + tParam.content.eRadioBand = RADIO_BAND_5_0_GHZ; + regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam); + + /* scan type is passive if 802.11d is enabled and country IE was not yet found, active otherwise */ + if ( (TI_TRUE == bRegulatoryDomainEnabled) && (TI_FALSE == tParam.content.bIsCountryFound) ) + { + pScanCncn->tOsScanParams.scanType = SCAN_TYPE_NORMAL_PASSIVE; + } + /* All paramters in the func are hard coded, due to that we set to active if not passive */ + else + { + pScanCncn->tOsScanParams.scanType = SCAN_TYPE_NORMAL_ACTIVE; + /* also set number and rate of probe requests */ + pScanCncn->tOsScanParams.probeReqNumber = SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_A; + pScanCncn->tOsScanParams.probeRequestRate = SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_A; + } + + /* add supported channels on G */ + if (SCAN_TYPE_NORMAL_PASSIVE == pScanCncn->tOsScanParams.scanType ) + { + uValidChannelsCount = scanCncnOsSm_FillAllAvailableChannels (hScanCncn, RADIO_BAND_5_0_GHZ, + SCAN_TYPE_NORMAL_PASSIVE, &(pScanCncn->tOsScanParams.channelEntry[0]), + SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_A, + SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_A, + SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_A, + SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_A ); + } + else + { + uValidChannelsCount = scanCncnOsSm_FillAllAvailableChannels (hScanCncn, RADIO_BAND_5_0_GHZ, + SCAN_TYPE_NORMAL_ACTIVE, &(pScanCncn->tOsScanParams.channelEntry[0]), + SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_A, + SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_A, + SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_A, + SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_A ); + } + pScanCncn->tOsScanParams.numOfChannels = uValidChannelsCount; + + /* check that some channels are available */ + if ( uValidChannelsCount > 0 ) + { + EScanCncnResultStatus eResult; + + /* send command to scan concentrator APP SM */ + eResult = scanCncn_Start1ShotScan (hScanCncn, SCAN_SCC_APP_ONE_SHOT, &(pScanCncn->tOsScanParams)); + + /* if scan failed, send scan complete event to the SM */ + if (SCAN_CRS_SCAN_RUNNING != eResult) + { + TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionStartAScan: scan failed on 5.0 GHz, quitting\n"); + genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn); + } + } + else + { + TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionStartGScan: no valid cahnnels on 5.0 GHz, quitting\n"); + /* no channels to scan, send a scan complete event */ + genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn); + } +} + +/** + * \fn scanCncnOsSm_ActionCompleteScan + * \brief Scan concentartor OS state machine complete scan action function + * + * Scan concentartor OS state machine complete scan action function. + * Cleans up after an OS scan cycle - stabilize the scan result table + * + * \param hScanCncn - handle to the scan concentartor object + * \return None + */ +void scanCncnOsSm_ActionCompleteScan (TI_HANDLE hScanCncn) +{ + TScanCncn *pScanCncn = (TScanCncn*)hScanCncn; + + /* mark that OID scan process is no longer running */ + pScanCncn->bOSScanRunning = TI_FALSE; + /* also mark that no app scan client is running */ + pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT; + + /* + * set the result table to stable state. Note: OID scans are always done for the application, so the + * results will always be sent to the scan concentartor app scan result table, regardless of the + * SME connection mode. However, it is expected that the SME will NOT attempt to connect when an OID + * scan request will be received + */ + scanResultTable_SetStableState (pScanCncn->hScanResultTable); + + /* no need to send scan complete event - WZC (or equivalent other OS apps) will query for the results */ +} + +/** + * \fn scanCncnOsSm_FillAllAvailableChannels + * \brief Fills a chhanel array with valid channels (and their params) according to band and scan type + * + * Fills a chhanel array with valid channels (and their params) according to band and scan type + * + * \param hScanCncn - handle to the scan concentrator object + * \param eBand - band to extract channels for + * \param eScanType - scan type tp ectract channels for + * \param pChannelArray - where to store allowed channels information + * \param uMaxDwellTime - maximum dwell time value to be used for each channel + * \param uMinDwellTime - minimum dwell time value to be used for each channel + * \param eETCondition - early termination condition value to be used for each channel + * \param uETFrameNumber - early termination frame number value to be used for each channel + * \return Number of allowed channels (that were placed in the given channels array) + */ +TI_UINT32 scanCncnOsSm_FillAllAvailableChannels (TI_HANDLE hScanCncn, ERadioBand eBand, EScanType eScanType, + TScanChannelEntry *pChannelArray, TI_UINT32 uMaxDwellTime, + TI_UINT32 uMinChannelTime, EScanEtCondition eETCondition, + TI_UINT8 uETFrameNumber) +{ + TScanCncn *pScanCncn = (TScanCncn*)hScanCncn; + TI_UINT32 i, j, uAllowedChannelsCount, uValidChannelsCnt = 0; + paramInfo_t tParam; + TI_UINT8 uTempChannelList[ SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND ]; + + /* get the numnber of supported channels for this band */ + tParam.paramType = REGULATORY_DOMAIN_ALL_SUPPORTED_CHANNELS; + tParam.content.siteMgrRadioBand = eBand; + regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam); + uAllowedChannelsCount = tParam.content.supportedChannels.sizeOfList; + + /* for the time being don't scan more channels than fit in one command */ + if (uAllowedChannelsCount > SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND) + { + uAllowedChannelsCount = SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND; + } + + /* Copy allowed channels to reuse param var */ + os_memoryCopy (pScanCncn->hOS, uTempChannelList, + tParam.content.supportedChannels.listOfChannels, uAllowedChannelsCount ); + + /* preapre the param var to request channel allowance for the requested scan type */ + tParam.paramType = REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES; + tParam.content.channelCapabilityReq.band = eBand; + + /* add default values to channels allowed for the requested scan type and band */ + for (i = 0; i < uAllowedChannelsCount; i++) + { + /* get specific channel allowance for scan type */ + if ((eScanType == SCAN_TYPE_NORMAL_PASSIVE) || + (eScanType == SCAN_TYPE_TRIGGERED_PASSIVE) || + (eScanType == SCAN_TYPE_SPS)) + { + tParam.content.channelCapabilityReq.scanOption = PASSIVE_SCANNING; + } + else + { + tParam.content.channelCapabilityReq.scanOption = ACTIVE_SCANNING; + } + tParam.content.channelCapabilityReq.channelNum = uTempChannelList[ i ]; + + regulatoryDomain_getParam( pScanCncn->hRegulatoryDomain, &tParam ); + if (TI_TRUE == tParam.content.channelCapabilityRet.channelValidity) + { + /* add the channel ID */ + pChannelArray[ uValidChannelsCnt ].normalChannelEntry.channel = uTempChannelList[ i ]; + + /* add other default parameters */ + pChannelArray[ uValidChannelsCnt ].normalChannelEntry.minChannelDwellTime = uMinChannelTime; + pChannelArray[ uValidChannelsCnt ].normalChannelEntry.maxChannelDwellTime = uMaxDwellTime; + pChannelArray[ uValidChannelsCnt ].normalChannelEntry.earlyTerminationEvent = eETCondition; + pChannelArray[ uValidChannelsCnt ].normalChannelEntry.ETMaxNumOfAPframes = uETFrameNumber; + pChannelArray[ uValidChannelsCnt ].normalChannelEntry.txPowerDbm = + tParam.content.channelCapabilityRet.maxTxPowerDbm; + + /* Fill broadcast BSSID */ + for (j = 0; j < 6; j++) + { + pChannelArray[ uValidChannelsCnt ].normalChannelEntry.bssId[ j ] = 0xff; + } + uValidChannelsCnt++; + } + } + + /* return the number of channels that are actually allowed for the requested scan type on the requested band */ + return uValidChannelsCnt; +} + +/** + * \fn Function declaration + * \brief Function brief description goes here + * + * Function detailed description goes here + * + * \note Note is indicated here + * \param Parameter name - parameter description + * \param … + * \return Return code is detailed here + * \sa Reference to other relevant functions + */ +/** + * \\n + * \date 11-Jan-2005\n + * \brief Handles an unexpected event.\n + + * + * Function Scope \e Private.\n + * \param hScanCncn - handle to the scan concentrator object.\n + * \return always OK.\n + */ +void scanCncnOsSm_ActionUnexpected (TI_HANDLE hScanCncn) +{ + TScanCncn *pScanCncn = (TScanCncn*)hScanCncn; + + TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionUnexpected: Unexpeted action for current state\n"); +} + |