/*

 * CmdBldCmd.c

 *

 * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.      

 * All rights reserved.      

 * 

 * This program and the accompanying materials are made available under the 

 * terms of the Eclipse Public License v1.0 or BSD License which accompanies

 * this distribution. The Eclipse Public License is available at

 * http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below.                                   

 *                                                                       

 * 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  CmdBldCmd.c 

 *  \brief Command builder. Commands

 *

 *  \see   CmdBld.h 

 */

#define __FILE_ID__  FILE_ID_93

#include "tidef.h"

#include "report.h"

#include "TWDriverInternal.h"

#include "CmdBld.h"

#include "CmdBldCmdIE.h"

#include "CmdBldCfgIE.h"

#include "CmdQueue_api.h"

#include "eventMbox_api.h"

/* 

    Rx filter field is mostly hard-coded.

   This filter value basically pass only valid beacons / probe responses. For exact bit description,

   consult either the DPG or the FPG (or both, and Yoel...)

*/

#define RX_FILTER_CFG_ (CFG_RX_PRSP_EN | CFG_RX_MGMT_EN | CFG_RX_BCN_EN | CFG_RX_RCTS_ACK | CFG_RX_CTL_EN)

TI_STATUS cmdBld_CmdAddWepKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb);

TI_STATUS cmdBld_CmdRemoveWepKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb);

TI_STATUS cmdBld_CmdAddWepMappingKey 	(TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb);

TI_STATUS cmdBld_CmdRemoveWepMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb);

TI_UINT32 cmdBld_BuildPeriodicScanChannles  (TPeriodicScanParams *pPeriodicScanParams, ConnScanChannelInfo_t *pChannelList, EScanType eScanType, ERadioBand eRadioBand, TI_UINT32 uPassiveScanDfsDwellTime);

/** 

 * \fn     cmdBld_CmdStartScan

 * \brief  Build a start scan command and send it to the FW

 * 

 * Build a start scan command and send it to the FW

 * 

 * \param  hCmdBld - handle to the command builder object

 * \param  pScanVals - scan parameters

 * \param  eScanTag - scan tag used for scan complete and result tracking

 * \param  fScanCommandResponseCB - command complete CB

 * \param  hCb - command complete CB

 * \return command status (OK / NOK)

 * \sa     cmdBld_CmdStopScan

 */ 

TI_STATUS cmdBld_CmdStartScan (TI_HANDLE hCmdBld, TScanParams *pScanVals, EScanResultTag eScanTag, 

                               TI_BOOL bHighPriority, void* ScanCommandResponseCB, TI_HANDLE hCb)

