src/Sta_Management/ScanCncn.c

/*
 * ScanCncn.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 ScanCncn.c
 *  \brief Scan concentartor implementation
 *
 *  \see   ScanCncnSm.c, ScanCncnSmSpecific.c
 */


#define __FILE_ID__  FILE_ID_76
#include "ScanCncn.h"
#include "report.h"
#include "scrApi.h"
#include "regulatoryDomainApi.h"
#include "siteMgrApi.h"
#include "healthMonitor.h"
#include "TWDriver.h"
#include "DrvMainModules.h"
#include "GenSM.h"
#include "ScanCncnPrivate.h"
#include "ScanCncnOsSm.h"
#include "scanResultTable.h"
#include "smeApi.h"
#include "apConnApi.h"
#include "EvHandler.h"

/* static functions */
void scanCncn_SGupdateScanParams (TI_HANDLE hScanCncn, UScanParams *puScanParams, TI_BOOL bPeriodicScan) ;
static void scanCncn_VerifyChannelsWithRegDomain (TI_HANDLE hScanCncn, UScanParams *puScanParams, TI_BOOL bPeriodicScan);

#define SCAN_CLIENT_FROM_TAG( tag )  tag2Client[ tag ];
static EScanCncnClient tag2Client[ SCAN_RESULT_TAG_MAX_NUMBER ] =
    { SCAN_SCC_NO_CLIENT, SCAN_SCC_APP_ONE_SHOT, SCAN_SCC_DRIVER, SCAN_SCC_APP_PERIODIC, SCAN_SCC_NO_CLIENT,
      SCAN_SCC_ROAMING_IMMED, SCAN_SCC_ROAMING_CONT };

/**
 * \fn     scanCncn_Create
 * \brief  Create the scan concentrator object
 *
 * Create the scan concentrator object. Allocates system resources and creates the client modules.
 *
 * \param  hOS - handle to the OS object
 * \return hanlde to the new scan concentrator object
 * \sa     scanCncn_Destroy, scanCncn_Init, scanCncn_SetDefaults
 */
TI_HANDLE scanCncn_Create (TI_HANDLE hOS)
{
    TScanCncn   *pScanCncn;
    TI_UINT32   uIndex;

    /* Allocate scan concentartor object memory */
    pScanCncn = (TScanCncn*)os_memoryAlloc (hOS, sizeof (TScanCncn));
    if (NULL == pScanCncn)
    {
        WLAN_OS_REPORT (("scanCncn_Create: Unable to allocate memory for scan concentrator object\n"));
        return NULL;
    }

    /* nullify the new object */
    os_memorySet (hOS, (void*)pScanCncn, 0, sizeof (TScanCncn));

    /* Store OS handle */
    pScanCncn->hOS = hOS;

    /* Create different clients */
    for (uIndex = 0; uIndex < SCAN_SCC_NUM_OF_CLIENTS; uIndex++)
    {
        pScanCncn->pScanClients[ uIndex ] = scanCncnSm_Create (hOS);
        if (NULL == pScanCncn->pScanClients[ uIndex ])
        {
            WLAN_OS_REPORT (("scanCncn_Create: Unable to create client %d object\n", uIndex));
            /* free all resources allocated so far */
            scanCncn_Destroy ((TI_HANDLE)pScanCncn);
            return NULL;
        }
    }

    /* create the OS scan SM */
    pScanCncn->hOSScanSm = scanCncnOsSm_Create ((TI_HANDLE)pScanCncn);
    if (NULL == pScanCncn->hOSScanSm)
    {
        WLAN_OS_REPORT (("scanCncn_Create: Unable to create OS scan SM\n"));
        /* free all resources allocated so far */
        scanCncn_Destroy ((TI_HANDLE)pScanCncn);
        return NULL;
    }

    /* create the app scan result table */
    pScanCncn->hScanResultTable = scanResultTable_Create (hOS);
    if (NULL == pScanCncn->hScanResultTable)
    {
        WLAN_OS_REPORT (("scanCncn_Create: Unable to create application scan result table\n"));
        /* free all resources allocated so far */
        scanCncn_Destroy ((TI_HANDLE)pScanCncn);
        return NULL;
    }

    /* return handle to the new object */
    return (TI_HANDLE)pScanCncn;
}

/**
 * \fn     scanCncn_Destroy
 * \brief  Destroys the scan concentrator object
 *
 * Destroys the scan concentrator object. Destroys the cleint modules and frees system resources.
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \return None
 * \sa     scanCncn_Create
 */
void scanCncn_Destroy (TI_HANDLE hScanCncn)
{
    TScanCncn   *pScanCncn = (TScanCncn*)hScanCncn;
    TI_UINT32   uIndex;

    /* destory the app scan result table */
    scanResultTable_Destroy (pScanCncn->hScanResultTable);

    /* destroy the OS scan SM */
    scanCncnOsSm_Destroy (hScanCncn);

    /* destroy the client objects */
    for (uIndex = 0; uIndex < SCAN_SCC_NUM_OF_CLIENTS; uIndex++)
    {
        scanCncnSm_Destroy (pScanCncn->pScanClients[ uIndex ]);
    }

    /* release the scan concentrator object */
    os_memoryFree (pScanCncn->hOS, hScanCncn, sizeof (TScanCncn));
}

/**
 * \fn     scanCncn_Init
 * \brief  Initializes the scan concentartor module
 *
 * Copy handles, register callbacks and initialize client modules
 *
 * \param  pStadHandles - modules handles structure
 * \return None
 * \sa     scanCncn_Create, scanCncn_SetDefaults
 */
