/*
 * regulatoryDomain.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 regulatoryDomain.c
 *  \brief regulatoryDomain module interface
 *
 *  \see regulatoryDomain.h
 */

/************************************************************************************************/
/*  												*/
/*		MODULE:		regulatoryDomain.c					        */
/*		PURPOSE:	regulatoryDomain module interface.			        */
/*                  This module calculated the channel that should be scanned and that are      */
/*                   supported. Moreover, he set the transmit power level according to the      */
/*                   regulatory domain requirements and the supported channel.                  */
/*								 			        */
/************************************************************************************************/
#define __FILE_ID__  FILE_ID_3
#include "report.h"
#include "osApi.h"
#include "paramOut.h"
#include "regulatoryDomain.h"
#include "regulatoryDomainApi.h"
#include "TWDriver.h"
#include "siteMgrApi.h"
#include "SwitchChannelApi.h"
#include "DrvMainModules.h"
#include "TWDriver.h"


/* Mask for retrieving the TxPower from the Scan Control Table */
#define MASK_TX_POWER					(0x1f) /* bits 0-4 indicates MaxTxPower */ 
#define MASK_ACTIVE_ALLOWED 			(0x40) /* bit 6 indiactes the channel is allowed for Active scan */
#define MASK_FREQ_ALLOWED 				(0x80) /* bit 7 indicates the cahnnel is allowed*/

#define CHANNEL_VALIDITY_TS_THRESHOLD   10000 /* 10 sec */

/* 
* Small macro to convert Dbm units into Dbm/10 units. This macro is important
* in order to avoid over-flow of Dbm units bigger than 25
*/
#define DBM2DBMDIV10(uTxPower) \
	((uTxPower) > (MAX_TX_POWER / DBM_TO_TX_POWER_FACTOR) ? \
		MAX_TX_POWER : (uTxPower) * DBM_TO_TX_POWER_FACTOR)		


/********************************************************************************/
/*						Internal functions prototypes.							*/
/********************************************************************************/
static TI_STATUS regulatoryDomain_updateCurrTxPower(regulatoryDomain_t	*pRegulatoryDomain);

static void regulatoryDomain_setChannelValidity(regulatoryDomain_t *pRegulatoryDomain, 
												TI_UINT16 channelNum, TI_BOOL channelValidity);

static TI_STATUS setSupportedChannelsAccording2CountryIe(regulatoryDomain_t *pRegulatoryDomain, TCountry*	pCountry, TI_BOOL band_2_4);

static void setSupportedChannelsAccording2ScanControlTable(regulatoryDomain_t  *pRegulatoryDomain);

static TI_STATUS regulatoryDomain_getChannelCapability(regulatoryDomain_t *pRegulatoryDomain, 
													   channelCapabilityReq_t channelCapabilityReq, 
													   channelCapabilityRet_t *channelCapabilityRet);

static void regulatoryDomain_updateChannelsTs(regulatoryDomain_t *pRegulatoryDomain, TI_UINT8 channel);

static void regulatoryDomain_buildDefaultListOfChannelsPerBand(regulatoryDomain_t *pRegulatoryDomain, ERadioBand band, TI_UINT8 *listSize);

static void regulatoryDomain_checkCountryCodeExpiry(regulatoryDomain_t *pRegulatoryDomain);

static TI_BOOL regulatoryDomain_isChannelSupprted(regulatoryDomain_t *pRegulatoryDomain, TI_UINT8 channel);

static TI_BOOL regulatoryDomain_isCountryFound(regulatoryDomain_t *pRegulatoryDomain, ERadioBand radioBand);

static void regulatoryDomain_getPowerTableMinMax (regulatoryDomain_t *pRegulatoryDomain,
                                                  powerCapability_t  *pPowerCapability);

static TI_UINT8 regulatoryDomain_getMaxPowerAllowed(regulatoryDomain_t	*pRegulatoryDomain,
												 TI_UINT8				uChannel,
												 ERadioBand		eBand,
												 TI_BOOL				bServingChannel);

/********************************************************************************/
/*						Interface functions Implementation.						*/
/********************************************************************************/


/************************************************************************
 *                        regulatoryDomain_create									*
 ************************************************************************
DESCRIPTION: regulatoryDomain module creation function, called by the config mgr in creation phase 
				performs the following:
				-	Allocate the regulatoryDomain handle
				                                                                                                   
INPUT:      hOs -			Handle to OS		


OUTPUT:		

RETURN:     Handle to the regulatoryDomain module on success, NULL otherwise

************************************************************************/
TI_HANDLE regulatoryDomain_create(TI_HANDLE hOs)
{
	regulatoryDomain_t			*pRegulatoryDomain = NULL;
	
	/* allocating the regulatoryDomain object */
	pRegulatoryDomain = os_memoryAlloc(hOs,sizeof(regulatoryDomain_t));

	if (pRegulatoryDomain == NULL)
		return NULL;

	return(pRegulatoryDomain);
}


/************************************************************************
 *                        regulatoryDomain_init							*
 ************************************************************************
DESCRIPTION: Module init function, Called by the DrvMain in init phase
				performs the following:
				-	Reset & initializes local variables
				-	Init the handles to be used by the module
                                                                                                   
INPUT:      pStadHandles - List of handles to be used by the module

OUTPUT:		

RETURN:     void
************************************************************************/
void regulatoryDomain_init (TStadHandlesList *pStadHandles)
{
	regulatoryDomain_t *pRegulatoryDomain = (regulatoryDomain_t *)(pStadHandles->hRegulatoryDomain);

	/* init variables */
	pRegulatoryDomain->country_2_4_WasFound		= TI_FALSE;
	pRegulatoryDomain->country_5_WasFound		= TI_FALSE;
	pRegulatoryDomain->uExternTxPowerPreferred	= MAX_TX_POWER;	/* i.e. no restriction */
	pRegulatoryDomain->uPowerConstraint			= MIN_TX_POWER;	/* i.e. no restriction */
	 
	/* Init handlers */
	pRegulatoryDomain->hSiteMgr       = pStadHandles->hSiteMgr;
	pRegulatoryDomain->hTWD	          = pStadHandles->hTWD;
	pRegulatoryDomain->hReport	      = pStadHandles->hReport;
	pRegulatoryDomain->hOs	          = pStadHandles->hOs;
    pRegulatoryDomain->hSwitchChannel = pStadHandles->hSwitchChannel;
}


/************************************************************************
 *                        regulatoryDomain_SetDefaults						*
 ************************************************************************
DESCRIPTION: regulatoryDomain module configuration function, called by the config mgr in configuration phase
				performs the following:
				-	Reset & initializes local variables
				-	Init the handles to be used by the module
                                                                                                   
INPUT:      hRegulatoryDomain	-	regulatoryDomain handle
			List of handles to be used by the module
			pRegulatoryDomainInitParams	-	Init table of the module.		


OUTPUT:		

RETURN:     TI_OK on success, TI_NOK otherwise

************************************************************************/
TI_STATUS regulatoryDomain_SetDefaults (TI_HANDLE 	hRegulatoryDomain,
                                        regulatoryDomainInitParams_t *pRegulatoryDomainInitParams)
{
	regulatoryDomain_t *pRegulatoryDomain = (regulatoryDomain_t *)hRegulatoryDomain;

	/* User max Tx power for all channels */
	pRegulatoryDomain->uUserMaxTxPower	  = pRegulatoryDomainInitParams->desiredTxPower; 
	/* Temporary Tx Power control to be used */
    pRegulatoryDomain->uTemporaryTxPower  = pRegulatoryDomainInitParams->uTemporaryTxPower;
    pRegulatoryDomain->uDesiredTemporaryTxPower = pRegulatoryDomainInitParams->uTemporaryTxPower;

    /* 
	 * Indicate the time in which the STA didn't receive any country code and was not connected, and therefore
     * will delete its current country code 
	 */
    pRegulatoryDomain->uTimeOutToResetCountryMs = pRegulatoryDomainInitParams->uTimeOutToResetCountryMs;
	pRegulatoryDomain->uLastCountryReceivedTS = 0;

	pRegulatoryDomain->regulatoryDomainEnabled = pRegulatoryDomainInitParams->multiRegulatoryDomainEnabled;
	pRegulatoryDomain->spectrumManagementEnabled = pRegulatoryDomainInitParams->spectrumManagementEnabled;
	if (pRegulatoryDomain->spectrumManagementEnabled == TI_TRUE)
	{
		pRegulatoryDomain->regulatoryDomainEnabled = TI_TRUE;
	}
		
	/* Getting the desired Control Table contents for 2.4 Ghz*/
	os_memoryCopy(pRegulatoryDomain->hOs,
				  (void *)pRegulatoryDomain->scanControlTable.ScanControlTable24.tableString,
				  (void *)pRegulatoryDomainInitParams->desiredScanControlTable.ScanControlTable24.tableString,
					NUM_OF_CHANNELS_24 * sizeof(TI_INT8));

	/* Getting the desired Control Table contents for 5 Ghz*/
	os_memoryCopy(pRegulatoryDomain->hOs,
				  (void *)pRegulatoryDomain->scanControlTable.ScanControlTable5.tableString,
				  (void *)pRegulatoryDomainInitParams->desiredScanControlTable.ScanControlTable5.tableString,
					A_5G_BAND_NUM_CHANNELS * sizeof(TI_INT8));

	setSupportedChannelsAccording2ScanControlTable(pRegulatoryDomain);

    pRegulatoryDomain->minDFS_channelNum = A_5G_BAND_MIN_MIDDLE_BAND_DFS_CHANNEL;
    pRegulatoryDomain->maxDFS_channelNum = A_5G_BAND_MAX_UPPER_BAND_DFS_CHANNEL;

TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_INIT, ".....Regulatory domain configured successfully\n");

	return TI_OK;
}