{

    TCmdBld   *pCmdBld = (TCmdBld *)hCmdBld;

    BasicScanChannelParameters_t* chanPtr;

    ScanParameters_t    tnetScanParams;

    TI_UINT8*              pBSSID;

    TI_INT32 i;

    /* Convert general scan data to tnet structure */

    tnetScanParams.basicScanParameters.tidTrigger = pScanVals->Tid;

    tnetScanParams.basicScanParameters.numOfProbRqst = pScanVals->probeReqNumber;

    tnetScanParams.basicScanParameters.ssidLength = pScanVals->desiredSsid.len;

    os_memoryCopy (pCmdBld->hOs, 

                   (void *)tnetScanParams.basicScanParameters.ssidStr, 

                   (void *)pScanVals->desiredSsid.str, 

                   tnetScanParams.basicScanParameters.ssidLength);

    /* 

        scan options field is composed of scan type and band selection. 

        First, use the lookup table to convert the scan type 

    */                  

    tnetScanParams.basicScanParameters.scanOptions = 0;

    switch ( pScanVals->scanType )

    {

    case SCAN_TYPE_NORMAL_ACTIVE : 

        tnetScanParams.basicScanParameters.scanOptions = SCAN_ACTIVE;

        break;

    case SCAN_TYPE_NORMAL_PASSIVE : 

        tnetScanParams.basicScanParameters.scanOptions = SCAN_PASSIVE;

        break;

    case SCAN_TYPE_TRIGGERED_ACTIVE :

        tnetScanParams.basicScanParameters.scanOptions = SCAN_ACTIVE | TRIGGERED_SCAN;

        break;

    case SCAN_TYPE_TRIGGERED_PASSIVE :

        tnetScanParams.basicScanParameters.scanOptions = SCAN_PASSIVE | TRIGGERED_SCAN;

        break;

    default:

        TRACE1( pCmdBld->hReport, REPORT_SEVERITY_ERROR, "Invalid scan type:%d\n", pScanVals->scanType);

        return TI_NOK;

    }

    /* Add the band selection */

    if ( RADIO_BAND_5_0_GHZ == pScanVals->band )

    {

        tnetScanParams.basicScanParameters.band = RADIO_BAND_5GHZ;

    }

    else

    {

        tnetScanParams.basicScanParameters.band = RADIO_BAND_2_4_GHZ;

    }

    /* Add high priority bit */

    if ( bHighPriority )

    {

        tnetScanParams.basicScanParameters.scanOptions |= SCAN_PRIORITY_HIGH;

    }

    tnetScanParams.basicScanParameters.scanOptions = ENDIAN_HANDLE_WORD( tnetScanParams.basicScanParameters.scanOptions );

    /* important note: BSSID filter (0x0010) is DISABLED, because the FW sets it according

       to BSSID value (broadcast does not filter, any other value will */

    tnetScanParams.basicScanParameters.rxCfg.ConfigOptions = 0x12802 ;

    tnetScanParams.basicScanParameters.rxCfg.FilterOptions = ENDIAN_HANDLE_LONG( RX_FILTER_CFG_ );

    /* If the SSID is not broadcast SSID, also filter according to SSID */

    if (pScanVals->desiredSsid.len != 0)

    {

        tnetScanParams.basicScanParameters.rxCfg.ConfigOptions |= BIT_4 | BIT_10;

    }

    tnetScanParams.basicScanParameters.rxCfg.ConfigOptions = ENDIAN_HANDLE_LONG( tnetScanParams.basicScanParameters.rxCfg.ConfigOptions );

    /* Rate conversion is done in the HAL */

    cmdBld_ConvertAppRatesBitmap (pScanVals->probeRequestRate, 

                                     0, 

                                     &tnetScanParams.basicScanParameters.txdRateSet);

    tnetScanParams.basicScanParameters.txdRateSet = ENDIAN_HANDLE_LONG( tnetScanParams.basicScanParameters.txdRateSet );

    tnetScanParams.basicScanParameters.numChannels = ENDIAN_HANDLE_WORD( pScanVals->numOfChannels );

    /* scan result tag */

    tnetScanParams.basicScanParameters.scanTag = eScanTag;

    /* copy channel specific scan data to HAL structure */

    for ( i = 0; i < pScanVals->numOfChannels; i++ )

    {

        TI_INT32 j;

        TI_UINT8*  macAddr;

        macAddr = (TI_UINT8*)&tnetScanParams.basicScanChannelParameters[ i ].bssIdL;

        /* copy the MAC address, upside down (CHIP structure) */

        for ( j = 0; j < MAC_ADDR_LEN; j++ )

        {

            macAddr[ j ] = pScanVals->channelEntry[ i ].normalChannelEntry.bssId[ MAC_ADDR_LEN - 1 - j ];

        }

        tnetScanParams.basicScanChannelParameters[ i ].scanMinDuration = 

            ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].normalChannelEntry.minChannelDwellTime );

        tnetScanParams.basicScanChannelParameters[ i ].scanMaxDuration = 

            ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].normalChannelEntry.maxChannelDwellTime );

        tnetScanParams.basicScanChannelParameters[ i ].ETCondCount = 

            pScanVals->channelEntry[ i ].normalChannelEntry.ETMaxNumOfAPframes |

            pScanVals->channelEntry[ i ].normalChannelEntry.earlyTerminationEvent;

        tnetScanParams.basicScanChannelParameters[ i ].txPowerAttenuation = 

            pScanVals->channelEntry[ i ].normalChannelEntry.txPowerDbm;

        tnetScanParams.basicScanChannelParameters[ i ].channel = 

            pScanVals->channelEntry[ i ].normalChannelEntry.channel;

    }

    TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "RxCfg = 0x%x\n                             RxFilterCfg = 0x%x\n                             scanOptions = 0x%x\n                             numChannels = %d\n                             probeNumber = %d\n                             probeRateModulation = 0x%x\n                             tidTrigger = %d\n" ,                               tnetScanParams.basicScanParameters.rxCfg.ConfigOptions,                               tnetScanParams.basicScanParameters.rxCfg.FilterOptions,                              tnetScanParams.basicScanParameters.scanOptions,                               tnetScanParams.basicScanParameters.numChannels,                               tnetScanParams.basicScanParameters.numOfProbRqst,                              tnetScanParams.basicScanParameters.txdRateSet,                               tnetScanParams.basicScanParameters.tidTrigger);

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Channel      BSSID           MinTime     MaxTime     ET     TxPower   probChan\n");

    for( i=0; i < pScanVals->numOfChannels; i++)

    {

        chanPtr = &tnetScanParams.basicScanChannelParameters[i];

        pBSSID = (TI_UINT8*)&chanPtr->bssIdL;

 		TRACE12(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "%06d   %02x:%02x:%02x:%02x:%02x:%02x    %05d %05d %02d %05d %05d\n",i, pBSSID[5],pBSSID[4],pBSSID[3],pBSSID[2],pBSSID[1],pBSSID[0], chanPtr->scanMinDuration, chanPtr->scanMaxDuration, chanPtr->ETCondCount, chanPtr->txPowerAttenuation, chanPtr->channel);

    }

    return cmdBld_CmdIeStartScan (hCmdBld, &tnetScanParams, ScanCommandResponseCB, hCb);

}