void scanCncn_Init (TStadHandlesList *pStadHandles)
{
    TScanCncn   *pScanCncn = (TScanCncn*)pStadHandles->hScanCncn;

    /* store handles */
    pScanCncn->hTWD = pStadHandles->hTWD;
    pScanCncn->hReport = pStadHandles->hReport;
    pScanCncn->hRegulatoryDomain = pStadHandles->hRegulatoryDomain;
    pScanCncn->hSiteManager = pStadHandles->hSiteMgr;
    pScanCncn->hSCR = pStadHandles->hSCR;
    pScanCncn->hAPConn = pStadHandles->hAPConnection;
    pScanCncn->hEvHandler = pStadHandles->hEvHandler;
    pScanCncn->hMlme = pStadHandles->hMlmeSm;
    pScanCncn->hHealthMonitor = pStadHandles->hHealthMonitor;
    pScanCncn->hSme = pStadHandles->hSme;

    /* nullify other parameters */
    pScanCncn->eConnectionStatus = STA_NOT_CONNECTED;
    pScanCncn->bUseSGParams = TI_FALSE; /* bUseSGParams is TI_TRUE only when SG module is enabled */
    pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT;
    pScanCncn->uOSScanLastTimeStamp = 0;
    pScanCncn->bOSScanRunning = TI_FALSE;

    /* initialize client objects */
    scanCncnSm_Init (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ], pScanCncn->hReport, pScanCncn->hTWD,
                     pScanCncn->hSCR, pScanCncn->hAPConn, pScanCncn->hMlme, (TI_HANDLE)pScanCncn,
                     scanCncnSmImmed1Shot_ScrRequest, scanCncnSmImmed1Shot_ScrRelease, scanCncnSmImmed1Shot_StartScan,
                     scanCncnSmImmed1Shot_StopScan, scanCncnSmImmed1Shot_Recovery, "Immediate scan SM");
    scanCncnSm_Init (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ], pScanCncn->hReport, pScanCncn->hTWD,
                     pScanCncn->hSCR, pScanCncn->hAPConn, pScanCncn->hMlme, (TI_HANDLE)pScanCncn,
                     scanCncnSmCont1Shot_ScrRequest, scanCncnSmCont1Shot_ScrRelease, scanCncnSmCont1Shot_StartScan,
                     scanCncnSmCont1Shot_StopScan, scanCncnSmCont1Shot_Recovery, "Continuous scan SM");
    scanCncnSm_Init (pScanCncn->pScanClients[ SCAN_SCC_DRIVER ], pScanCncn->hReport, pScanCncn->hTWD,
                     pScanCncn->hSCR, pScanCncn->hAPConn, pScanCncn->hMlme, (TI_HANDLE)pScanCncn,
                     scanCncnSmDrvP_ScrRequest, scanCncnSmDrvP_ScrRelease, scanCncnSmDrvP_StartScan,
                     scanCncnSmDrvP_StopScan, scanCncnSmDrvP_Recovery, "Driver scan SM");
    scanCncnSm_Init (pScanCncn->pScanClients[ SCAN_SCC_APP_PERIODIC ], pScanCncn->hReport, pScanCncn->hTWD,
                     pScanCncn->hSCR, pScanCncn->hAPConn, pScanCncn->hMlme, (TI_HANDLE)pScanCncn,
                     scanCncnSmAppP_ScrRequest, scanCncnSmAppP_ScrRelease, scanCncnSmAppP_StartScan,
                     scanCncnSmAppP_StopScan, scanCncnSmAppP_Recovery, "Periodic application scan SM");
    scanCncnSm_Init (pScanCncn->pScanClients[ SCAN_SCC_APP_ONE_SHOT ], pScanCncn->hReport, pScanCncn->hTWD,
                     pScanCncn->hSCR, pScanCncn->hAPConn, pScanCncn->hMlme, (TI_HANDLE)pScanCncn,
                     scanCncnSmApp1Shot_ScrRequest, scanCncnSmApp1Shot_ScrRelease, scanCncnSmApp1Shot_StartScan,
                     scanCncnSmApp1Shot_StopScan, scanCncnSmApp1Shot_Recovery, "One-shot application scan SM");

    /* Initialize the OS scan SM */
    scanCncnOsSm_Init ((TI_HANDLE)pScanCncn);

    /* initlaize the application scan result table */
    scanResultTable_Init (pScanCncn->hScanResultTable, pStadHandles);
}

/**
 * \fn     scanCncn_SetDefaults
 * \brief  Set registry values to scan concentrator
 *
 * Set registry values to scan concentrator
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  pScanConcentratorInitParams - pointer to the registry parameters struct
 * \return None
 * \sa     scanCncn_Create, scanCncn_Init
 */
void scanCncn_SetDefaults (TI_HANDLE hScanCncn, TScanCncnInitParams *pScanCncnInitParams)
{
    TScanCncn   *pScanCncn = (TScanCncn*)hScanCncn;

    /* copy registry values */
    os_memoryCopy (pScanCncn->hOS,
                   &pScanCncn->tInitParams,
                   pScanCncnInitParams,
                   sizeof (TScanCncnInitParams));

    /* register SCR callbacks */
    scr_registerClientCB (pScanCncn->hSCR, SCR_CID_APP_SCAN, scanCncn_ScrAppCB, (TI_HANDLE)pScanCncn);
    scr_registerClientCB (pScanCncn->hSCR, SCR_CID_DRIVER_FG_SCAN, scanCncn_ScrDriverCB, (TI_HANDLE)pScanCncn);
    scr_registerClientCB (pScanCncn->hSCR, SCR_CID_CONT_SCAN, scanCncn_ScrRoamingContCB, (TI_HANDLE)pScanCncn);
    scr_registerClientCB (pScanCncn->hSCR, SCR_CID_IMMED_SCAN, scanCncn_ScrRoamingImmedCB, (TI_HANDLE)pScanCncn);

    /* register TWD scan complete CB */
    TWD_RegisterScanCompleteCb (pScanCncn->hTWD, scanCncn_ScanCompleteNotificationCB,
                                (TI_HANDLE)pScanCncn);
    /* register and enable periodic scan complete event with TWD */
    TWD_RegisterEvent (pScanCncn->hTWD, TWD_OWN_EVENT_PERIODIC_SCAN_COMPLETE,
                       scanCncn_PeriodicScanCompleteCB, (TI_HANDLE)pScanCncn);
    TWD_EnableEvent (pScanCncn->hTWD, TWD_OWN_EVENT_PERIODIC_SCAN_COMPLETE);

    /* and periodic scan report */
    TWD_RegisterEvent (pScanCncn->hTWD, TWD_OWN_EVENT_PERIODIC_SCAN_REPORT,
                       scanCncn_PeriodicScanReportCB, (TI_HANDLE)pScanCncn);
    TWD_EnableEvent (pScanCncn->hTWD, TWD_OWN_EVENT_PERIODIC_SCAN_REPORT);

    /* "register" the application scan result callback */
    scanCncn_RegisterScanResultCB ((TI_HANDLE)pScanCncn, SCAN_SCC_APP_ONE_SHOT, scanCncn_AppScanResultCB, (TI_HANDLE)pScanCncn);
    scanCncn_RegisterScanResultCB ((TI_HANDLE)pScanCncn, SCAN_SCC_APP_PERIODIC, scanCncn_AppScanResultCB, (TI_HANDLE)pScanCncn);
}

/**
 * \fn     scanCncn_SwitchToConnected
 * \brief  Notifies the scan concentratoe the STA has connected to an infrastructure BSS
 *
 * Notifies the scan concentratoe the STA has connected to an infrastructure BSS
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \return None
 * \sa     scanCncn_SwitchToNotConnected, scanCncn_SwitchToIBSS
 */