TI_STATUS regulatoryDomain_setParam(TI_HANDLE hRegulatoryDomain,
									paramInfo_t	*pParam)
{
	regulatoryDomain_t *pRegulatoryDomain = (regulatoryDomain_t *)hRegulatoryDomain;
    
			
	switch(pParam->paramType)
	{
    case REGULATORY_DOMAIN_COUNTRY_PARAM:
        {
            TI_BOOL        bBand_2_4;

            /* Sanity check */
            if (NULL == pParam->content.pCountry)
            {   
                TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR, "regulatoryDomain_setParam, REGULATORY_DOMAIN_COUNTRY_PARAM is set with NULL pointer");

                return TI_NOK;
            }
            else /* Update country code and supported channels */
            {         
                bBand_2_4 = siteMgr_isCurrentBand24(pRegulatoryDomain->hSiteMgr);

			    /* Setting the CountryIE for every Band */
			    setSupportedChannelsAccording2CountryIe(pRegulatoryDomain, pParam->content.pCountry, bBand_2_4);
            }
        }
		break;

	case REGULATORY_DOMAIN_SET_POWER_CONSTRAINT_PARAM:

        /* Update only if 11h enabled */
        if (pRegulatoryDomain->spectrumManagementEnabled)
		{	
            /* Convert to RegDomain units */
            TI_UINT8 uNewPowerConstraint = DBM2DBMDIV10(pParam->content.powerConstraint);

TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "SET_POWER_CONSTRAINT Old= %d New = %d (Only if bigger...)\n", 							  pRegulatoryDomain->uPowerConstraint, uNewPowerConstraint);

			/* Update powerConstraint */
			if ( pRegulatoryDomain->uPowerConstraint != uNewPowerConstraint )
			{
				pRegulatoryDomain->uPowerConstraint = uNewPowerConstraint;
				/* Set new Tx power to TWD - only if needed ! */
				regulatoryDomain_updateCurrTxPower(pRegulatoryDomain);
			}
        }
		break;	
		
	case REGULATORY_DOMAIN_EXTERN_TX_POWER_PREFERRED:
		/* ExternTxPowerPreferred is the TX Power Control (TPC) */
		{
			/* Convert to RegDomain units */
			TI_UINT8 uNewTPC = DBM2DBMDIV10(pParam->content.ExternTxPowerPreferred);

TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "REGULATORY_DOMAIN_EXTERN_TX_POWER_PREFERRED Old= %d New = %d\n", 				pRegulatoryDomain->uExternTxPowerPreferred, uNewTPC);

			if ( uNewTPC != pRegulatoryDomain->uExternTxPowerPreferred )
			{
				pRegulatoryDomain->uExternTxPowerPreferred = uNewTPC;
				/* Set new Tx power to TWD - only if needed ! */
				regulatoryDomain_updateCurrTxPower(pRegulatoryDomain);
			}
		}
		break;	
	
	case REGULATORY_DOMAIN_SET_CHANNEL_VALIDITY:
		/* Set channel as Valid or Invalid for Active SCAN only.
			Mainly used by DFS when Switch Channel is active */
		regulatoryDomain_setChannelValidity(pRegulatoryDomain, pParam->content.channelValidity.channelNum, 
															   pParam->content.channelValidity.channelValidity);
		break;
	
	case REGULATORY_DOMAIN_CURRENT_TX_POWER_IN_DBM_PARAM:
		/* This case is called when the desired Tx Power Level in Dbm is changed by the user */
        if(pRegulatoryDomain->uUserMaxTxPower != pParam->content.desiredTxPower)
        {
            pRegulatoryDomain->uUserMaxTxPower = pParam->content.desiredTxPower;			
			/* Set new Tx power to TWD - only if needed ! */
			regulatoryDomain_updateCurrTxPower(pRegulatoryDomain);
        }

		break;

	case REGULATORY_DOMAIN_TX_POWER_AFTER_SELECTION_PARAM:
		/* Called after joining BSS, set Tx power to TWD */

        TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_setParam, REGULATORY_DOMAIN_TX_POWER_AFTER_SELECTION_PARAM \n");

	   /* setting the Tx Power according to the selected channel */
        regulatoryDomain_updateCurrTxPower(pRegulatoryDomain);
        
		break;

    case REGULATORY_DOMAIN_DISCONNECT_PARAM:
        TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_setParam, REGULATORY_DOMAIN_DISCONNECT_PARAM\n");

        pRegulatoryDomain->uExternTxPowerPreferred = MAX_TX_POWER;	/* i.e. no restriction */
        pRegulatoryDomain->uPowerConstraint		   = MIN_TX_POWER;	/* i.e. no restriction */

        /* Update the last time a country code was used. 
        After uTimeOutToResetCountryMs the country code will be deleted     */
        if (pRegulatoryDomain->country_2_4_WasFound || pRegulatoryDomain->country_5_WasFound)
        {
            pRegulatoryDomain->uLastCountryReceivedTS = os_timeStampMs(pRegulatoryDomain->hOs);
        }
        break;

	case REGULATORY_DOMAIN_UPDATE_CHANNEL_VALIDITY:
		regulatoryDomain_updateChannelsTs(pRegulatoryDomain, pParam->content.channel);
		break;

    case REGULATORY_DOMAIN_TEMPORARY_TX_ATTENUATION_PARAM:
		/* Temporary Tx Power control */
TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_setParam: temporary fix = %d, \n", pParam->content.bActivateTempPowerFix);

        pRegulatoryDomain->bTemporaryTxPowerEnable = pParam->content.bActivateTempPowerFix;

			regulatoryDomain_updateCurrTxPower(pRegulatoryDomain);

        break;

    case REGULATORY_DOMAIN_ENABLE_DISABLE_802_11D:
        TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_setParam, REGULATORY_DOMAIN_ENABLE_DISABLE_802_11D = %d, \n", pParam->content.enableDisable_802_11d);

        if ((pRegulatoryDomain->regulatoryDomainEnabled != pParam->content.enableDisable_802_11d) &&
            !pParam->content.enableDisable_802_11d && pRegulatoryDomain->spectrumManagementEnabled)
        {   /* Disable of 802_11d, is not allowed when 802_11h is enabled */
            TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR, "regulatoryDomain_setParam, Disable of 802_11d, is not allowed when 802_11h is enabled  \n");
            return TI_NOK;
            
        }
        pRegulatoryDomain->regulatoryDomainEnabled = pParam->content.enableDisable_802_11d;

		/* Mark that no country was found - applies for both enabling and disabling of 11d */
		pRegulatoryDomain->country_2_4_WasFound = TI_FALSE;
		pRegulatoryDomain->country_5_WasFound = TI_FALSE;

        if (!pRegulatoryDomain->regulatoryDomainEnabled)
        {   /* Set regulatory Domain according to scan control table */
            setSupportedChannelsAccording2ScanControlTable(pRegulatoryDomain);
        }

		break;

    case REGULATORY_DOMAIN_ENABLE_DISABLE_802_11H:
        TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_setParam, REGULATORY_DOMAIN_ENABLE_DISABLE_802_11H = %d, \n", pParam->content.enableDisable_802_11h);

        pRegulatoryDomain->spectrumManagementEnabled = pParam->content.enableDisable_802_11h;
        if (pParam->content.enableDisable_802_11h)
        {   /* If 802_11h is enabled, enable 802_11d as well */
            pRegulatoryDomain->regulatoryDomainEnabled = TI_TRUE;
        }
        switchChannel_enableDisableSpectrumMngmt(pRegulatoryDomain->hSwitchChannel, pRegulatoryDomain->spectrumManagementEnabled);
		break;

	case REGULATORY_DOMAIN_COUNTRY_2_4_PARAM:
        /* NOTE !!! use this feature carefully. */
        TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_setParam, REGULATORY_DOMAIN_COUNTRY_2_4_PARAM Len = %d, \n", pParam->paramLength);

        TRACE_INFO_HEX(pRegulatoryDomain->hReport, (TI_UINT8*)pParam->content.pCountry, sizeof(TCountry));

        return setSupportedChannelsAccording2CountryIe(pRegulatoryDomain, pParam->content.pCountry, TI_TRUE);

	case REGULATORY_DOMAIN_COUNTRY_5_PARAM:
        /* NOTE !!! use this feature carefully */
        return setSupportedChannelsAccording2CountryIe(pRegulatoryDomain, pParam->content.pCountry, TI_FALSE);


    case REGULATORY_DOMAIN_DFS_CHANNELS_RANGE:
        TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_setParam, DFS_CHANNELS_RANGE, min = %d, max = %d, \n", pParam->content.DFS_ChannelRange.minDFS_channelNum, pParam->content.DFS_ChannelRange.maxDFS_channelNum);

        if ((pParam->content.DFS_ChannelRange.minDFS_channelNum<A_5G_BAND_MIN_CHANNEL) ||
            (pParam->content.DFS_ChannelRange.maxDFS_channelNum>A_5G_BAND_MAX_CHANNEL) ||
            pParam->content.DFS_ChannelRange.minDFS_channelNum > pParam->content.DFS_ChannelRange.maxDFS_channelNum)
        {
            TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR, "regulatoryDomain_setParam, Bad DFS_CHANNELS_RANGE, min = %d, max = %d, \n", pParam->content.DFS_ChannelRange.minDFS_channelNum, pParam->content.DFS_ChannelRange.maxDFS_channelNum);
            return TI_NOK;
        }
        pRegulatoryDomain->minDFS_channelNum = (TI_UINT8)pParam->content.DFS_ChannelRange.minDFS_channelNum;
        pRegulatoryDomain->maxDFS_channelNum = (TI_UINT8)pParam->content.DFS_ChannelRange.maxDFS_channelNum;

        break;

	default:
TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR, "Set param, Params is not supported, %d\n\n", pParam->paramType);
		return PARAM_NOT_SUPPORTED;
	}

	return TI_OK;
}

TI_STATUS regulatoryDomain_getParam(TI_HANDLE hRegulatoryDomain,
									paramInfo_t	*pParam)
{
	regulatoryDomain_t	*pRegulatoryDomain = (regulatoryDomain_t *)hRegulatoryDomain;

    /* Check if country code is still valid */
    regulatoryDomain_checkCountryCodeExpiry(pRegulatoryDomain);

	switch(pParam->paramType)
	{

	case REGULATORY_DOMAIN_TX_POWER_LEVEL_TABLE_PARAM:
        {
            TFwInfo *pFwInfo = TWD_GetFWInfo (pRegulatoryDomain->hTWD);
            os_memoryCopy(pRegulatoryDomain->hOs, 
                          (void *)&pParam->content.powerLevelTable,
                          (void *)pFwInfo->txPowerTable,
                          sizeof(pFwInfo->txPowerTable));
        }
		break;

	case REGULATORY_DOMAIN_MANAGEMENT_CAPABILITY_ENABLED_PARAM:
		pParam->content.spectrumManagementEnabled = pRegulatoryDomain->spectrumManagementEnabled;
		break;
		
	case REGULATORY_DOMAIN_ENABLED_PARAM:
		pParam->content.regulatoryDomainEnabled = pRegulatoryDomain->regulatoryDomainEnabled;
		break;

	case REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES:
		{
			channelCapabilityReq_t	channelCapabilityReq;

			channelCapabilityReq.band = pParam->content.channelCapabilityReq.band;
			channelCapabilityReq.channelNum = pParam->content.channelCapabilityReq.channelNum;
			channelCapabilityReq.scanOption = pParam->content.channelCapabilityReq.scanOption;

            regulatoryDomain_getChannelCapability(pRegulatoryDomain, channelCapabilityReq, &pParam->content.channelCapabilityRet);
		}
		break;

	case REGULATORY_DOMAIN_POWER_CAPABILITY_PARAM:
		/* power capability is only applicable when spectrum management is active (802.11h) */ 
		if(pRegulatoryDomain->spectrumManagementEnabled)
		{
            regulatoryDomain_getPowerTableMinMax (pRegulatoryDomain, &pParam->content.powerCapability);
		}
		else
		{
			return TI_NOK;
		}
		break;

	case REGULATORY_DOMAIN_IS_CHANNEL_SUPPORTED:
		/* checking if the channel is supported */
		pParam->content.bIsChannelSupprted  = 
			regulatoryDomain_isChannelSupprted(pRegulatoryDomain, pParam->content.channel);
			
		break;

	case REGULATORY_DOMAIN_ALL_SUPPORTED_CHANNELS:
		{
			ERadioBand	band = pParam->content.siteMgrRadioBand;
			regulatoryDomain_buildDefaultListOfChannelsPerBand(pRegulatoryDomain, band, &pParam->content.supportedChannels.sizeOfList);
		    pParam->content.supportedChannels.listOfChannels = pRegulatoryDomain->pDefaultChannels;
		}
		break;

	case REGULATORY_DOMAIN_CURRENT_TX_POWER_IN_DBM_PARAM:

            {
			TTwdParamInfo		tparam;
			/* Get last configured Tx power from TWD */
			tparam.paramType = TWD_TX_POWER_PARAM_ID;
			TWD_GetParam(pRegulatoryDomain->hTWD, &tparam);

			pParam->content.desiredTxPower = tparam.content.halCtrlTxPowerDbm;

TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_getParam, CURRENT_TX_POWER_IN_DBM  = %d\n", 							   pParam->content.desiredTxPower);
            }

        break;

    case REGULATORY_DOMAIN_COUNTRY_PARAM:
        {   
            /* This case is used as an inner function of the driver to retrieve the full IE of the country */
            TI_BOOL bBand_2_4 = siteMgr_isCurrentBand24(pRegulatoryDomain->hSiteMgr);

            if (bBand_2_4)
            {
                if (pRegulatoryDomain->country_2_4_WasFound)
                {
                    pParam->content.pCountry = &pRegulatoryDomain->country24;
                }
                else    /* Do not use the Inforamtion */
                {
                    pParam->content.pCountry = NULL;
                }
            }   /* band 5.0 */
            else
            { 
                if (pRegulatoryDomain->country_5_WasFound)
                {
                   pParam->content.pCountry = &pRegulatoryDomain->country5;
                }
                else    /* Do not use the Inforamtion */
                {
                    pParam->content.pCountry = NULL;
                }
            }
        }
        break;
        
	case REGULATORY_DOMAIN_COUNTRY_2_4_PARAM:
		/* Getting only country string */

        if (pRegulatoryDomain->country_2_4_WasFound)
        {
            os_memoryCopy(pRegulatoryDomain->hOs, (void*)pParam->content.pCountryString, (void*)pRegulatoryDomain->country24.countryIE.CountryString, DOT11_COUNTRY_STRING_LEN);
        }
        else
        {
            pParam->content.pCountryString[0] = '\0';
        }
 		break;

	case REGULATORY_DOMAIN_COUNTRY_5_PARAM:
		/* Getting only country string */

        if (pRegulatoryDomain->country_5_WasFound)
        {
            os_memoryCopy(pRegulatoryDomain->hOs, (void*)pParam->content.pCountryString, (void*)pRegulatoryDomain->country5.countryIE.CountryString, DOT11_COUNTRY_STRING_LEN);
        }
        else
        {
            pParam->content.pCountryString[0] = '\0';
        }
		break;

    case REGULATORY_DOMAIN_DFS_CHANNELS_RANGE:
        TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_getParam, DFS_CHANNELS_RANGE, min = %d, max = %d, \n", pRegulatoryDomain->minDFS_channelNum, pRegulatoryDomain->maxDFS_channelNum);
        pParam->content.DFS_ChannelRange.minDFS_channelNum = pRegulatoryDomain->minDFS_channelNum;
        pParam->content.DFS_ChannelRange.maxDFS_channelNum = pRegulatoryDomain->maxDFS_channelNum;

        break;

	case REGULATORY_DOMAIN_IS_COUNTRY_FOUND:

		pParam->content.bIsCountryFound = 
			 regulatoryDomain_isCountryFound(pRegulatoryDomain, pParam->content.eRadioBand);
		
		break;

    case REGULATORY_DOMAIN_IS_DFS_CHANNEL:

        if ((pRegulatoryDomain->spectrumManagementEnabled) && /* 802.11h is enabled */
            (RADIO_BAND_5_0_GHZ == pParam->content.tDfsChannel.eBand) && /* band is 5 GHz */
            (pRegulatoryDomain->minDFS_channelNum <= pParam->content.tDfsChannel.uChannel) && /* channel is within DFS range */
            (pRegulatoryDomain->maxDFS_channelNum >= pParam->content.tDfsChannel.uChannel))
        {
            pParam->content.tDfsChannel.bDfsChannel = TI_TRUE;
        }
        else
        {
            pParam->content.tDfsChannel.bDfsChannel = TI_FALSE;
        }
        break;

    case REGULATORY_DOMAIN_TIME_TO_COUNTRY_EXPIRY:
        /* if a country was found for either band */
        if ((pRegulatoryDomain->country_2_4_WasFound) || (pRegulatoryDomain->country_5_WasFound))
        {
            paramInfo_t *pParam2;
            TI_STATUS   connStatus;
            TI_UINT32   uCurrentTS = os_timeStampMs (pRegulatoryDomain->hOs);

            pParam2 = (paramInfo_t *)os_memoryAlloc(pRegulatoryDomain->hOs, sizeof(paramInfo_t));
            if (!pParam2)
            {
                return TI_NOK;
            }

            /* Get connection status */
            pParam2->paramType = SITE_MGR_CURRENT_SSID_PARAM;
            connStatus = siteMgr_getParam (pRegulatoryDomain->hSiteMgr, pParam2);
            os_memoryFree(pRegulatoryDomain->hOs, pParam2, sizeof(paramInfo_t));

            /* if we are connected, return 0 */
            if (connStatus != NO_SITE_SELECTED_YET)
            {
                pParam->content.uTimeToCountryExpiryMs = 0;
            }
            else
            {
                /* 
                 * if country already expired (shouldn't happen as we are checking it at the top of
                 * get_param, but just in case...
                 */
                if ((uCurrentTS - pRegulatoryDomain->uLastCountryReceivedTS) > pRegulatoryDomain->uTimeOutToResetCountryMs)
                {
                    pParam->content.uTimeToCountryExpiryMs = 0;
                }
                else
                {
                    pParam->content.uTimeToCountryExpiryMs = 
                        pRegulatoryDomain->uTimeOutToResetCountryMs - (uCurrentTS - pRegulatoryDomain->uLastCountryReceivedTS);
                }
            }
        }
        else
        {
            pParam->content.uTimeToCountryExpiryMs = 0;
        }
        break;

	default:
		TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_WARNING, "Get param, Params is not supported, %d\n\n", pParam->paramType);
		return PARAM_NOT_SUPPORTED;
	}

	return TI_OK;
}

