src/Sta_Management/ScanCncnOsSm.c

/*
 * 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");
}