void scanCncn_SwitchToConnected (TI_HANDLE hScanCncn)
{
    TScanCncn   *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE0(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_SwitchToConnected: Switching to connected state.\n");

    /* change connection status to connected */
    pScanCncn->eConnectionStatus = STA_CONNECTED;

    /* Any running scans in other modes will be aborted (if needed) by the SCR (or have already been) */
}

/**
 * \fn     scanCncn_SwitchToNotConnected
 * \brief  Notifies the scan concentratoe the STA has disconnected from a BSS
 *
 * Notifies the scan concentratoe the STA has disconnected from a BSS
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \return None
 * \sa     scanCncn_SwitchToConnected, scanCncn_SwitchToIBSS
 */
void scanCncn_SwitchToNotConnected (TI_HANDLE hScanCncn)
{
    TScanCncn   *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE0(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_SwitchToNotConnected: Switching to not connected state.\n");

    /* change connection status to connected */
    pScanCncn->eConnectionStatus = STA_NOT_CONNECTED;

    /* Any running scans in other modes will be aborted (if needed) by the SCR (or have already been) */
}

/**
 * \fn     scanCncn_SwitchToIBSS
 * \brief  Notifies the scan concentratoe the STA has connected to an independent BSS
 *
 * Notifies the scan concentratoe the STA has connected to an independent BSS
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \return None
 * \sa     scanCncn_SwitchToConnected, scanCncn_SwitchToNotConnected
 */
void scanCncn_SwitchToIBSS (TI_HANDLE hScanCncn)
{
    TScanCncn   *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE0(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_SwitchToIBSS: Switching to IBSS state.\n");

    /* change connection status to connected */
    pScanCncn->eConnectionStatus = STA_IBSS;

    /* Any running scans in other modes will be aborted (if needed) by the SCR (or have already been) */
}

EScanCncnResultStatus scanCncn_Start1ShotScan (TI_HANDLE hScanCncn,
                                          EScanCncnClient eClient,
                                          TScanParams* pScanParams)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;
    paramInfo_t         *pParam;

    TRACE1(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_Start1ShotScan: Received scan request from client %d\n", eClient);

    pParam = (paramInfo_t *)os_memoryAlloc(pScanCncn->hOS, sizeof(paramInfo_t));
    if (!pParam) {
        return SCAN_CRS_SCAN_FAILED;
    }

    /* copy scan parameters to local buffer */
    os_memoryCopy (pScanCncn->hOS, &(pScanCncn->pScanClients[ eClient ]->uScanParams.tOneShotScanParams),
                   pScanParams, sizeof(TScanParams));

    /*
     * roaming scans (continuous and immediate) require to set the current SSID, to keep the scan manager
     * unaware of it, unless the SSID is broadcast (to allow customers to request broadcast scan)
     */
    if ((SCAN_SCC_ROAMING_CONT == eClient) || (SCAN_SCC_ROAMING_IMMED == eClient))
    {
        if (0 != pScanParams->desiredSsid.len)
        {
            /* set the SSID of the current AP */
            pParam->paramType = SME_DESIRED_SSID_ACT_PARAM;
            sme_GetParam (pScanCncn->hSme, pParam);
            os_memoryCopy (pScanCncn->hOS,
                           &(pScanCncn->pScanClients[ eClient ]->uScanParams.tOneShotScanParams.desiredSsid),
                           &(pParam->content.smeDesiredSSID),
                           sizeof(TSsid));
        }
    }
    os_memoryFree(pScanCncn->hOS, pParam, sizeof(paramInfo_t));

    /* ask the reg domain which channels are allowed for the requested scan type */
    scanCncn_VerifyChannelsWithRegDomain (hScanCncn, &(pScanCncn->pScanClients[ eClient ]->uScanParams), TI_FALSE);

    /* if no channels are available for scan, return negative result */
    if (0 == pScanCncn->pScanClients[ eClient ]->uScanParams.tOneShotScanParams.numOfChannels)
    {
        TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncn_Start1ShotScan: no cahnnels to scan after reg. domain verification, can't scan\n");
        return SCAN_CRS_SCAN_FAILED;
    }

    if (TI_TRUE == pScanCncn->bUseSGParams)
    {
        scanCncn_SGupdateScanParams (hScanCncn, &(pScanCncn->pScanClients[ eClient ]->uScanParams), TI_FALSE);
    }

    /* mark that a scan request is in progress (to avoid client re-entrance if the scan fail) */
    pScanCncn->pScanClients[ eClient ]->bInRequest = TI_TRUE;

    /* mark the scan result as TI_OK (until other status will replace it) */
    pScanCncn->pScanClients[ eClient ]->eScanResult = SCAN_CRS_SCAN_COMPLETE_OK;

    /* send a start scan event to the SM */
    genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_START,
                 (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);

    /* mark that the scan request is no longer in progress */
    pScanCncn->pScanClients[ eClient ]->bInRequest = TI_FALSE;

    /*
     * return scan result - if an error occured return the error, otherwise return running
     * (complete_ok is set to be returned when scan is complete)
     */
    if (SCAN_CRS_SCAN_COMPLETE_OK != pScanCncn->pScanClients[ eClient ]->eScanResult)
    {
        return pScanCncn->pScanClients[ eClient ]->eScanResult;
    }
    return SCAN_CRS_SCAN_RUNNING;
}

void scanCncn_StopScan (TI_HANDLE hScanCncn, EScanCncnClient eClient)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE1( pScanCncn->hReport, REPORT_SEVERITY_INFORMATION, "scanCncn_StopScan: Received stop scan request from client %d\n", eClient);

    /*
     * mark that null data should be sent (different from abort, where null dats is not sent
     * to reduce abort time)
     */
    pScanCncn->pScanClients[ eClient ]->bSendNullDataOnStop = TI_TRUE;

    /* if no previous error has occurred, change the state to stopped */
    if (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ eClient ]->eScanResult)
    {
        pScanCncn->pScanClients[ eClient ]->eScanResult = SCAN_CRS_SCAN_STOPPED;
    }

    /* send a stop scan event to the SM */
    genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_STOP,
                 (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);
}

/**
 * \fn     scanCncn_StartPeriodicScan
 * \brief  Starts a periodic scan operation
 *
 * Starts a periodic scan operation:
 *  - copies scan params to scan concentrator object
 *  - verifies the requested channels with the reg doamin
 *  - if needed, adjust to SG compensation values
 *  - send an event to the client SM
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  eClient - the client requesting the scan operation
 * \param  pScanParams - scan parameters
 * \return Scan opeartion status
 * \retval SCAN_CRS_SCAN_RUNNING - scan started successfully and is now running
 * \retval SCAN_CRS_SCAN_FAILED - scan failed to start due to an unexpected error
 * \sa     scanCncn_StopPeriodicScan
 */
EScanCncnResultStatus scanCncn_StartPeriodicScan (TI_HANDLE hScanCncn,
                                                  EScanCncnClient eClient,
                                                  TPeriodicScanParams *pScanParams)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE1(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_startPeriodicScan: Received scan request from client %d\n", eClient);

    /* copy scan parameters to local buffer */
    os_memoryCopy (pScanCncn->hOS, &(pScanCncn->pScanClients[ eClient ]->uScanParams.tPeriodicScanParams),
                   pScanParams, sizeof(TPeriodicScanParams));

    /* ask the reg domain which channels are allowed for the requested scan type */
    scanCncn_VerifyChannelsWithRegDomain (hScanCncn, &(pScanCncn->pScanClients[ eClient ]->uScanParams), TI_TRUE);

    /* if no channels are available for scan, return negative result */
    if (0 == pScanCncn->pScanClients[ eClient ]->uScanParams.tPeriodicScanParams.uChannelNum)
    {
        TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncn_StartPeriodicScan: no cahnnels to scan after reg. domain verification, can't scan\n");
        return SCAN_CRS_SCAN_FAILED;
    }

    if (TI_TRUE == pScanCncn->bUseSGParams)
    {
        scanCncn_SGupdateScanParams (hScanCncn, &(pScanCncn->pScanClients[ eClient ]->uScanParams), TI_TRUE);
    }

    /* mark that a scan request is in progress (to avoid client re-entrance if the scan fail) */
    pScanCncn->pScanClients[ eClient ]->bInRequest = TI_TRUE;

    /* mark the scan result as TI_OK (until other status will replace it) */
    pScanCncn->pScanClients[ eClient ]->eScanResult = SCAN_CRS_SCAN_COMPLETE_OK;

    /* send a start scan event to the SM */
    genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_START,
                 (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);

    /* mark that the scan request is no longer in progress */
    pScanCncn->pScanClients[ eClient ]->bInRequest = TI_FALSE;

    /*
     * return scan result - if an error occured return the error, otherwise return running
     * (complete_ok is set to be returned when scan is complete)
     */
    if (SCAN_CRS_SCAN_COMPLETE_OK != pScanCncn->pScanClients[ eClient ]->eScanResult)
    {
        return pScanCncn->pScanClients[ eClient ]->eScanResult;
    }
    return SCAN_CRS_SCAN_RUNNING;
}

/**
 * \fn     scanCncn_StopPeriodicScan
 * \brief  Stop an on-going periodic scan operation
 *
 * Set necessary flags and send a stop scan event to the client SM
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  eClient - the client requesting to stop the scan operation
 * \return None
 * \sa     scanCncn_StartPeriodicScan
 */
void scanCncn_StopPeriodicScan (TI_HANDLE hScanCncn, EScanCncnClient eClient)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE1( pScanCncn->hReport, REPORT_SEVERITY_INFORMATION, "scanCncn_StopPeriodicScan: Received stop scan request from client %d\n", eClient);

    /* if no previous error has occurred, change the state to stopped */
    if (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ eClient ]->eScanResult)
    {
        pScanCncn->pScanClients[ eClient ]->eScanResult = SCAN_CRS_SCAN_STOPPED;
    }

    /* send a stop scan event to the SM */
    genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_STOP,
                 (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);
}

