blob: efa4a8b4ec721494308051a2ac0b47dcde1c11b7 [file] [log] [blame]
/*
* ScanCncnOsSm.c
*
* Copyright(c) 1998 - 2010 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)) || SCAN_TYPE_TRIGGERED_PASSIVE == pScanCncn->tOsScanParams.scanType)
{
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 = (ERateMask)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)) || SCAN_TYPE_TRIGGERED_PASSIVE == pScanCncn->tOsScanParams.scanType)
{
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_A;
pScanCncn->tOsScanParams.probeRequestRate = (ERateMask)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;
/*Update the table only if scan was not rejected*/
if ( !pScanCncn->pScanClients[ pScanCncn->eCurrentRunningAppScanClient ]->bScanRejectedOn2_4)
{
/*
* 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);
}
else
{
pScanCncn->pScanClients[ pScanCncn->eCurrentRunningAppScanClient ]->bScanRejectedOn2_4 = TI_FALSE;
}
/* 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;
/* 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");
}