/************************************************************************
 *                        regulatoryDomain_destroy						*
 ************************************************************************
DESCRIPTION: regulatoryDomain module destroy function, called by the config mgr in the destroy phase 
				performs the following:
				-	Free all memory allocated by the module
                                                                                                   
INPUT:      hRegulatoryDomain	-	regulatoryDomain handle.		


OUTPUT:		

RETURN:     TI_OK on success, TI_NOK otherwise

************************************************************************/
TI_STATUS regulatoryDomain_destroy(TI_HANDLE hRegulatoryDomain)
{
	regulatoryDomain_t	*pRegulatoryDomain = (regulatoryDomain_t *)hRegulatoryDomain;

	if (pRegulatoryDomain == NULL)
		return TI_OK;

    os_memoryFree(pRegulatoryDomain->hOs, pRegulatoryDomain, sizeof(regulatoryDomain_t));

	return TI_OK;
}

/************************************************************************
 *                        regulatoryDomain_isCountryFound						*
 ************************************************************************
DESCRIPTION: This function returns the validity of Country according to band
                                                                                                   
INPUT:      hRegulatoryDomain	-	regulatoryDomain handle.   
            radioBand           - the desired band 	


OUTPUT:		

RETURN:     TI_TRUE - if country IE was found according to the band.
            TI_FALSE - otherwise.

************************************************************************/
TI_BOOL regulatoryDomain_isCountryFound(regulatoryDomain_t  *pRegulatoryDomain, ERadioBand radioBand)
{

    if(radioBand == RADIO_BAND_2_4_GHZ)
    {
            return pRegulatoryDomain->country_2_4_WasFound;
    }
    else
    {
        return pRegulatoryDomain->country_5_WasFound;
    }

}