void scanCncn_RegisterScanResultCB (TI_HANDLE hScanCncn, EScanCncnClient eClient,
                                    TScanResultCB scanResultCBFunc, TI_HANDLE scanResultCBObj)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;

    /* save the function and object pointers */
    pScanCncn->pScanClients[ eClient ]->tScanResultCB = scanResultCBFunc;
    pScanCncn->pScanClients[ eClient ]->hScanResultCBObj = scanResultCBObj;
}

/**
 * \fn     scanCncn_ScanCompleteNotificationCB
 * \brief  Called when a scan is complete
 *
 * Update scan status and send a complete event to the SM
 *
 * \note   Must wait for all results to be received before the scan is actually completed
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  eTag - the scan type tag
 * \param  uResoultCount - number of results received during this scan
 * \param  SPSStatus - which channels were attempted (if this is an SPS scan)
 * \param  bTSFError - whether a TSF error occurred (if this is an SPS scan)
 * \param  scanStatus - scan SRV status (OK / NOK)
 * \return None
 */
void scanCncn_ScanCompleteNotificationCB (TI_HANDLE hScanCncn, EScanResultTag eTag,
                                          TI_UINT32 uResultCount, TI_UINT16 SPSStatus,
                                          TI_BOOL bTSFError, TI_STATUS scanStatus,
                                          TI_STATUS PSMode)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;
    EScanCncnClient     eClient;

    TRACE6(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_ScanCompleteNotificationCB: tag: %d, result count: %d, SPS status: %d, TSF Error: %d, scan status: %d, PS mode: %d\n", eTag, uResultCount, SPSStatus, bTSFError, scanStatus, PSMode);

    /* get the scan client value from the scan tag */
    eClient = SCAN_CLIENT_FROM_TAG (eTag);

    /* update scan result if scan SRV reported error (and no error occured so far) */
    if ((TI_OK != scanStatus) && (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ eClient ]->eScanResult))
    {
        pScanCncn->pScanClients[ eClient ]->eScanResult = SCAN_CRS_SCAN_FAILED;
    }

    /* for SPS: copy SPS result and update scan status according to TSF error */
    if (SCAN_TYPE_SPS == pScanCncn->pScanClients[ eClient ]->uScanParams.tOneShotScanParams.scanType)
    {
        pScanCncn->pScanClients[ eClient ]->uSPSScanResult = SPSStatus;
        if (TI_TRUE == bTSFError)
        {
            pScanCncn->pScanClients[ eClient ]->eScanResult = SCAN_CRS_TSF_ERROR;
        }
    }

    /* update number of frames expected */
    pScanCncn->pScanClients[ eClient ]->uResultExpectedNumber += uResultCount;

    /* check if all frames had been received */
    if (pScanCncn->pScanClients[ eClient ]->uResultCounter >= pScanCncn->pScanClients[ eClient ]->uResultExpectedNumber)
    {
        TRACE2(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_ScanCompleteNotificationCB: client %d received %d results, matching scan complete FW indication, sending scan complete event\n", eClient, pScanCncn->pScanClients[ eClient ]->uResultCounter);

        /* all frames had been received, send a scan complete event to the client SM */
        genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE,
                     (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);
    }
    else
    {
        TRACE3(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_ScanCompleteNotificationCB: client %d received %d results, FW indicated %d results, waiting for more\n", eClient, pScanCncn->pScanClients[ eClient ]->uResultCounter, pScanCncn->pScanClients[ eClient ]->uResultExpectedNumber);

        /* still waiting for some frames, turn on the scan complete pending flag */
        pScanCncn->pScanClients[ eClient ]->bScanCompletePending = TI_TRUE;
    }
}

/**
 * \fn     scanCncn_PeriodicScanReportCB
 * \brief  Called when results are available but periodic scan is not yet complete
 *
 * Called when results are available but periodic scan is not yet complete
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  str - event data
 * \param  strLen - data length
 * \return None
 * \sa     scanCncn_PeriodicScanCompleteCB
 */
void scanCncn_PeriodicScanReportCB (TI_HANDLE hScanCncn, char* str, TI_UINT32 strLen)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;
    EScanCncnClient     eClient;
    EScanResultTag      eTag = str[ 1 ];
    TI_UINT32           uResultCount = str[ 0 ];

    TRACE2(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_PeriodicScanReportCB: tag: %d, result count: %d\n", eTag, uResultCount);

    /* get the scan client value from the scan tag */
    eClient = SCAN_CLIENT_FROM_TAG (eTag);

    /* update number of frames expected */
    pScanCncn->pScanClients[ eClient ]->uResultExpectedNumber += uResultCount;
}
/**
 * \fn     scanCncn_PeriodicScanReportCB
 * \brief  Called when results are available but the scan is bot yet complete
 *
 * Called when results are available but the scan is bot yet complete
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  str - event data
 * \param  strLen - data length
 * \return None
 * \sa     scanCncn_PeriodicScanReportCB
 */
void scanCncn_PeriodicScanCompleteCB (TI_HANDLE hScanCncn, char* str, TI_UINT32 strLen)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;
    EScanCncnClient     eClient;
    EScanResultTag      eTag = str[ 1 ];
    TI_UINT32           uResultCount = str[ 0 ];

    TRACE2(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_PeriodicScanCompleteCB: tag: %d, result count: %d\n", eTag, uResultCount);

    /* get the scan client value from the scan tag */
    eClient = SCAN_CLIENT_FROM_TAG (eTag);

    /* update number of frames expected */
    pScanCncn->pScanClients[ eClient ]->uResultExpectedNumber += uResultCount;

    /* check if all frames had been received */
    if (pScanCncn->pScanClients[ eClient ]->uResultCounter >= pScanCncn->pScanClients[ eClient ]->uResultExpectedNumber)
    {
        TRACE2(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_PeriodicScanCompleteCB: client %d received %d results, matching scan complete FW indication, sending scan complete event\n", eClient, pScanCncn->pScanClients[ eClient ]->uResultCounter);
        /* all frames had been received, send a scan complete event to the client SM */
        genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE,
                     (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);
    }
    else
    {
        TRACE3(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_PeriodicScanCompleteCB: client %d received %d results, FW indicated %d results, waiting for more\n", eClient, pScanCncn->pScanClients[ eClient ]->uResultCounter, pScanCncn->pScanClients[ eClient ]->uResultExpectedNumber);
        /* still waiting for some frames, turn on the scan complete pending flag */
        pScanCncn->pScanClients[ eClient ]->bScanCompletePending = TI_TRUE;
    }
}

/**
 * \fn     scanCncn_MlmeResultCB
 * \brief  Handles an MLME result (received frame)
 *
 * Filters the frame for roaming scans and passes it to the appropriate client
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  bssid - a pointer to the address of the AP sending this frame
 * \param  frameInfo - the IE in the frame
 * \param  pRxAttr - a pointer to TNET RX attributes struct
 * \param  buffer - a pointer to the frame body
 * \param  bufferLength - the frame body length
 * \return None
 */
void scanCncn_MlmeResultCB (TI_HANDLE hScanCncn, TMacAddr* bssid, mlmeFrameInfo_t* frameInfo,
                            TRxAttr* pRxAttr, TI_UINT8* buffer, TI_UINT16 bufferLength)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;
    EScanCncnClient     eClient;
    TScanFrameInfo      tScanFrameInfo;
    TI_BOOL             bValidResult = TI_TRUE;

    /* get the scan client value from the scan tag */
    eClient = SCAN_CLIENT_FROM_TAG (pRxAttr->eScanTag);

    /* increase scan result counter */
    pScanCncn->pScanClients[ eClient ]->uResultCounter++;

    /*
     * erroneous results are signaled by NULL pointers and are notified to the scan concentrator to
     * update the counter only!
     */
    if (NULL == bssid)
    {
        TRACE0(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_MlmeResultCB: received an empty frame notification from MLME\n");

        /* invalid resuilt */
        bValidResult = TI_FALSE;
    }
    /* are results valid so far (TI_TRUE == bValidResult) */
    else
    {
        TRACE6(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanConcentrator_mlmeResultCB: received frame from BBSID: %02x:%02x:%02x:%02x:%02x:%02x\n", (*bssid)[ 0 ], (*bssid)[ 1 ], (*bssid)[ 2 ], (*bssid)[ 3 ], (*bssid)[ 4 ], (*bssid)[ 5 ]);

       /*
        * for roaming continuous and immediate, discard frames from current AP,
        * or frames with SSID different than desired when the scan is NOT SPS
        */
        if((SCAN_SCC_ROAMING_CONT == eClient) || (SCAN_SCC_ROAMING_IMMED == eClient))
        {
            bssEntry_t          *pCurrentAP;

            pCurrentAP = apConn_getBSSParams(pScanCncn->hAPConn);
            if(MAC_EQUAL(*bssid, pCurrentAP->BSSID) ||
               ((os_memoryCompare (pScanCncn->hOS,
                                   (TI_UINT8*)frameInfo->content.iePacket.pSsid->serviceSetId,
                                   (TI_UINT8*)pScanCncn->pScanClients[ eClient ]->uScanParams.tOneShotScanParams.desiredSsid.str,
                                   pScanCncn->pScanClients[ eClient ]->uScanParams.tOneShotScanParams.desiredSsid.len)) &&
                pScanCncn->pScanClients[ eClient ]->uScanParams.tOneShotScanParams.scanType != SCAN_TYPE_SPS))
            {
                TRACE6(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanConcentrator_mlmeResultCB: discarding frame from SSID: , BSSID: %02x:%02x:%02x:%02x:%02x:%02x, because SSID different from desired or from current AP!\n", (*bssid)[ 0 ], (*bssid)[ 1 ], (*bssid)[ 2 ], (*bssid)[ 3 ], (*bssid)[ 4 ], (*bssid)[ 5 ]);

                /* invalid resuilt */
                bValidResult = TI_FALSE;
            }

        }


        if(TI_TRUE == bValidResult)
        {
            /* build the scan frame info object */
            tScanFrameInfo.bssId = bssid;
            tScanFrameInfo.band = (ERadioBand)pRxAttr->band;
            tScanFrameInfo.channel = pRxAttr->channel;
            tScanFrameInfo.parsedIEs = frameInfo;
            tScanFrameInfo.rate = pRxAttr->Rate;
            tScanFrameInfo.rssi = pRxAttr->Rssi;
            tScanFrameInfo.snr = pRxAttr->SNR;
            tScanFrameInfo.staTSF = pRxAttr->TimeStamp;
            tScanFrameInfo.buffer = buffer;
            tScanFrameInfo.bufferLength = bufferLength;

            if (TI_TRUE == pScanCncn->tInitParams.bPushMode)
            {
               /*
                * The scan found result, send a scan report event to the use with the frame 	parameters without save the result in the scan table
                */
                EvHandlerSendEvent (pScanCncn->hEvHandler, IPC_EVENT_SCAN_REPORT, (TI_UINT8*)&tScanFrameInfo, sizeof(TScanFrameInfo));
            }
            else
            {
               /* call the client result CB */
               pScanCncn->pScanClients[ eClient ]->tScanResultCB (pScanCncn->pScanClients[ eClient ]->hScanResultCBObj,
                                                                  SCAN_CRS_RECEIVED_FRAME, &tScanFrameInfo, 0xffff ); /* SPS status is only valid on SPS scan complete */
            }
        }
    }

    /* check if scan complete is pending for this frame for all results */
    if((TI_TRUE == pScanCncn->pScanClients[ eClient ]->bScanCompletePending) &&
       (pScanCncn->pScanClients[ eClient ]->uResultCounter == pScanCncn->pScanClients[ eClient ]->uResultExpectedNumber))
    {
        TRACE1(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_MlmeResultCB: received frame number %d, scan complete pending, sending scan complet event\n", pScanCncn->pScanClients[ eClient ]->uResultCounter);

        /* send a scan complete event to the client SM */
        genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE,
                     (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);
    }
}

/**
 * \fn     scanCncn_ScrRoamingImmedCB
 * \brief  Called by SCR for immediate roaming client status change notification
 *
 * Handles status change by sending the appropriate SM event
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  eRrequestStatus - the immediate scan for roaming client status
 * \param  eResource - the resource for which the CB is issued
 * \param  ePendreason - The reason for pend status, if the status is pend
 * \return None
 */
void scanCncn_ScrRoamingImmedCB (TI_HANDLE hScanCncn, EScrClientRequestStatus eRequestStatus,
                                 EScrResourceId eResource, EScePendReason ePendReason)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE3(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_ScrRoamingImmedCB: status: %d, resource: %d pend reason: %d\n", eRequestStatus, eResource, ePendReason);

    /* act according to the request staus */
    switch (eRequestStatus)
    {
    case SCR_CRS_RUN:
        /* send an SCR run event to the SM */
        genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]->hGenSM, SCAN_CNCN_SM_EVENT_RUN,
                     (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]);
        break;

    case SCR_CRS_PEND:
        /* if pending reason has changed to different group - send a reject event
           (should only happen when pending) */
        if ( SCR_PR_DIFFERENT_GROUP_RUNNING == ePendReason )
        {
            /* send an SCR reject event to the SM - would not scan when not performing roaming */
            pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]->eScanResult = SCAN_CRS_SCAN_FAILED;
            genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]->hGenSM, SCAN_CNCN_SM_EVENT_REJECT,
                         (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]);
        }
        break;

    case SCR_CRS_FW_RESET:
        /* if no previous error has occurred, change the state to FW reset */
        if (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]->eScanResult)
        {
            pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]->eScanResult = SCAN_CRS_SCAN_ABORTED_FW_RESET;
        }

        /* send a recovery event to the SM */
        genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]->hGenSM, SCAN_CNCN_SM_EVENT_RECOVERY,
                     (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_ROAMING_IMMED ]);
        break;

    case SCR_CRS_ABORT:
        /* This should never happen, report error */
    default:
        TRACE1(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncn_ScrRoamingImmedCB: Illegal SCR request status: %d.\n", eRequestStatus);
        break;
    }
}