/** 

 * \fn     cmdBld_CmdStartSPSScan

 * \brief  Build a start SPS scan command and send it to the FW

 * 

 * Build a start SPS scan command and send it to the FW

 * 

 * \param  hCmdBld - handle to the command builder object

 * \param  pScanVals - scan parameters

 * \param  eScanTag - scan tag used for scan complete and result tracking

 * \param  fScanCommandResponseCB - command complete CB

 * \param  hCb - command complete CB

 * \return command status (OK / NOK)

 * \sa     cmdBld_CmdStopSPSScan

 */ 

TI_STATUS cmdBld_CmdStartSPSScan (TI_HANDLE hCmdBld, TScanParams *pScanVals, EScanResultTag eScanTag, 

                                  void* fScanCommandResponseCB, TI_HANDLE hCb)

{

    TCmdBld  *pCmdBld = (TCmdBld *)hCmdBld;

    ScheduledScanParameters_t   tnetSPSScanParams;

    TI_INT32 i;

    /* Convert general scan data to TNET structure */

    tnetSPSScanParams.scheduledGeneralParameters.scanOptions = SCAN_PASSIVE;

    /* Add the band selection */

    if ( RADIO_BAND_5_0_GHZ == pScanVals->band )

    {

        tnetSPSScanParams.scheduledGeneralParameters.band = RADIO_BAND_5GHZ;

    }

    else

    {

        tnetSPSScanParams.scheduledGeneralParameters.band = RADIO_BAND_2_4_GHZ;

    }

    tnetSPSScanParams.scheduledGeneralParameters.scanOptions = ENDIAN_HANDLE_WORD( tnetSPSScanParams.scheduledGeneralParameters.scanOptions );

    /* important note: BSSID filter (0x0010) is DISABLED, because the FW sets it according

       to BSSID value (broadcast does not filter, any other value will */

    /* If the SSID is not broadcast SSID, also filter according to SSID */

    tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions = 0x12812;

    tnetSPSScanParams.scheduledGeneralParameters.rxCfg.FilterOptions = ENDIAN_HANDLE_LONG( RX_FILTER_CFG_ );

    tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions = ENDIAN_HANDLE_LONG( tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions );

    /* latest TSF value - used to discover TSF error (AP recovery) */

    tnetSPSScanParams.scheduledGeneralParameters.scanCmdTime_h = ENDIAN_HANDLE_LONG( INT64_HIGHER(pScanVals->latestTSFValue) );

    tnetSPSScanParams.scheduledGeneralParameters.scanCmdTime_l = ENDIAN_HANDLE_LONG( INT64_LOWER(pScanVals->latestTSFValue) );

    /* add scan tag */

    tnetSPSScanParams.scheduledGeneralParameters.scanTag = eScanTag;

    tnetSPSScanParams.scheduledGeneralParameters.numChannels = pScanVals->numOfChannels;

    /* copy channel specific scan data to HAL structure */

    for ( i = 0; i < pScanVals->numOfChannels; i++ )

    {

        TI_INT32 j;

        TI_UINT8*  macAddr;

        macAddr = (TI_UINT8*)&tnetSPSScanParams.scheduledChannelParameters[ i ].bssIdL;

        /* copy the MAC address, upside down (CHIP structure) */

        for ( j = 0; j < MAC_ADDR_LEN; j++ )

        {

            macAddr[ j ] = pScanVals->channelEntry[ i ].normalChannelEntry.bssId[ MAC_ADDR_LEN - 1 - j ];

        }

        tnetSPSScanParams.scheduledChannelParameters[ i ].scanMaxDuration = 

            ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].SPSChannelEntry.scanDuration );

        tnetSPSScanParams.scheduledChannelParameters[ i ].scanStartTime = 

            ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].SPSChannelEntry.scanStartTime );

        tnetSPSScanParams.scheduledChannelParameters[ i ].ETCondCount =

            pScanVals->channelEntry[ i ].SPSChannelEntry.ETMaxNumOfAPframes | 

            pScanVals->channelEntry[ i ].SPSChannelEntry.earlyTerminationEvent;

        tnetSPSScanParams.scheduledChannelParameters[ i ].channel = 

            pScanVals->channelEntry[ i ].SPSChannelEntry.channel;

    }

    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "RxCfg = 0x%x\n                             RxFilterCfg = 0x%x\n                             scanOptions = 0x%x\n                             numChannels = %d\n", tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions, tnetSPSScanParams.scheduledGeneralParameters.rxCfg.FilterOptions, tnetSPSScanParams.scheduledGeneralParameters.scanOptions, tnetSPSScanParams.scheduledGeneralParameters.numChannels);

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Channel      BSSID           StartTime     Duration     ET     probChan\n");