/***********************************************************************
 *                       setSupportedChannelsAccording2CountryIe									
 ***********************************************************************
DESCRIPTION:	Called when beacon/Probe Response with Country IE
				is found.
				The function sets the local countryIE per band with the CountryIE
				 that was detected in the last passive scan.
				 It is assumed that only one Country IE per band is allowed.
				 If Country is changed when the TNET is loaded, it should
				 be re-loaded in order to re-config the new Country domain.
                                                                                                   
INPUT:      hRegulatoryDomain	-	RegulatoryDomain handle.
			pCountry	-	pointer to the detected country IE.

OUTPUT:		

RETURN:     TI_OK - New country code was set (or the same one was already configured)
            TI_NOK - The new country code could not be set

************************************************************************/
static TI_STATUS setSupportedChannelsAccording2CountryIe(regulatoryDomain_t *pRegulatoryDomain, TCountry* pCountry, TI_BOOL band_2_4)
{
	channelCapability_t *pSupportedChannels;
	TI_UINT8				channelIndex;
	TI_UINT8				tripletChannelIndex, tripletChannelCnt;
	TI_UINT8				channelStep, numberOfChannels, minChannelNumber, maxChannelNumber;

	
	if (!pRegulatoryDomain->regulatoryDomainEnabled)
	{  /* Ignore the Country IE if 802.11d is disabled */
		return TI_NOK;
	}

    /* Check if the country code should be reset */
    regulatoryDomain_checkCountryCodeExpiry(pRegulatoryDomain);

	if( band_2_4 == TI_TRUE )
	{
		if (pRegulatoryDomain->country_2_4_WasFound)
		{	/* Do not update new Country IE */
			if (os_memoryCompare(pRegulatoryDomain->hOs, (void *)&pCountry->countryIE, (void *)&pRegulatoryDomain->country24.countryIE, sizeof(dot11_countryIE_t)))
			{
TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_WARNING, "setSupportedChannelsAccording2CountryIe different Country, cur=, new=\n");
            	return TI_NOK;
            }
            else    /* Same IE - just mark the TS and return TI_OK */
            {
                /* Mark the time of the received country IE */                
                pRegulatoryDomain->uLastCountryReceivedTS = os_timeStampMs(pRegulatoryDomain->hOs);
                return TI_OK;
            }
		}
		pRegulatoryDomain->country_2_4_WasFound = TI_TRUE;
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_2_4;
		channelStep = BG_24G_BAND_CHANNEL_HOPS;
		maxChannelNumber = NUM_OF_CHANNELS_24;
		minChannelNumber = BG_24G_BAND_MIN_CHANNEL;
		numberOfChannels = NUM_OF_CHANNELS_24;
		/* save the country IE */
		os_memoryCopy(pRegulatoryDomain->hOs, (void*)&pRegulatoryDomain->country24, (void *)pCountry, sizeof(TCountry));

        TRACE3(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "Country 2.4 =%c%c%c\n",pRegulatoryDomain->country24.countryIE.CountryString[0], pRegulatoryDomain->country24.countryIE.CountryString[1], pRegulatoryDomain->country24.countryIE.CountryString[2]);

	}
	else    /* band 5.0 */
	{
		if (pRegulatoryDomain->country_5_WasFound)
		{	/* Do not update new Country IE if the IE is the same*/
			if (os_memoryCompare(pRegulatoryDomain->hOs, (void *)&pCountry->countryIE, (void *)&pRegulatoryDomain->country5.countryIE, sizeof(dot11_countryIE_t)))
			{
TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_WARNING, "setSupportedChannelsAccording2CountryIe different Country, cur=, new=\n");
            	return TI_NOK;
            }
            else    /* Same IE - just mark the TS and return TI_OK */
            {
                /* Mark the time of the received country IE */                
                pRegulatoryDomain->uLastCountryReceivedTS = os_timeStampMs(pRegulatoryDomain->hOs);
                return TI_OK;
            }
		}
		pRegulatoryDomain->country_5_WasFound = TI_TRUE;
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_5;
		channelStep = A_5G_BAND_CHANNEL_HOPS;
		maxChannelNumber = A_5G_BAND_MAX_CHANNEL;
		minChannelNumber = A_5G_BAND_MIN_CHANNEL;
		numberOfChannels = A_5G_BAND_NUM_CHANNELS;
		/* save the country IE */
		os_memoryCopy(pRegulatoryDomain->hOs, (void*)&pRegulatoryDomain->country5, (void*)pCountry, sizeof(TCountry));

        TRACE3(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "Country 5 =%c%c%c\n",pRegulatoryDomain->country5.countryIE.CountryString[0], pRegulatoryDomain->country5.countryIE.CountryString[1], pRegulatoryDomain->country5.countryIE.CountryString[2]);
	}

    /*
     * New Country IE was saved. Now - update the last received TS and ScanControlTable
     */

    /* Mark the time of the received country IE */                
    pRegulatoryDomain->uLastCountryReceivedTS = os_timeStampMs(pRegulatoryDomain->hOs);

	/* First clear the validity of all channels 
		Overwrite the ScanControlTable */
	for (channelIndex=0; channelIndex<numberOfChannels; channelIndex++)
	{
		pSupportedChannels[channelIndex].channelValidityActive = TI_FALSE;
		pSupportedChannels[channelIndex].channelValidityPassive = TI_FALSE;
		pSupportedChannels[channelIndex].bChanneInCountryIe = TI_FALSE;
		pSupportedChannels[channelIndex].uMaxTxPowerDomain = MIN_TX_POWER; 	
	}
    
	tripletChannelCnt = (pCountry->len - DOT11_COUNTRY_STRING_LEN) / 3;
	/* set validity of the channels according to the band (2.4 or 5) */
	for( tripletChannelIndex = 0; tripletChannelIndex < tripletChannelCnt ; tripletChannelIndex++)
	{
		TI_UINT8	firstChannelNumInTriplet;
		
		firstChannelNumInTriplet = pCountry->countryIE.tripletChannels[tripletChannelIndex].firstChannelNumber;
TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "firstChannelNumInTriplet=%d,channelStep=%d\n", firstChannelNumInTriplet, channelStep);
		for (channelIndex=0; channelIndex<pCountry->countryIE.tripletChannels[tripletChannelIndex].numberOfChannels; channelIndex++)
		{
			TI_UINT16	channelNumber;

			channelNumber = firstChannelNumInTriplet+(channelIndex*channelStep);
TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "setSupportedChannelsAccording2CountryIe of channel=%d\n", channelNumber);
			
			if (channelNumber <= maxChannelNumber)
			{
				TI_UINT8 	channelIndex4Band;

				channelIndex4Band = (channelNumber-minChannelNumber);
				pSupportedChannels[channelIndex4Band].bChanneInCountryIe = TI_TRUE;
				pSupportedChannels[channelIndex4Band].channelValidityPassive = TI_TRUE;
				pSupportedChannels[channelIndex4Band].channelValidityActive = TI_TRUE;

				/* set the TX power in DBM/10 units */
			    pSupportedChannels[channelIndex4Band].uMaxTxPowerDomain = 
					DBM2DBMDIV10(pCountry->countryIE.tripletChannels[tripletChannelIndex].maxTxPowerLevel);

TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "channel = %d uMaxTxPowerDomain=%d\n", 										channelNumber, pSupportedChannels[channelIndex4Band].uMaxTxPowerDomain);
			}
		}
    }

	return TI_OK;
}


/***********************************************************************
 *                        regulatoryDomain_isChannelSupprted									
 ***********************************************************************
DESCRIPTION:	The function checks if the input channel is supported.
                                                                                                   
INPUT:      pRegulatoryDomain	-	RegulatoryDomain pointer.
			channel				-	Channel number.
			

OUTPUT:		

RETURN:     TI_OK if channel is supported, TI_NOK otherwise.

************************************************************************/
static TI_BOOL regulatoryDomain_isChannelSupprted(regulatoryDomain_t *pRegulatoryDomain, TI_UINT8 channel)
{
	TI_UINT8				channelIndex;
	channelCapability_t *pSupportedChannels;

	if (pRegulatoryDomain==NULL)
	{
		return TI_FALSE;
	}

	if ((channel<BG_24G_BAND_MIN_CHANNEL) || (channel>A_5G_BAND_MAX_CHANNEL))
	{
		return TI_FALSE;
	}
	if (channel>=A_5G_BAND_MIN_CHANNEL)
	{
		channelIndex = (channel-A_5G_BAND_MIN_CHANNEL);
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_5;
	}
	else
	{
		channelIndex = (channel-BG_24G_BAND_MIN_CHANNEL);
		if (channelIndex >= NUM_OF_CHANNELS_24)
		{
			TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR,
				   "regulatoryDomain_isChannelSupprted(): 2.4G invalid channel # %u\n", channel );
			return TI_FALSE;
		}
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_2_4;
	}
	if (pRegulatoryDomain->spectrumManagementEnabled 
		&& (channel >= pRegulatoryDomain->minDFS_channelNum) 
        && (channel <= pRegulatoryDomain->maxDFS_channelNum)
		&& ((os_timeStampMs(pRegulatoryDomain->hOs)-pSupportedChannels[channelIndex].timestamp) >=CHANNEL_VALIDITY_TS_THRESHOLD ))
	{	/* If 802.11h is enabled, a DFS channel is valid only for 10 sec
			from the last Beacon/ProbeResponse */
        pSupportedChannels[channelIndex].channelValidityActive = TI_FALSE;
        TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_isChannelSupprted(): CHANNEL_VALIDITY_TS_THRESHOLD !! Disable channel no %d, DFS channel\n", channel );

	}

	return (pSupportedChannels[channelIndex].channelValidityActive);

}

/************************************************************************
 *                        regulatoryDomain_setChannelValidity			*
 ************************************************************************/
/*
*
*
* \b Description: 
*
* This function sets a channel as invalid or valid in the internal Regulatory Domain
 * database. 
*
* \b ARGS:
*
*  I   - pData - pointer to the regDoamin SM context  \n
*  I   - channelNum - the invalid/valid channel number
*  I   - channelValidity - TI_TRUE if channel is valid, TI_FALSE channel is invalid
*
* \b RETURNS:
*
*  None.
*
* 
*************************************************************************/
static void regulatoryDomain_setChannelValidity(regulatoryDomain_t *pRegulatoryDomain, 
												TI_UINT16 channelNum, TI_BOOL channelValidity)
{
	channelCapability_t		*pSupportedChannels;
	TI_UINT8					channelIndex;


	if (pRegulatoryDomain == NULL)
	{
		return;
	}
	if ((channelNum==0 ) || (channelNum>A_5G_BAND_MAX_CHANNEL))
	{
TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR, "regulatoryDomain_setChannelValidity, invalid channelNum=%d \n", channelNum);
		return;
	}
	
	if (channelNum <= NUM_OF_CHANNELS_24)
	{
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_2_4;
		channelIndex = (channelNum-BG_24G_BAND_MIN_CHANNEL);
	}
	else 
	{
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_5;
		channelIndex = (channelNum - A_5G_BAND_MIN_CHANNEL);
	}
	
	if(channelValidity == TI_TRUE)
		if((pSupportedChannels[channelIndex].bChanneInCountryIe == TI_FALSE) && (pRegulatoryDomain->regulatoryDomainEnabled == TI_TRUE))
		{
TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_WARNING, "regulatoryDomain_setChannelValidity: channelNum = %d isn't supported at the Country. wll not set to active!\n", channelNum);
			return;
		}

    TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_setChannelValidity: channelNum=%d, validity=%d \n", channelNum, channelValidity);


	pSupportedChannels[channelIndex].channelValidityActive = channelValidity;
}