/**
 * \fn     scanCncn_ScrRoamingContCB
 * \brief  Called by SCR for continuous roaming client status change notification
 *
 * Handles status change by sending the appropriate SM event
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  eRrequestStatus - the continuous scan for roaming client status
 * \param  eResource - the resource for which the CB is issued
 * \param  ePendreason - The reason for pend status, if the status is pend
 * \return None
 */
void scanCncn_ScrRoamingContCB (TI_HANDLE hScanCncn, EScrClientRequestStatus eRequestStatus,
                                EScrResourceId eResource, EScePendReason ePendReason)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE3(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_ScrRoamingContCB: status: %d, resource: %d pend reason: %d\n", eRequestStatus, eResource, ePendReason);

    /* act according to the request staus */
    switch (eRequestStatus)
    {
    case SCR_CRS_RUN:
        /* send an SCR run event to the SM */
        genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->hGenSM, SCAN_CNCN_SM_EVENT_RUN,
                     (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]);
        break;

    case SCR_CRS_PEND:
        /* if pending reason has changed to different group - send a reject event (should only happen when pending) */
        if ( SCR_PR_DIFFERENT_GROUP_RUNNING == ePendReason )
        {
            pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->eScanResult = SCAN_CRS_SCAN_FAILED;
            genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->hGenSM, SCAN_CNCN_SM_EVENT_REJECT,
                         (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]);
        }
        break;

    case SCR_CRS_FW_RESET:
        /* if no previous error has occurred, change the state to FW reset */
        if (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->eScanResult)
        {
            pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->eScanResult = SCAN_CRS_SCAN_ABORTED_FW_RESET;
        }

        /* send a recovery event to the SM */
        genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->hGenSM, SCAN_CNCN_SM_EVENT_RECOVERY,
                     (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]);
        break;


    case SCR_CRS_ABORT:
        /* mark not to send NULL data when scan is stopped */
        pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->bSendNullDataOnStop = TI_FALSE;

        /* if no previous error has occurred, change the result to abort */
        if (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->eScanResult)
        {
            pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->eScanResult = SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY;
        }

        /* send an abort scan event to the SM */
        genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]->hGenSM, SCAN_CNCN_SM_EVENT_ABORT,
                     (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_ROAMING_CONT ]);
        break;

    default:
        TRACE1(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncn_ScrRoamingContCB: Illegal SCR request status: %d.\n", eRequestStatus);
        break;
    }
}