#ifdef TI_DBG

    for( i=0; i < tnetSPSScanParams.scheduledGeneralParameters.numChannels; i++)

    {

        ScheduledChannelParameters_t* chanPtr = &tnetSPSScanParams.scheduledChannelParameters[ i ];

        TI_UINT8* pBSSID = (TI_UINT8*)&chanPtr->bssIdL;

        TRACE11(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "%6d   %02x:%02x:%02x:%02x:%02x:%02x    %5d %5d %2d %5d\n",i, pBSSID[5],pBSSID[4],pBSSID[3],pBSSID[2],pBSSID[1],pBSSID[0], chanPtr->scanStartTime, chanPtr->scanMaxDuration, chanPtr->ETCondCount, chanPtr->channel);

    }

#endif /* TI_DBG */

    return cmdBld_CmdIeStartSPSScan (hCmdBld, &tnetSPSScanParams, fScanCommandResponseCB, hCb);

}

/** 

 * \fn     cmdBld_CmdStopScan

 * \brief  Build a stop scan command and send it to FW

 * 

 * Build a stop scan command and send it to FW

 * 

 * \param  hCmdBld - handle to the command builder object

 * \param  eScanTag - scan tag, used for scan complete and result tracking

 * \return command status (OK / NOK)

 * \sa     cmdBld_CmdStartSPSScan

 */ 

TI_STATUS cmdBld_CmdStopScan (TI_HANDLE hCmdBld, EScanResultTag eScanTag, 

                              void *fScanCommandResponseCB, TI_HANDLE hCb)

{

    return cmdBld_CmdIeStopScan (hCmdBld, fScanCommandResponseCB, hCb);

}