/************************************************************************
 *      setSupportedChannelsAccording2ScanControlTable 					*
 ************************************************************************/
/**
*
*
* \b Description: 
*
* This function is called in config and sets the supported channels according to
* the scan control table read from registry and reg domain read from the chip.
*
* \b ARGS:
*
*  I   - pRegulatoryDomain - pointer to the regDoamin SM context  \n
*
* \b RETURNS:
*
*  None.
*
* 
*************************************************************************/
static void setSupportedChannelsAccording2ScanControlTable(regulatoryDomain_t  *pRegulatoryDomain)
{
	TI_UINT8 	channelIndex;
	TI_UINT8	channelMask;

	if (pRegulatoryDomain==NULL)
	{
		return;
	}

    TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "setSupportedChannelsAccording2ScanControlTable \n");

	for (channelIndex=0; channelIndex<NUM_OF_CHANNELS_24; channelIndex++)
	{
		channelMask = pRegulatoryDomain->scanControlTable.ScanControlTable24.tableString[channelIndex];
		pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].bChanneInCountryIe = TI_FALSE;

		/* Calculate Domain Tx Power - channelMask units are in Dbm. */
		pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].uMaxTxPowerDomain = 
						DBM2DBMDIV10(channelMask & MASK_TX_POWER);
		if (channelMask & (MASK_ACTIVE_ALLOWED | MASK_FREQ_ALLOWED))
		{	/* The channel is allowed for Active & Passive scans */
			if (pRegulatoryDomain->regulatoryDomainEnabled)
			{	/* All channels should be invalid for Active scan */
				pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].channelValidityActive = TI_FALSE;
                TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "channelIndex=%d is invalid for Active \n", channelIndex+1);
			}
			else
			{
				pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].channelValidityActive = TI_TRUE;
                TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "channelIndex=%d is Active valid \n", channelIndex+1);
			}
			
		}
		
		if (channelMask & MASK_FREQ_ALLOWED)
		{	/* The channel is allowed for Passive scan */
			pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].channelValidityPassive = TI_TRUE;
            TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "channelIndex=%d is Passive valid \n", channelIndex+1);
		}
		else
		{	/* The channel is not allowed */
			pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].channelValidityPassive = TI_FALSE;
			pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].channelValidityActive = TI_FALSE;
		}
	}

	for (channelIndex=A_5G_BAND_MIN_CHANNEL; channelIndex<A_5G_BAND_MAX_CHANNEL; channelIndex++)
	{	
		TI_UINT8	channelIndexInBand5;

		channelIndexInBand5 = (channelIndex-A_5G_BAND_MIN_CHANNEL);
		channelMask = pRegulatoryDomain->scanControlTable.ScanControlTable5.tableString[channelIndexInBand5];
        TRACE3(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "channelIndex=%d, channelIndexInBand5=%d channelMask=%d\n", channelIndex, channelIndexInBand5, channelMask);

		/* Calculate Domain Tx Power - channelMask units are in Dbm. */
		pRegulatoryDomain->supportedChannels_band_5[channelIndexInBand5].uMaxTxPowerDomain = 
			DBM2DBMDIV10(channelMask & MASK_TX_POWER);

		pRegulatoryDomain->supportedChannels_band_5[channelIndexInBand5].bChanneInCountryIe = TI_FALSE;
		if (channelMask & (MASK_ACTIVE_ALLOWED | MASK_FREQ_ALLOWED))
		{	 /* The channel is allowed for Active & Passive scans */
			if (pRegulatoryDomain->regulatoryDomainEnabled)
			{	/* All channels should be invalid for Active scan */
				pRegulatoryDomain->supportedChannels_band_5[channelIndexInBand5].channelValidityActive = TI_FALSE;
                TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "channelIndex=%d is invalid for Active \n", channelIndex);
			}
			else
			{
				pRegulatoryDomain->supportedChannels_band_5[channelIndexInBand5].channelValidityActive = TI_TRUE;
                TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "channelIndex=%d, channelIndexInBand5=%d, is Active valid \n", channelIndex, channelIndexInBand5);
			}   		
		}
		
		if (channelMask & MASK_FREQ_ALLOWED)
		{	/* The channel is allowed for Passive scan */
			pRegulatoryDomain->supportedChannels_band_5[channelIndexInBand5].channelValidityPassive = TI_TRUE;
            TRACE2(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "channelIndex=%d, channelIndexInBand5=%d, is Passive valid \n", channelIndex, channelIndexInBand5);
		}
		else
		{	/* The channel is not allowed */
			pRegulatoryDomain->supportedChannels_band_5[channelIndexInBand5].channelValidityPassive = TI_FALSE;
			pRegulatoryDomain->supportedChannels_band_5[channelIndexInBand5].channelValidityActive = TI_FALSE;
		}

	}
}


/***********************************************************************
*                        regulatoryDomain_getChannelCapability									
***********************************************************************
DESCRIPTION:	This function returns the channel capability information

INPUT:      pRegulatoryDomain		-	RegulatoryDomain pointer.
			channelCapabilityReq	-	Channels parameters


OUTPUT:		channelCapabilityRet	-   Channel capability information

RETURN:     TI_OK if information was retrieved, TI_NOK otherwise.

************************************************************************/
static TI_STATUS regulatoryDomain_getChannelCapability(regulatoryDomain_t *pRegulatoryDomain, 
													   channelCapabilityReq_t channelCapabilityReq, 
													   channelCapabilityRet_t *channelCapabilityRet)
{
	channelCapability_t		*pSupportedChannels;
	TI_UINT8				channelIndex;
	TI_BOOL					bCountryWasFound, bServingChannel;

	if ((pRegulatoryDomain == NULL) || (channelCapabilityRet == NULL))
	{
		return TI_NOK;
	}

	channelCapabilityRet->channelValidity = TI_FALSE;
	channelCapabilityRet->maxTxPowerDbm = 0;
	if ((channelCapabilityReq.channelNum==0 ) || (channelCapabilityReq.channelNum > A_5G_BAND_MAX_CHANNEL))
	{
        TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR, "regulatoryDomain_getChannelCapability, invalid channelNum=%d \n", channelCapabilityReq.channelNum);
		return TI_NOK;
	}
	
	if (channelCapabilityReq.band==RADIO_BAND_2_4_GHZ)
	{
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_2_4;
		channelIndex = (channelCapabilityReq.channelNum-BG_24G_BAND_MIN_CHANNEL);
		if (channelIndex >= NUM_OF_CHANNELS_24)
		{
			TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR,
				   "regulatoryDomain_getChannelCapability(): 2.4G invalid channel # %u\n", channelCapabilityReq.channelNum );
			return TI_NOK;
		}
		bCountryWasFound = pRegulatoryDomain->country_2_4_WasFound;
	}
	else if (channelCapabilityReq.band==RADIO_BAND_5_0_GHZ)
	{
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_5;
		channelIndex = (channelCapabilityReq.channelNum - A_5G_BAND_MIN_CHANNEL);
		if (channelIndex >= A_5G_BAND_NUM_CHANNELS)
		{
			TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR,
				   "regulatoryDomain_getChannelCapability(): 5G invalid channel # %u\n", channelCapabilityReq.channelNum);
			return TI_NOK;
		}
		bCountryWasFound = pRegulatoryDomain->country_5_WasFound;
	}
	else
	{
		TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR, "regulatoryDomain_getChannelCapability, invalid band=%d \n", channelCapabilityReq.band);
		return TI_NOK;
	}


	/* 
	 * Set channelValidity according to ScanTable and whether 11d is enabled 
	 */
	if (channelCapabilityReq.scanOption == ACTIVE_SCANNING)
	{
		if ( ( pRegulatoryDomain->regulatoryDomainEnabled ) && ( !bCountryWasFound ) )
		{	/* 11d enabled and no country IE was found - set channel to invalid */
			channelCapabilityRet->channelValidity = TI_FALSE;
		}
		else
		{
            paramInfo_t *pParam = (paramInfo_t *)os_memoryAlloc(pRegulatoryDomain->hOs, sizeof(paramInfo_t));
            if (!pParam)
            {
                return TI_NOK;
            }

            channelCapabilityRet->channelValidity = pSupportedChannels[channelIndex].channelValidityActive;
			/*
			 * Set Maximum Tx power for the channel - only for active scanning
			 */ 

			/* Get current channel and check if we are using the same one */
			pParam->paramType = SITE_MGR_CURRENT_CHANNEL_PARAM;
			siteMgr_getParam(pRegulatoryDomain->hSiteMgr, pParam);

			bServingChannel = ( pParam->content.siteMgrCurrentChannel == channelCapabilityReq.channelNum ?
								TI_TRUE : TI_FALSE );

			channelCapabilityRet->maxTxPowerDbm = regulatoryDomain_getMaxPowerAllowed(pRegulatoryDomain, 
				channelCapabilityReq.channelNum, 
				channelCapabilityReq.band, 
				bServingChannel);
            os_memoryFree(pRegulatoryDomain->hOs, pParam, sizeof(paramInfo_t));
		}
	}
	else	/* Passive scanning */
	{
		if ( ( pRegulatoryDomain->regulatoryDomainEnabled ) && ( !bCountryWasFound ) )
		{	/* 11d enabled and no country IE was found - set channel to valid for passive scan */
			channelCapabilityRet->channelValidity = TI_TRUE;
		}
	else
	{
		channelCapabilityRet->channelValidity = pSupportedChannels[channelIndex].channelValidityPassive;
	}
	}
	
	if (pRegulatoryDomain->spectrumManagementEnabled 
		&& (channelCapabilityReq.scanOption == ACTIVE_SCANNING)
        && (channelCapabilityReq.channelNum >= pRegulatoryDomain->minDFS_channelNum) 
        && (channelCapabilityReq.channelNum <= pRegulatoryDomain->maxDFS_channelNum)
		&& ((os_timeStampMs(pRegulatoryDomain->hOs)-pSupportedChannels[channelIndex].timestamp) >=CHANNEL_VALIDITY_TS_THRESHOLD ))
	{	/* If 802.11h is enabled, a DFS channel is valid only for 10 sec
			from the last Beacon/ProbeResponse */
        pSupportedChannels[channelIndex].channelValidityActive = TI_FALSE;
        channelCapabilityRet->channelValidity = TI_FALSE;
        TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_getChannelCapability(): CHANNEL_VALIDITY_TS_THRESHOLD !!! Disable channel no %d, DFS channel\n", channelCapabilityReq.channelNum  );
    }

    TRACE4(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, " Channel num= %d, scan option=%d validity = %d, TX power = %d \n", 					channelCapabilityReq.channelNum, 					channelCapabilityReq.scanOption,					channelCapabilityRet->channelValidity,					channelCapabilityRet->maxTxPowerDbm);
	return TI_OK;

}