/**
 * \fn     scanCncn_ScrAppCB
 * \brief  Called by SCR for application scan client status change notification
 *
 * Handles status change by sending the appropriate SM event
 *
 * \note   this function is used by the SCR for both one-shot and periodic application scan
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  eRrequestStatus - the application scan client status
 * \param  eResource - the resource for which the CB is issued
 * \param  ePendreason - The reason for pend status, if the status is pend
 * \return None
 */
void scanCncn_ScrAppCB (TI_HANDLE hScanCncn, EScrClientRequestStatus eRequestStatus,
                        EScrResourceId eResource, EScePendReason ePendReason )
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;
    EScanCncnClient     eClient;

    TRACE3(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_ScrAppCB: status: %d, resource: %d pend reason: %d\n", eRequestStatus, eResource, ePendReason);

    /* set client according to SCr resource */
    if (SCR_RESOURCE_PERIODIC_SCAN == eResource)
    {
        eClient = SCAN_SCC_APP_PERIODIC;
    }
    else
    {
        eClient = SCAN_SCC_APP_ONE_SHOT;
    }

    /* act according to the request staus */
    switch (eRequestStatus)
    {
    /*
     * Note: pend is not handled because application scan cancel its scan request when it receives pend
     * as the SCR request result, and thus it is assumed that the application scan request will never be
     * pending
     */
    case SCR_CRS_RUN:
        /* send an SCR run event to the SM */
        genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_RUN,
                     (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);
        break;

    case SCR_CRS_FW_RESET:
        /* if no previous error has occurred, change the state to FW reset */
        if (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ eClient ]->eScanResult)
        {
            pScanCncn->pScanClients[ eClient ]->eScanResult = SCAN_CRS_SCAN_ABORTED_FW_RESET;
        }

        /* send a recovery event to the SM */
        genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_RECOVERY,
                     (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);
        break;

    case SCR_CRS_ABORT:
        /* mark not to send NULL data when scan is stopped */
        pScanCncn->pScanClients[ eClient ]->bSendNullDataOnStop = TI_FALSE;

        /* if no previous error has occurred, change the result to abort */
        if (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ eClient ]->eScanResult)
        {
            pScanCncn->pScanClients[ eClient ]->eScanResult = SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY;
        }

        /* send an abort scan event to the SM */
        genSM_Event (pScanCncn->pScanClients[ eClient ]->hGenSM, SCAN_CNCN_SM_EVENT_ABORT,
                     (TI_HANDLE)pScanCncn->pScanClients[ eClient ]);
        break;

    default:
        TRACE1(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncn_ScrAppCB: Illegal SCR request status: %d.\n", eRequestStatus);
        break;
    }
}

/**
 * \fn     scanCncn_ScrDriverCB
 * \brief  Called by SCR for driver scan client status change notification
 *
 * Handles status change by sending the appropriate SM event
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  eRrequestStatus - the driver scan client status
 * \param  eResource - the resource for which the CB is issued
 * \param  ePendreason - The reason for pend status, if the status is pend
 * \return None
 */
void scanCncn_ScrDriverCB (TI_HANDLE hScanCncn, EScrClientRequestStatus eRequestStatus,
                           EScrResourceId eResource, EScePendReason ePendReason)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;

    TRACE3(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_ScrDriverCB: status: %d, resource: %d pend reason: %d\n", eRequestStatus, eResource, ePendReason);

    /* act according to the request staus */
    switch (eRequestStatus)
    {
    case SCR_CRS_RUN:
        /* send the next event to the SM */
        genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]->hGenSM, SCAN_CNCN_SM_EVENT_RUN,
                     (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]);
        break;

    case SCR_CRS_PEND:
        /* if pending reason has changed to different group - send a reject event (should only happen when pending) */
        if ( SCR_PR_DIFFERENT_GROUP_RUNNING == ePendReason )
        {
            pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]->eScanResult = SCAN_CRS_SCAN_FAILED;
            genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]->hGenSM, SCAN_CNCN_SM_EVENT_REJECT,
                         (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]);
        }
        break;

    case SCR_CRS_FW_RESET:
        /* if no previous error has occurred, change the state to FW reset */
        if (SCAN_CRS_SCAN_COMPLETE_OK == pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]->eScanResult)
        {
            pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]->eScanResult = SCAN_CRS_SCAN_ABORTED_FW_RESET;
        }

        /* send a recovery event to the SM */
        genSM_Event (pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]->hGenSM, SCAN_CNCN_SM_EVENT_RECOVERY,
                     (TI_HANDLE)pScanCncn->pScanClients[ SCAN_SCC_DRIVER ]);
        break;

    case SCR_CRS_ABORT:
    /* This should never happen, report error */
    default:
        TRACE1(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncn_ScrDriverCB: Illegal SCR request status: %d.\n", eRequestStatus);
        break;
    }
}