/** 

 * \fn     cmdBld_CmdStopSPSScan

 * \brief  Build a stop SPS scan command and send it to FW

 * 

 * Build a stop SPS scan command and send it to FW

 * 

 * \param  hCmdBld - handle to the command builder object

 * \param  eScanTag - scan tag, used for scan complete and result tracking

 * \return command status (OK / NOK)

 * \sa     cmdBld_CmdStartScan

 */ TI_STATUS cmdBld_CmdStopSPSScan (TI_HANDLE hCmdBld, EScanResultTag eScanTag, 

                                 void* fScanCommandResponseCB, TI_HANDLE hCb)

{

    return cmdBld_CmdIeStopSPSScan (hCmdBld, fScanCommandResponseCB, hCb);

}

TI_STATUS cmdBld_CmdSetSplitScanTimeOut (TI_HANDLE hCmdBld, TI_UINT32 uTimeOut)

{

    DB_WLAN(hCmdBld).uSlicedScanTimeOut = uTimeOut;

	return cmdBld_CmdIeSetSplitScanTimeOut (hCmdBld, uTimeOut, NULL, NULL);

}

/** 

 * \fn     cmdBld_debugPrintPeriodicScanChannles 

 * \brief  Print periodic scan channel list for debug purposes

 * 

 * Print periodic scan channel list for debug purposes

 * 

 * \param  hCmdBld - handle to the command builder object

 * \param  pChannel - pointer to the channel list to print

 * \param  uChannelCount - number of channles to print

 * \return None

 * \sa     cmdBld_debugPrintPeriodicScanParams

 */ 

void cmdBld_debugPrintPeriodicScanChannles (TI_HANDLE hCmdBld, ConnScanChannelInfo_t* pChannel,

                                            TI_UINT32 uChannelCount)

{

    TCmdBld                 *pCmdBld = (TCmdBld *)hCmdBld;

    TI_UINT32               uIndex;

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Index  Channel  MinTime  MaxTime  DFStime  PowerLevel\n");

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

    for (uIndex = 0; uIndex <  uChannelCount; uIndex++)

    {

        TRACE6(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "%-10d %-10d %-10d %-10d %-10d %-11d\n", uIndex, pChannel[ uIndex ].channel, pChannel[ uIndex ].scanMinDuration, pChannel[ uIndex ].scanMaxDuration, pChannel[ uIndex ].passiveScanDuration, pChannel[ uIndex ].txPowerLevelDbm);

    }

}

/** 

 * \fn     cmdBld_debugPrintPeriodicScanParams 

 * \brief  Print periodic scan parameters for debug purposes

 * 

 * Print periodic scan parameters for debug purposes

 * 

 * \param  hCmdBld - handle to the command builder object

 * \param  pCommand - pointer to the periodic scan command to print

 * \return None

 * \sa     cmdBld_debugPrintPeriodicScanChannles

 */ 

void cmdBld_debugPrintPeriodicScanParams (TI_HANDLE hCmdBld, ConnScanParameters_t* pCommand)