static void regulatoryDomain_updateChannelsTs(regulatoryDomain_t *pRegulatoryDomain, TI_UINT8 channel)
{
	TI_UINT8				channelIndex;
	channelCapability_t *pSupportedChannels;

	if (pRegulatoryDomain==NULL)
	{
		return;
	}

	if ((channel<BG_24G_BAND_MIN_CHANNEL) || (channel>A_5G_BAND_MAX_CHANNEL))
	{
		return;
	}

	if (channel>=A_5G_BAND_MIN_CHANNEL)
	{
		channelIndex = (channel-A_5G_BAND_MIN_CHANNEL);
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_5;
	}
	else
	{
		channelIndex = (channel-BG_24G_BAND_MIN_CHANNEL);
		if (channelIndex >= NUM_OF_CHANNELS_24)
		{
			TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_ERROR,
				   "regulatoryDomain_updateChannelsTs(): 2.4G invalid channel # %u\n", channel );
			return;
		}
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_2_4;
	}
	
	if((pSupportedChannels[channelIndex].bChanneInCountryIe == TI_FALSE) && (pRegulatoryDomain->regulatoryDomainEnabled == TI_TRUE))
  	{
		TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_WARNING, "regulatoryDomain_updateChannelsTs: channelNum = %d isn't supported at the Country. wll not set to active!\n", channel);
  		return;
  	}

	pSupportedChannels[channelIndex].timestamp = os_timeStampMs(pRegulatoryDomain->hOs);
	pSupportedChannels[channelIndex].channelValidityActive = TI_TRUE;

}

/***********************************************************************
 *              regulatoryDomain_updateCurrTxPower								
 ***********************************************************************
DESCRIPTION: Called when new Tx power should be calculated and configured.
			 Check if we are already joined to BSS/IBSS, calculate 
			 new Tx power and configure it to TWD.
				
INPUT:		pRegulatoryDomain	- regulatoryDomain pointer.
			
RETURN:     TI_OK - New value was configured to TWD, TI_NOK - Can't configure value
			TX_POWER_SET_SAME_VALUE - Same value was already configured.

************************************************************************/
static TI_STATUS regulatoryDomain_updateCurrTxPower(regulatoryDomain_t	*pRegulatoryDomain)
{
    paramInfo_t			*pParam;
	TI_STATUS			eStatus;
	TTwdParamInfo		*pTwdParam;
	TI_UINT8			uCurrChannel, uNewTxPower;

    pParam = (paramInfo_t *)os_memoryAlloc(pRegulatoryDomain->hOs, sizeof(paramInfo_t));
    if (!pParam)
    {
        return TI_NOK;
    }

    pTwdParam = (TTwdParamInfo *)os_memoryAlloc(pRegulatoryDomain->hOs, sizeof(TTwdParamInfo));
    if (!pTwdParam)
    {
        os_memoryFree(pRegulatoryDomain->hOs, pParam, sizeof(paramInfo_t));
        return TI_NOK;
    }

	/* Get the current channel, and update TWD with the changed */
	pParam->paramType = SITE_MGR_CURRENT_CHANNEL_PARAM;
	eStatus = siteMgr_getParam(pRegulatoryDomain->hSiteMgr, pParam);

	if ( eStatus != TI_OK )
	{
		/* We are not joined yet - no meaning for new Tx power */
        TRACE0(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_updateCurrTxPower, No site selected yet\n");
        os_memoryFree(pRegulatoryDomain->hOs, pParam, sizeof(paramInfo_t));
        os_memoryFree(pRegulatoryDomain->hOs, pTwdParam, sizeof(TTwdParamInfo));
		return TI_NOK;
	}
	/* Save current channel */
	uCurrChannel = pParam->content.siteMgrCurrentChannel;

	/* Get the current channel, and update TWD with the changed */
	pParam->paramType = 	SITE_MGR_RADIO_BAND_PARAM;
	siteMgr_getParam(pRegulatoryDomain->hSiteMgr, pParam);

	/* Calculate maximum Tx power for the serving channel */
	uNewTxPower = regulatoryDomain_getMaxPowerAllowed(pRegulatoryDomain, uCurrChannel, 
													  pParam->content.siteMgrRadioBand, TI_TRUE);
    os_memoryFree(pRegulatoryDomain->hOs, pParam, sizeof(paramInfo_t));	
	
	/* Verify that the Temporary TX Power Control doesn't violate the TX Power Constraint */
	pRegulatoryDomain->uTemporaryTxPower = TI_MIN(pRegulatoryDomain->uDesiredTemporaryTxPower, uNewTxPower);


    TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "regulatoryDomain_updateCurrTxPower, Write to TWD = %d \n", uNewTxPower);

    pTwdParam->paramType = TWD_TX_POWER_PARAM_ID;

    /* set TWD according to Temporary Tx Power Enable flag */
    if (TI_TRUE == pRegulatoryDomain->bTemporaryTxPowerEnable)
    {
        pTwdParam->content.halCtrlTxPowerDbm = pRegulatoryDomain->uTemporaryTxPower;
    }
    else
    {
        pTwdParam->content.halCtrlTxPowerDbm = uNewTxPower;
    }

    eStatus = TWD_SetParam(pRegulatoryDomain->hTWD, pTwdParam);
    os_memoryFree(pRegulatoryDomain->hOs, pTwdParam, sizeof(TTwdParamInfo));
	return eStatus;
}