/**
 * \fn     scanCncn_VerifyChannelsWithRegDomain
 * \brief  Verifies channel validity and TX power with the reg. domain
 *
 * Verifies channel validity and TX power with the reg. domain. Removes invalid channels.
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  puScanParams - a pointer to the scan parmeters union
 * \param  bPeriodicScan - TRUE if the parameters are for periodic scan, FALSE if for one-shot scan
 * \return None
 */
void scanCncn_VerifyChannelsWithRegDomain (TI_HANDLE hScanCncn, UScanParams *puScanParams, TI_BOOL bPeriodicScan)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;
    paramInfo_t         *pParam;
    paramInfo_t         tDfsParam;
    TI_UINT8            i, uChannelNum;

    pParam = (paramInfo_t *)os_memoryAlloc(pScanCncn->hOS, sizeof(paramInfo_t));
    if (!pParam) {
        return;
    }

    /* get channel number according to scan type */
    if (TI_TRUE == bPeriodicScan)
    {
        uChannelNum = puScanParams->tPeriodicScanParams.uChannelNum;
    }
    else
    {
        uChannelNum = puScanParams->tOneShotScanParams.numOfChannels;
    }

        /* check channels */
    for (i = 0; i < uChannelNum; )
        { /* Note that i is only increased when channel is valid - if channel is invalid, another
             channel is copied in its place, and thus the same index should be checked again. However,
             since the number of channels is decreased, the loop end condition is getting nearer! */
        pParam->paramType = REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES;
        if (TI_TRUE == bPeriodicScan)
        {
            /* set band and scan type for periodic scan */
            pParam->content.channelCapabilityReq.band = puScanParams->tPeriodicScanParams.tChannels[ i ].eBand;
            if (puScanParams->tPeriodicScanParams.tChannels[ i ].eScanType == SCAN_TYPE_NORMAL_PASSIVE)
            {
                pParam->content.channelCapabilityReq.scanOption = PASSIVE_SCANNING;
            }
            else
            {
                /* query the reg. domain whether this is a DFS channel */
                tDfsParam.paramType = REGULATORY_DOMAIN_IS_DFS_CHANNEL;
                tDfsParam.content.tDfsChannel.eBand = puScanParams->tPeriodicScanParams.tChannels[ i ].eBand;
                tDfsParam.content.tDfsChannel.uChannel = puScanParams->tPeriodicScanParams.tChannels[ i ].uChannel;
                regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tDfsParam);

                /* if this is a DFS channel */
                if (TI_TRUE == tDfsParam.content.tDfsChannel.bDfsChannel)
                {
                    /*
                     * DFS channels are first scanned passive and than active, so reg. domain can only validate
                     * these channels for pasiive scanning at the moment
                     */
                    pParam->content.channelCapabilityReq.scanOption = PASSIVE_SCANNING;

                    /* set the channel scan type to DFS */
                    puScanParams->tPeriodicScanParams.tChannels[ i ].eScanType = SCAN_TYPE_PACTSIVE;
                    /* passive scan time is passed for all channels to the TWD, and copied there to the FW */
                }
                else
                {
                    pParam->content.channelCapabilityReq.scanOption = ACTIVE_SCANNING;
                }
            }

            /* set channel for periodic scan */
            pParam->content.channelCapabilityReq.channelNum =
                puScanParams->tPeriodicScanParams.tChannels[ i ].uChannel;
            regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, pParam);
            if (TI_FALSE == pParam->content.channelCapabilityRet.channelValidity)
            {   /* channel not allowed - copy the rest of the channel in its place */
                os_memoryCopy (pScanCncn->hOS, &(puScanParams->tPeriodicScanParams.tChannels[ i ]),
                               &(puScanParams->tPeriodicScanParams.tChannels[ i + 1 ]),
                               sizeof(TPeriodicChannelEntry) * (puScanParams->tPeriodicScanParams.uChannelNum - i - 1));
                puScanParams->tPeriodicScanParams.uChannelNum--;
                uChannelNum--;
            }
            else
            {
                /* also set the power level to the minimumm between requested power and allowed power */
                puScanParams->tPeriodicScanParams.tChannels[ i ].uTxPowerLevelDbm =
                        TI_MIN( pParam->content.channelCapabilityRet.maxTxPowerDbm,
                                puScanParams->tPeriodicScanParams.tChannels[ i ].uTxPowerLevelDbm );

                i += 1;
            }
        }
        else
        {
            /* set band and scan type for one-shot scan */
            pParam->content.channelCapabilityReq.band = puScanParams->tOneShotScanParams.band;
            if ((puScanParams->tOneShotScanParams.scanType == SCAN_TYPE_NORMAL_PASSIVE) ||
                (puScanParams->tOneShotScanParams.scanType == SCAN_TYPE_TRIGGERED_PASSIVE) ||
                (puScanParams->tOneShotScanParams.scanType == SCAN_TYPE_SPS))
            {
                pParam->content.channelCapabilityReq.scanOption = PASSIVE_SCANNING;
            }
            else
            {
                pParam->content.channelCapabilityReq.scanOption = ACTIVE_SCANNING;
            }

            /* set channel for one-shot scan - SPS */
            if (SCAN_TYPE_SPS == puScanParams->tOneShotScanParams.scanType)
            {
                pParam->content.channelCapabilityReq.channelNum =
                    puScanParams->tOneShotScanParams.channelEntry[ i ].SPSChannelEntry.channel;
                regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, pParam);
                if (TI_FALSE == pParam->content.channelCapabilityRet.channelValidity)
                {   /* channel not allowed - copy the rest of the channel in its place */
                    os_memoryCopy (pScanCncn->hOS, &(puScanParams->tOneShotScanParams.channelEntry[ i ]),
                                   &(puScanParams->tOneShotScanParams.channelEntry[ i + 1 ]),
                                   sizeof(TScanSpsChannelEntry) * (puScanParams->tOneShotScanParams.numOfChannels - i - 1));
                    puScanParams->tOneShotScanParams.numOfChannels--;
                    uChannelNum--;
                }
                else
                {
                    i += 1;
                }

            }
            /* set channel for one-shot scan - all other scan types */
            else
            {
                pParam->content.channelCapabilityReq.channelNum =
                    puScanParams->tOneShotScanParams.channelEntry[ i ].normalChannelEntry.channel;
                regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, pParam);
                if (TI_FALSE == pParam->content.channelCapabilityRet.channelValidity)
                {   /* channel not allowed - copy the rest of the channel in its place */
                    os_memoryCopy (pScanCncn->hOS, &(puScanParams->tOneShotScanParams.channelEntry[ i ]),
                                   &(puScanParams->tOneShotScanParams.channelEntry[ i + 1 ]),
                                   sizeof(TScanNormalChannelEntry) * (puScanParams->tOneShotScanParams.numOfChannels - i - 1));
                    puScanParams->tOneShotScanParams.numOfChannels--;
                    uChannelNum--;
                }
                else
                {
                    puScanParams->tOneShotScanParams.channelEntry[i].normalChannelEntry.txPowerDbm =
                            TI_MIN (pParam->content.channelCapabilityRet.maxTxPowerDbm,
                                    puScanParams->tOneShotScanParams.channelEntry[i].normalChannelEntry.txPowerDbm);
                    i += 1;
                }
            }
        }
    }
    os_memoryFree(pScanCncn->hOS, pParam, sizeof(paramInfo_t));
}