{

    TCmdBld                 *pCmdBld = (TCmdBld *)hCmdBld;

    /* print periodic scan params command */

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Cycle intervals:\n");

    TRACE8(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "0:  %-6d %-6d %-6d %-6d %-6d %-6d %-6d %-6d\n", pCommand->cycleIntervals[ 0 ], pCommand->cycleIntervals[ 1 ], pCommand->cycleIntervals[ 2 ], pCommand->cycleIntervals[ 3 ], pCommand->cycleIntervals[ 4 ], pCommand->cycleIntervals[ 5 ], pCommand->cycleIntervals[ 6 ], pCommand->cycleIntervals[ 7 ]);

    TRACE8(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "8:  %-6d %-6d %-6d %-6d %-6d %-6d %-6d %-6d\n", pCommand->cycleIntervals[ 8 ], pCommand->cycleIntervals[ 9 ], pCommand->cycleIntervals[ 10 ], pCommand->cycleIntervals[ 11 ], pCommand->cycleIntervals[ 12 ], pCommand->cycleIntervals[ 13 ], pCommand->cycleIntervals[ 14 ], pCommand->cycleIntervals[ 15 ]);

    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "RSSI threshold: %d, SNR threshold: %d, number of cycles: %d, reporth threshold: %d\n", pCommand->rssiThreshold, pCommand->snrThreshold, pCommand->maxNumOfCycles, pCommand->reportThreshold);

    TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Terminate on report: %d, result tag: %d, BSS type: %d, number of probe requests: %d\n", pCommand->terminateOnReport, pCommand->resultsTag, pCommand->bssType, pCommand->numProbe);

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "SSID filter type: %d, SSID length: %d, SSID: \n", pCommand->ssidFilterType, pCommand->ssidLength);

    /* print channel info */

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "2.4 GHz Channels:\n");

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

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Number of passive channels: %d, number of active channels: %d\n", pCommand->numOfPassive[ 0 ], pCommand->numOfActive[ 0 ]);

    cmdBld_debugPrintPeriodicScanChannles (hCmdBld, &(pCommand->channelList[ 0 ]),

                                           pCommand->numOfPassive[ 0 ] + 

                                           pCommand->numOfActive[ 0 ]);

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "5.0 GHz Channels:\n");

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

    TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Number of passive channels: %d, number of DFS channels: %d, number of active channels: %d\n", pCommand->numOfPassive[ 1 ], pCommand->numOfDfs, pCommand->numOfActive[ 2 ]);

    cmdBld_debugPrintPeriodicScanChannles (hCmdBld, &(pCommand->channelList[ CONN_SCAN_MAX_CHANNELS_BG ]),

                                           pCommand->numOfPassive[ 1 ] + 

                                           pCommand->numOfActive[ 1 ] +

                                           pCommand->numOfDfs);

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "4.9 GHz channles:\n");

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

    TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Number of passive channels: %d, number of active channels: %d\n", pCommand->numOfPassive[ 2 ], pCommand->numOfActive[ 2 ]);

    cmdBld_debugPrintPeriodicScanChannles (hCmdBld, &(pCommand->channelList[ CONN_SCAN_MAX_CHANNELS_BG + CONN_SCAN_MAX_CHANNELS_A ]),

                                           pCommand->numOfPassive[ 2 ] + 

                                           pCommand->numOfActive[ 2 ]);

}

/** 

 * \fn     cmdBld_debugPrintPeriodicScanSsidList 

 * \brief  Print periodic scan SSID list for debug purposes

 * 

 * Print periodic scan SSID list for debug purposes

 * 

 * \param  hCmdBld - handle to the command builder object

 * \param  pCommand - pointer to the periodic scan SSID list command to print

 * \return None

 * \sa     cmdBld_debugPrintPeriodicScanParams

 */ 

void cmdBld_debugPrintPeriodicScanSsidList (TI_HANDLE hCmdBld, ConnScanSSIDList_t* pCommand)

{

    TCmdBld                 *pCmdBld = (TCmdBld *)hCmdBld;

    TI_UINT32               uIndex;

    /* print SSID list command */

    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "SSID list:\n");

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

    TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Num of entries: %d\n", pCommand->numOfSSIDEntries);

    for (uIndex = 0; uIndex < pCommand->numOfSSIDEntries; uIndex++)

    {

        TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "index: %d, SSID type: %d, SSID length:% d, SSID string:\n", uIndex, pCommand->SSIDList[ uIndex ].ssidType, pCommand->SSIDList[ uIndex ].ssidLength);

    }

}

/** 

 * \fn     cmdBld_BuildPeriodicScanChannlesn 

 * \brief  Copy channels info for periodic scan to FW structure for a specific band and scan type 

 * 

 * Copy channels info, from driver structure, to FW structure, for periodic scan, for a specific

 * band and scan type.

 * 

 * \param  pPeriodicScanParams - driver priodic scan parameters (source)

 * \param  pChannelList - FW scan channel list (destination)

 * \param  eScanType - scan type (passive or active)

 * \param  eRadioBand - band (G, A or J)

 * \param  uPassiveScanDfsDwellTime - Dwell time for passive scan on DFS channels (in milli-secs)

 * \return Number of channels found for this scan type and band

 * \sa     cmdBld_StartPeriodicScan 

 */ 