/***********************************************************************
 *                        regulatoryDomain_checkCountryCodeExpiry									
 ***********************************************************************
DESCRIPTION: Check & Reset the country code that was detected earlier.
                Reseting country code will be done when the STA was not connected for 
                a certain amount of time, and no country code was received in that period (from the same country).
                This scenario might indicate that the STA has moved to a different country.
                                                                                                   
INPUT:      pRegulatoryDomain	-	Regulatory Domain handle.

OUTPUT:		updating country code if necessary.

RETURN:     

************************************************************************/
void regulatoryDomain_checkCountryCodeExpiry(regulatoryDomain_t *pRegulatoryDomain)
{
    paramInfo_t *pParam;
    TI_STATUS   connStatus;
    TI_UINT32   uCurrentTS = os_timeStampMs(pRegulatoryDomain->hOs);

    if ((pRegulatoryDomain->country_2_4_WasFound) || (pRegulatoryDomain->country_5_WasFound))
    {
        pParam = (paramInfo_t *)os_memoryAlloc(pRegulatoryDomain->hOs, sizeof(paramInfo_t));
        if (!pParam)
        {
            return;
        }
        /* Get connection status */
        pParam->paramType = SITE_MGR_CURRENT_SSID_PARAM;
        connStatus      = siteMgr_getParam(pRegulatoryDomain->hSiteMgr, pParam);

         /* If (uTimeOutToResetCountryMs has elapsed && we are not connected)
                 delete the last country code received */
        if (((uCurrentTS - pRegulatoryDomain->uLastCountryReceivedTS) > pRegulatoryDomain->uTimeOutToResetCountryMs) &&
            (connStatus == NO_SITE_SELECTED_YET))
        {
            TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, ", Reset country code after %d Ms\n",(uCurrentTS - pRegulatoryDomain->uLastCountryReceivedTS));

            /* Reset country codes */
            pRegulatoryDomain->country_2_4_WasFound = TI_FALSE;
            pRegulatoryDomain->country_5_WasFound = TI_FALSE;
            
            /* Restore default values of the scan control table */
            setSupportedChannelsAccording2ScanControlTable(pRegulatoryDomain); 
        }
        os_memoryFree(pRegulatoryDomain->hOs, pParam, sizeof(paramInfo_t));
    }
}

/***********************************************************************
*              regulatoryDomain_getMaxPowerAllowed								
***********************************************************************
DESCRIPTION: Get the maximum tx power allowed for the given channel.
				The final value is constructed by:
				1) User max value
				2) Domain restriction - 11d country code IE
				3) 11h power constraint - only on serving channel
				4) XCC TPC - only on serving channel

RETURN:     Max power in Dbm/10 for the given channel

************************************************************************/
static TI_UINT8 regulatoryDomain_getMaxPowerAllowed(regulatoryDomain_t	*pRegulatoryDomain,
												 TI_UINT8				uChannel,
												 ERadioBand		eBand,
												 TI_BOOL				bServingChannel)
{
	channelCapability_t	*pSupportedChannels;
	TI_UINT8				 uChannelIndex, uTxPower;

	if( eBand == RADIO_BAND_2_4_GHZ)
	{
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_2_4;
		uChannelIndex = uChannel - BG_24G_BAND_MIN_CHANNEL;
	}
	else
	{
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_5;
		uChannelIndex = uChannel - A_5G_BAND_MIN_CHANNEL;
	}

	/* We'll start with the "Domain restriction - 11d country code IE" */
	uTxPower = pSupportedChannels[uChannelIndex].uMaxTxPowerDomain;

	if ( bServingChannel)
	{
		if (pRegulatoryDomain->uPowerConstraint < uTxPower)
		{
			/* When 802.11h is disabled, uPowerConstraint is 0 anyway */
			uTxPower -= pRegulatoryDomain->uPowerConstraint;
		}
        
        /* Take XCC limitation too */
        uTxPower = TI_MIN(uTxPower, pRegulatoryDomain->uExternTxPowerPreferred);

	}

	/* Now make sure we are not exceeding the user maximum */
	uTxPower = TI_MIN(uTxPower, pRegulatoryDomain->uUserMaxTxPower);

TRACE3(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, " uChannel = %d bServingChannel = %d uTxPower = %d \n", uChannel, bServingChannel, uTxPower);

	return uTxPower;
}


static void regulatoryDomain_buildDefaultListOfChannelsPerBand(regulatoryDomain_t *pRegulatoryDomain, ERadioBand band, TI_UINT8 *listSize)
{
	TI_UINT8				channelIndex;
	TI_UINT8				numberOfChannels, minChannelNumber;
	channelCapability_t	*pSupportedChannels;
	TI_UINT8				maxSupportedChannels=0;

	if ( (pRegulatoryDomain==NULL) || (listSize==NULL))
	{
		return;
	}

	if( band == RADIO_BAND_2_4_GHZ)
	{
		minChannelNumber = BG_24G_BAND_MIN_CHANNEL;
		numberOfChannels = NUM_OF_CHANNELS_24;
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_2_4;
	}
	else
	{
		minChannelNumber = A_5G_BAND_MIN_CHANNEL;
		numberOfChannels = A_5G_BAND_NUM_CHANNELS;
		pSupportedChannels = pRegulatoryDomain->supportedChannels_band_5;
	}


	for (channelIndex=0; channelIndex<numberOfChannels; channelIndex++)
	{
		if (pSupportedChannels[channelIndex].channelValidityPassive)
		{
			pRegulatoryDomain->pDefaultChannels[maxSupportedChannels] = channelIndex+minChannelNumber;
TRACE1(pRegulatoryDomain->hReport, REPORT_SEVERITY_INFORMATION, "Channel num %d is supported \n", pRegulatoryDomain->pDefaultChannels[maxSupportedChannels]);
			maxSupportedChannels++;
		}
	}
 
	*listSize = maxSupportedChannels;
    
}

/***********************************************************************
*              regulatoryDomain_getPowerTableMinMax								
***********************************************************************
DESCRIPTION: Find the Tx-power-level table min & max values.
			 The table is made of 4 power levels and 5 bands/sub-bands. 

RETURN:     void
************************************************************************/
static void regulatoryDomain_getPowerTableMinMax (regulatoryDomain_t *pRegulatoryDomain,
                                                  powerCapability_t  *pPowerCapability)
{
    TFwInfo  *pFwInfo = TWD_GetFWInfo (pRegulatoryDomain->hTWD);
	TI_UINT8	i;

    /* Init the min (max) to the opposite edge so the table values are below (above) this edge */ 
	pPowerCapability->minTxPower = MAX_TX_POWER;
	pPowerCapability->maxTxPower = MIN_TX_POWER;

	/* Find Min and Max values of the table */
	for (i = 0; i < NUMBER_OF_SUB_BANDS_E; i++)
	{
		pPowerCapability->minTxPower = TI_MIN (pPowerCapability->minTxPower, 
                                               pFwInfo->txPowerTable[i][NUM_OF_POWER_LEVEL-1]);
		pPowerCapability->maxTxPower = TI_MAX (pPowerCapability->maxTxPower, 
                                               pFwInfo->txPowerTable[i][0]);
	}
}

/* for debug */
void regDomainPrintValidTables(TI_HANDLE hRegulatoryDomain)
{
	regulatoryDomain_t  *pRegulatoryDomain = (regulatoryDomain_t *)hRegulatoryDomain;
	TI_UINT16 channelIndex;

	for (channelIndex=0; channelIndex<NUM_OF_CHANNELS_24; channelIndex++)
	{
		if (pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].channelValidityPassive)
			WLAN_OS_REPORT(("channel num =%d is valid for passive \n", channelIndex+1));
		if (pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].channelValidityActive)
		{
			WLAN_OS_REPORT(("channel =%d is valid for active TX power=%d\n", 
				channelIndex+1, pRegulatoryDomain->supportedChannels_band_2_4[channelIndex].uMaxTxPowerDomain));
		}
	}

	for (channelIndex=0; channelIndex<A_5G_BAND_NUM_CHANNELS; channelIndex++)
	{
		TI_UINT8	channelNum;
		channelNum = channelIndex+A_5G_BAND_MIN_CHANNEL;
		if (pRegulatoryDomain->supportedChannels_band_5[channelIndex].channelValidityPassive)
			WLAN_OS_REPORT(("channel =%d is valid for passive \n", channelNum));
		if (pRegulatoryDomain->supportedChannels_band_5[channelIndex].channelValidityActive)
		{
			WLAN_OS_REPORT(("channel =%d is valid for active TX power=%d\n", 
				channelNum,pRegulatoryDomain->supportedChannels_band_5[channelIndex].uMaxTxPowerDomain));
		}
		}

	WLAN_OS_REPORT(("11h PowerConstraint = %d, XCC TPC = %d, User  = %d\n", 
		pRegulatoryDomain->uPowerConstraint, pRegulatoryDomain->uExternTxPowerPreferred,
		pRegulatoryDomain->uUserMaxTxPower));

}