/**
 * \fn     scanCncn_SGconfigureScanParams
 * \brief  Configures Bluetooth coexistence compensation paramters
 *
 * Configures Bluetooth coexistence compensation paramters.
 * This function is called when SG is enabled or disabled from the SoftGemini module.
 *          The compensation is needed since BT Activity holds the antenna and over-ride Scan activity
 *
 * \param hScanCncn - handle to the scan concentrator object.\n
 * \param bUseSGParams - whether to use the new parameters (TI_TRUE when SG is enabled)
 * \param  probeReqPercent - increasing num probe requests in that percentage
 * \param SGcompensationMaxTime - max value from which we won't increase dwelling time
 * \param SGcompensationPercent - increasing dwell time in that percentage
 * \return None
 * \sa     scanCncn_SGupdateScanParams
 */
void scanCncn_SGconfigureScanParams (TI_HANDLE hScanCncn, TI_BOOL bUseSGParams,
                                     TI_UINT8 probeReqPercent, TI_UINT32 SGcompensationMaxTime,
                                             TI_UINT32 SGcompensationPercent)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;

    pScanCncn->bUseSGParams             = bUseSGParams;
    pScanCncn->uSGprobeRequestPercent   = probeReqPercent;
    pScanCncn->uSGcompensationMaxTime   = SGcompensationMaxTime;
    pScanCncn->uSGcompensationPercent   = SGcompensationPercent;

    TRACE4(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_SGconfigureScanParams: bUseSGParams=%d, numOfProbeRequest=%d, compensationMaxTime=%d, SGcompensationPercent=%d\n", pScanCncn->bUseSGParams, pScanCncn->uSGprobeRequestPercent, pScanCncn->uSGcompensationMaxTime, pScanCncn->uSGcompensationPercent);
}

/**
 * \fn     scanCncn_SGupdateScanParams
 * \brief  Updates dwell times and probe request number to compensate for bluetooth transmissions
 *
 * Updates dwell times and probe request number to compensate for bluetooth transmissions
 *
 * \param  hScanCncn - handle to the scan concentrator object
 * \param  puScanParams - a pointer to the scan parmeters union
 * \param  bPeriodicScan - TRUE if the parameters are for periodic scan, FALSE if for one-shot scan
 * \return None
 * \sa     scanCncn_SGconfigureScanParams
 */
void scanCncn_SGupdateScanParams (TI_HANDLE hScanCncn, UScanParams *puScanParams, TI_BOOL bPeriodicScan)
{
    TScanCncn           *pScanCncn = (TScanCncn*)hScanCncn;
    TI_UINT32           i, uTempTime;

    /* one shot scan */
    if (TI_FALSE == bPeriodicScan)
    {
        /* get a pointer to the one-shot scan params */
        TScanParams *pScanParams = &(puScanParams->tOneShotScanParams);

        /* for each channel increase the min and max dwell time */
        for (i = 0; i < pScanParams->numOfChannels; i++)
        {
            /* SPS scan */
            if (SCAN_TYPE_SPS == pScanParams->scanType)
            {
                if (pScanCncn->uSGcompensationMaxTime >
                    pScanParams->channelEntry[i].SPSChannelEntry.scanDuration)
                {
                    uTempTime = ((pScanParams->channelEntry[i].SPSChannelEntry.scanDuration) *
                        (100 + pScanCncn->uSGcompensationPercent)) / 100 ;

                    if (uTempTime > pScanCncn->uSGcompensationMaxTime)
                    {
                        uTempTime = pScanCncn->uSGcompensationMaxTime;
                    }
                    pScanParams->channelEntry[i].SPSChannelEntry.scanDuration = uTempTime;
                }
            }
            /* all other scan types */
            else
            {
                if (pScanCncn->uSGcompensationMaxTime >
            pScanParams->channelEntry[i].normalChannelEntry.minChannelDwellTime)
                {
                    uTempTime = ((pScanParams->channelEntry[i].normalChannelEntry.minChannelDwellTime) *
                        (100 + pScanCncn->uSGcompensationPercent)) / 100 ;

                    if (uTempTime > pScanCncn->uSGcompensationMaxTime)
                    {
                        uTempTime = pScanCncn->uSGcompensationMaxTime;
                    }
                    pScanParams->channelEntry[i].normalChannelEntry.minChannelDwellTime = uTempTime;
                }

                if (pScanCncn->uSGcompensationMaxTime >
                pScanParams->channelEntry[i].normalChannelEntry.maxChannelDwellTime)
                {
                    uTempTime = ((pScanParams->channelEntry[i].normalChannelEntry.maxChannelDwellTime) *
                        (100 + pScanCncn->uSGcompensationPercent)) / 100 ;

                    if (uTempTime > pScanCncn->uSGcompensationMaxTime)
                    {
                        uTempTime = pScanCncn->uSGcompensationMaxTime;
                    }
                    pScanParams->channelEntry[i].normalChannelEntry.maxChannelDwellTime = uTempTime;
                }
            }
        }

        /* update ProbeReqNumber by SG percantage */
        if (pScanParams->probeReqNumber > 0)
        {
            pScanParams->probeReqNumber = ((pScanParams->probeReqNumber) *
                    (100 + pScanCncn->uSGprobeRequestPercent)) / 100 ;
        }
    }
    /* periodic scan */
    else
    {
        TPeriodicScanParams *pPeriodicScanParams = &(puScanParams->tPeriodicScanParams);

        /* for each channel increase the min and max dwell time */
        for (i = 0; i < pPeriodicScanParams->uChannelNum; i++)
        {
            if (pScanCncn->uSGcompensationMaxTime >
                pPeriodicScanParams->tChannels[ i ].uMinDwellTimeMs)
            {
                uTempTime = ((pPeriodicScanParams->tChannels[ i ].uMinDwellTimeMs) *
                    (100 + pScanCncn->uSGcompensationPercent)) / 100 ;

                if (uTempTime > pScanCncn->uSGcompensationMaxTime)
                {
                    uTempTime = pScanCncn->uSGcompensationMaxTime;
                }
                pPeriodicScanParams->tChannels[ i ].uMinDwellTimeMs = uTempTime;
            }

            if (pScanCncn->uSGcompensationMaxTime >
                pPeriodicScanParams->tChannels[ i ].uMaxDwellTimeMs)
            {
                uTempTime = ((pPeriodicScanParams->tChannels[ i ].uMaxDwellTimeMs) *
                    (100 + pScanCncn->uSGcompensationPercent)) / 100 ;

                if (uTempTime > pScanCncn->uSGcompensationMaxTime)
                {
                    uTempTime = pScanCncn->uSGcompensationMaxTime;
                }
                pPeriodicScanParams->tChannels[ i ].uMaxDwellTimeMs = uTempTime;
            }
        }

        /* update ProbeReqNumber by SG percantage */
        if (pPeriodicScanParams->uProbeRequestNum > 0)
        {
            pPeriodicScanParams->uProbeRequestNum = ((pPeriodicScanParams->uProbeRequestNum) *
                    (100 + pScanCncn->uSGprobeRequestPercent)) / 100 ;
        }
    }
}