TI_UINT32 cmdBld_BuildPeriodicScanChannles (TPeriodicScanParams *pPeriodicScanParams, 

                                            ConnScanChannelInfo_t *pChannelList,

                                            EScanType eScanType, ERadioBand eRadioBand,

                                            TI_UINT32 uPassiveScanDfsDwellTime)

{

    TI_UINT32       uIndex, uNumChannels = 0;

    /* check all channels */

    for (uIndex = 0; uIndex < pPeriodicScanParams->uChannelNum; uIndex++)

    {

        /* if this channel is on the required band and uses the required scan type */

        if ((eRadioBand == pPeriodicScanParams->tChannels[ uIndex ].eBand) &&

            (eScanType == pPeriodicScanParams->tChannels[ uIndex ].eScanType))

        {

            /* update scan parameters */

            pChannelList[ uNumChannels ].channel = (TI_UINT8)pPeriodicScanParams->tChannels[ uIndex ].uChannel;

            pChannelList[ uNumChannels ].passiveScanDuration = ENDIAN_HANDLE_WORD ((TI_UINT16)uPassiveScanDfsDwellTime);

            pChannelList[ uNumChannels ].scanMaxDuration = 

                ENDIAN_HANDLE_WORD ((TI_UINT16)pPeriodicScanParams->tChannels[ uIndex ].uMaxDwellTimeMs);

            pChannelList[ uNumChannels ].scanMinDuration = 

                ENDIAN_HANDLE_WORD ((TI_UINT16)pPeriodicScanParams->tChannels[ uIndex ].uMinDwellTimeMs);

            pChannelList[ uNumChannels ].txPowerLevelDbm = (TI_UINT8)pPeriodicScanParams->tChannels[ uIndex ].uTxPowerLevelDbm;

            if (SCAN_TYPE_PACTSIVE == eScanType) /* DFS channel */

            {

                pChannelList[ uNumChannels ].passiveScanDuration = ENDIAN_HANDLE_WORD ((TI_UINT16)uPassiveScanDfsDwellTime);

                pChannelList[ uNumChannels ].channelFlags = 1; /* mark as DFS channel */

            }

            else

            {

                pChannelList[ uNumChannels ].channelFlags = 0; /* mark as not DFS channel */

            }

            /* advance mathcing channel counter */

            uNumChannels++;

        }

    }

    /* return channel count */

    return uNumChannels;

}

/** 

 * \fn     cmdBld_StartPeriodicScan 

 * \brief  Copy driver periodic scan parameters to FW structures and send all commands to FW

 * 

 * Copy driver periodic scan parameters to FW structures (SSID list, parameters including channels

 * and start command) and send all commands to FW.

 * 

 * \param  hCmdBld - handle to the command builder object

 * \param  pPeriodicScanParams - periodic scan driver parameters (source)

 * \param  eScanTag - scan tag, used for scan complete and result tracking

 * \param  uPassiveScanDfsDwellTimeUs - Passive dwell time for DFS channels

 * \param  fScanCommandResponseCB - scan command complete CB

 * \param  hCb - scan command response handle

 * \return TI_OK on success, other codes indicate failure

 * \sa     cmdBld_BuildPeriodicScanChannles, cmdBld_StopPeriodicScan

 */ 

TI_STATUS cmdBld_StartPeriodicScan (TI_HANDLE hCmdBld, TPeriodicScanParams *pPeriodicScanParams,

                                    EScanResultTag eScanTag, TI_UINT32 uPassiveScanDfsDwellTimeMs,

                                    void* fScanCommandResponseCB, TI_HANDLE hCb)

{

    TCmdBld                         *pCmdBld = (TCmdBld *)hCmdBld;

    ConnScanParameters_t            tFWPeriodicScanParams;

    ConnScanSSIDList_t              tFWSsidList;

    PeriodicScanTag                 tScanStart;

    TI_UINT32                       uIndex;

    TI_STATUS                       tStatus;