1 /*

     2  * CmdBldCmd.c

     3  *

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

     5  * All rights reserved.      

     6  * 

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

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

     9  * this distribution. The Eclipse Public License is available at

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

    11  *                                                                       

    12  * Redistribution and use in source and binary forms, with or without    

    13  * modification, are permitted provided that the following conditions    

    14  * are met:                                                              

    15  *                                                                       

    16  *  * Redistributions of source code must retain the above copyright     

    17  *    notice, this list of conditions and the following disclaimer.      

    18  *  * Redistributions in binary form must reproduce the above copyright  

    19  *    notice, this list of conditions and the following disclaimer in    

    20  *    the documentation and/or other materials provided with the         

    21  *    distribution.                                                      

    22  *  * Neither the name Texas Instruments nor the names of its            

    23  *    contributors may be used to endorse or promote products derived    

    24  *    from this software without specific prior written permission.      

    25  *                                                                       

    26  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   

    27  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     

    28  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 

    29  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT  

    30  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 

    31  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT      

    32  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 

    33  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 

    34  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT   

    35  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 

    36  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    37  */

    38 

    39 

    40 /** \file  CmdBldCmd.c 

    41  *  \brief Command builder. Commands

    42  *

    43  *  \see   CmdBld.h 

    44  */

    45 

    46 #define __FILE_ID__  FILE_ID_93

    47 #include "tidef.h"

    48 #include "report.h"

    49 #include "TWDriverInternal.h"

    50 #include "CmdBld.h"

    51 #include "CmdBldCmdIE.h"

    52 #include "CmdBldCfgIE.h"

    53 #include "CmdQueue_api.h"

    54 #include "eventMbox_api.h"

    55 

    56 

    57 /* 

    58     Rx filter field is mostly hard-coded.

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

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

    61 */

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

    63 

    64 

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

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

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

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

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

    70 

    71 

    72 /** 

    73  * \fn     cmdBld_CmdStartScan

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

    75  * 

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

    77  * 

    78  * \param  hCmdBld - handle to the command builder object

    79  * \param  pScanVals - scan parameters

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

    81  * \param  fScanCommandResponseCB - command complete CB

    82  * \param  hCb - command complete CB

    83  * \return command status (OK / NOK)

    84  * \sa     cmdBld_CmdStopScan

    85  */ 

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

    87                                TI_BOOL bHighPriority, void* ScanCommandResponseCB, TI_HANDLE hCb)

    88 {

    89     TCmdBld   *pCmdBld = (TCmdBld *)hCmdBld;

    90     BasicScanChannelParameters_t* chanPtr;

    91     ScanParameters_t    tnetScanParams;

    92     TI_UINT8*              pBSSID;

    93     TI_INT32 i;

    94 

    95     /* Convert general scan data to tnet structure */

    96     tnetScanParams.basicScanParameters.tidTrigger = pScanVals->Tid;

    97     tnetScanParams.basicScanParameters.numOfProbRqst = pScanVals->probeReqNumber;

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

    99     os_memoryCopy (pCmdBld->hOs, 

   100                    (void *)tnetScanParams.basicScanParameters.ssidStr, 

   101                    (void *)pScanVals->desiredSsid.str, 

   102                    tnetScanParams.basicScanParameters.ssidLength);

   103     

   104     /* 

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

   106         First, use the lookup table to convert the scan type 

   107     */                  

   108 

   109     tnetScanParams.basicScanParameters.scanOptions = 0;

   110 

   111     switch ( pScanVals->scanType )

   112     {

   113     case SCAN_TYPE_NORMAL_ACTIVE : 

   114         tnetScanParams.basicScanParameters.scanOptions = SCAN_ACTIVE;

   115         break;

   116     

   117     case SCAN_TYPE_NORMAL_PASSIVE : 

   118         tnetScanParams.basicScanParameters.scanOptions = SCAN_PASSIVE;

   119         break;

   120     

   121     case SCAN_TYPE_TRIGGERED_ACTIVE :

   122         tnetScanParams.basicScanParameters.scanOptions = SCAN_ACTIVE | TRIGGERED_SCAN;

   123         break;

   124     

   125     case SCAN_TYPE_TRIGGERED_PASSIVE :

   126         tnetScanParams.basicScanParameters.scanOptions = SCAN_PASSIVE | TRIGGERED_SCAN;

   127         break;

   128 

   129     default:

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

   131         return TI_NOK;

   132     }

   133 

   134     /* Add the band selection */

   135     if ( RADIO_BAND_5_0_GHZ == pScanVals->band )

   136     {

   137         tnetScanParams.basicScanParameters.band = RADIO_BAND_5GHZ;

   138     }

   139     else

   140     {

   141         tnetScanParams.basicScanParameters.band = RADIO_BAND_2_4_GHZ;

   142     }

   143 

   144     /* Add high priority bit */

   145     if ( bHighPriority )

   146     {

   147         tnetScanParams.basicScanParameters.scanOptions |= SCAN_PRIORITY_HIGH;

   148     }

   149 

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

   151 

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

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

   154     tnetScanParams.basicScanParameters.rxCfg.ConfigOptions = 0x12802 ;

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

   156 

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

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

   159     {

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

   161     }

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

   163 

   164     /* Rate conversion is done in the HAL */

   165     cmdBld_ConvertAppRatesBitmap (pScanVals->probeRequestRate, 

   166                                      0, 

   167                                      &tnetScanParams.basicScanParameters.txdRateSet);

   168 

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

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

   171 

   172     /* scan result tag */

   173     tnetScanParams.basicScanParameters.scanTag = eScanTag;

   174 

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

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

   177     {

   178         TI_INT32 j;

   179         TI_UINT8*  macAddr;

   180 

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

   182 

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

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

   185         {

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

   187         }

   188         tnetScanParams.basicScanChannelParameters[ i ].scanMinDuration = 

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

   190         tnetScanParams.basicScanChannelParameters[ i ].scanMaxDuration = 

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

   192         tnetScanParams.basicScanChannelParameters[ i ].ETCondCount = 

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

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

   195         tnetScanParams.basicScanChannelParameters[ i ].txPowerAttenuation = 

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

   197         tnetScanParams.basicScanChannelParameters[ i ].channel = 

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

   199     }

   200 

   201     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);

   202     

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

   204    

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

   206     {

   207         chanPtr = &tnetScanParams.basicScanChannelParameters[i];

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

   209 

   210  		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);

   211     }

   212 

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

   214 }

   215 

   216 /** 

   217  * \fn     cmdBld_CmdStartSPSScan

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

   219  * 

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

   221  * 

   222  * \param  hCmdBld - handle to the command builder object

   223  * \param  pScanVals - scan parameters

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

   225  * \param  fScanCommandResponseCB - command complete CB

   226  * \param  hCb - command complete CB

   227  * \return command status (OK / NOK)

   228  * \sa     cmdBld_CmdStopSPSScan

   229  */ 

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

   231                                   void* fScanCommandResponseCB, TI_HANDLE hCb)

   232 {

   233     TCmdBld  *pCmdBld = (TCmdBld *)hCmdBld;

   234     ScheduledScanParameters_t   tnetSPSScanParams;

   235     TI_INT32 i;

   236 

   237     /* Convert general scan data to TNET structure */

   238     tnetSPSScanParams.scheduledGeneralParameters.scanOptions = SCAN_PASSIVE;

   239     /* Add the band selection */

   240     if ( RADIO_BAND_5_0_GHZ == pScanVals->band )

   241     {

   242         tnetSPSScanParams.scheduledGeneralParameters.band = RADIO_BAND_5GHZ;

   243     }

   244     else

   245     {

   246         tnetSPSScanParams.scheduledGeneralParameters.band = RADIO_BAND_2_4_GHZ;

   247     }

   248 

   249 

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

   251 

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

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

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

   255     tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions = 0x12812;

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

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

   258 

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

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

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

   262 

   263     /* add scan tag */

   264     tnetSPSScanParams.scheduledGeneralParameters.scanTag = eScanTag;

   265 

   266     tnetSPSScanParams.scheduledGeneralParameters.numChannels = pScanVals->numOfChannels;

   267 

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

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

   270     {

   271         TI_INT32 j;

   272         TI_UINT8*  macAddr;

   273 

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

   275 

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

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

   278         {

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

   280         }

   281         tnetSPSScanParams.scheduledChannelParameters[ i ].scanMaxDuration = 

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

   283         tnetSPSScanParams.scheduledChannelParameters[ i ].scanStartTime = 

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

   285         tnetSPSScanParams.scheduledChannelParameters[ i ].ETCondCount =

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

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

   288         tnetSPSScanParams.scheduledChannelParameters[ i ].channel = 

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

   290     }

   291 

   292     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);

   293     

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

   295    

   296 #ifdef TI_DBG

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

   298     {

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

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

   301 

   302         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);

   303     }

   304 #endif /* TI_DBG */

   305 

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

   307 }

   308 

   309 /** 

   310  * \fn     cmdBld_CmdStopScan

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

   312  * 

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

   314  * 

   315  * \param  hCmdBld - handle to the command builder object

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

   317  * \return command status (OK / NOK)

   318  * \sa     cmdBld_CmdStartSPSScan

   319  */ 

   320 TI_STATUS cmdBld_CmdStopScan (TI_HANDLE hCmdBld, EScanResultTag eScanTag, 

   321                               void *fScanCommandResponseCB, TI_HANDLE hCb)

   322 {

   323     return cmdBld_CmdIeStopScan (hCmdBld, fScanCommandResponseCB, hCb);

   324 }

   325 

   326 

   327 /** 

   328  * \fn     cmdBld_CmdStopSPSScan

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

   330  * 

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

   332  * 

   333  * \param  hCmdBld - handle to the command builder object

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

   335  * \return command status (OK / NOK)

   336  * \sa     cmdBld_CmdStartScan

   337  */ TI_STATUS cmdBld_CmdStopSPSScan (TI_HANDLE hCmdBld, EScanResultTag eScanTag, 

   338                                  void* fScanCommandResponseCB, TI_HANDLE hCb)

   339 {

   340     return cmdBld_CmdIeStopSPSScan (hCmdBld, fScanCommandResponseCB, hCb);

   341 }

   342 

   343 TI_STATUS cmdBld_CmdSetSplitScanTimeOut (TI_HANDLE hCmdBld, TI_UINT32 uTimeOut)

   344 {

   345     DB_WLAN(hCmdBld).uSlicedScanTimeOut = uTimeOut;

   346 

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

   348 }

   349 

   350 /** 

   351  * \fn     cmdBld_debugPrintPeriodicScanChannles 

   352  * \brief  Print periodic scan channel list for debug purposes

   353  * 

   354  * Print periodic scan channel list for debug purposes

   355  * 

   356  * \param  hCmdBld - handle to the command builder object

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

   358  * \param  uChannelCount - number of channles to print

   359  * \return None

   360  * \sa     cmdBld_debugPrintPeriodicScanParams

   361  */ 

   362 void cmdBld_debugPrintPeriodicScanChannles (TI_HANDLE hCmdBld, ConnScanChannelInfo_t* pChannel,

   363                                             TI_UINT32 uChannelCount)

   364 {

   365     TCmdBld                 *pCmdBld = (TCmdBld *)hCmdBld;

   366     TI_UINT32               uIndex;

   367 

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

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

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

   371     {

   372         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);

   373     }

   374 }

   375 

   376 /** 

   377  * \fn     cmdBld_debugPrintPeriodicScanParams 

   378  * \brief  Print periodic scan parameters for debug purposes

   379  * 

   380  * Print periodic scan parameters for debug purposes

   381  * 

   382  * \param  hCmdBld - handle to the command builder object

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

   384  * \return None

   385  * \sa     cmdBld_debugPrintPeriodicScanChannles

   386  */ 

   387 void cmdBld_debugPrintPeriodicScanParams (TI_HANDLE hCmdBld, ConnScanParameters_t* pCommand)

   388 {

   389     TCmdBld                 *pCmdBld = (TCmdBld *)hCmdBld;

   390 

   391     /* print periodic scan params command */

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

   393     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 ]);

   394     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 ]);

   395     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);

   396     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);

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

   398     /* print channel info */

   399 

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

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

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

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

   404                                            pCommand->numOfPassive[ 0 ] + 

   405                                            pCommand->numOfActive[ 0 ]);

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

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

   408     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 ]);

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

   410                                            pCommand->numOfPassive[ 1 ] + 

   411                                            pCommand->numOfActive[ 1 ] +

   412                                            pCommand->numOfDfs);

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

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

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

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

   417                                            pCommand->numOfPassive[ 2 ] + 

   418                                            pCommand->numOfActive[ 2 ]);

   419 }

   420 

   421 /** 

   422  * \fn     cmdBld_debugPrintPeriodicScanSsidList 

   423  * \brief  Print periodic scan SSID list for debug purposes

   424  * 

   425  * Print periodic scan SSID list for debug purposes

   426  * 

   427  * \param  hCmdBld - handle to the command builder object

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

   429  * \return None

   430  * \sa     cmdBld_debugPrintPeriodicScanParams

   431  */ 

   432 void cmdBld_debugPrintPeriodicScanSsidList (TI_HANDLE hCmdBld, ConnScanSSIDList_t* pCommand)

   433 {

   434     TCmdBld                 *pCmdBld = (TCmdBld *)hCmdBld;

   435     TI_UINT32               uIndex;

   436 

   437     /* print SSID list command */

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

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

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

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

   442     {

   443         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);

   444     }

   445 

   446 }

   447 

   448 /** 

   449  * \fn     cmdBld_BuildPeriodicScanChannlesn 

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

   451  * 

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

   453  * band and scan type.

   454  * 

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

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

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

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

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

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

   461  * \sa     cmdBld_StartPeriodicScan 

   462  */ 

   463 TI_UINT32 cmdBld_BuildPeriodicScanChannles (TPeriodicScanParams *pPeriodicScanParams, 

   464                                             ConnScanChannelInfo_t *pChannelList,

   465                                             EScanType eScanType, ERadioBand eRadioBand,

   466                                             TI_UINT32 uPassiveScanDfsDwellTime)

   467 {

   468     TI_UINT32       uIndex, uNumChannels = 0;

   469 

   470     /* check all channels */

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

   472     {

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

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

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

   476         {

   477             /* update scan parameters */

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

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

   480             pChannelList[ uNumChannels ].scanMaxDuration = 

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

   482             pChannelList[ uNumChannels ].scanMinDuration = 

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

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

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

   486             {

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

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

   489             }

   490             else

   491             {

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

   493             }

   494 

   495             /* advance mathcing channel counter */

   496             uNumChannels++;

   497         }

   498     }

   499 

   500     /* return channel count */

   501     return uNumChannels;

   502 }

   503 

   504 /** 

   505  * \fn     cmdBld_StartPeriodicScan 

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

   507  * 

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

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

   510  * 

   511  * \param  hCmdBld - handle to the command builder object

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

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

   514  * \param  uPassiveScanDfsDwellTimeUs - Passive dwell time for DFS channels

   515  * \param  fScanCommandResponseCB - scan command complete CB

   516  * \param  hCb - scan command response handle

   517  * \return TI_OK on success, other codes indicate failure

   518  * \sa     cmdBld_BuildPeriodicScanChannles, cmdBld_StopPeriodicScan

   519  */ 

   520 TI_STATUS cmdBld_StartPeriodicScan (TI_HANDLE hCmdBld, TPeriodicScanParams *pPeriodicScanParams,

   521                                     EScanResultTag eScanTag, TI_UINT32 uPassiveScanDfsDwellTimeMs,

   522                                     void* fScanCommandResponseCB, TI_HANDLE hCb)

   523 {

   524     TCmdBld                         *pCmdBld = (TCmdBld *)hCmdBld;

   525     ConnScanParameters_t            tFWPeriodicScanParams;

   526     ConnScanSSIDList_t              tFWSsidList;

   527     PeriodicScanTag                 tScanStart;

   528     TI_UINT32                       uIndex;

   529     TI_STATUS                       tStatus;

   530 

   531     TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Building start periodic scan commands:\n");

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

   533     /* copy parameters to FW structure */

   534     tFWPeriodicScanParams.bssType = (ScanBssType_e)pPeriodicScanParams->eBssType;

   535     for (uIndex = 0; uIndex < PERIODIC_SCAN_MAX_INTERVAL_NUM; uIndex ++)

   536     {

   537         tFWPeriodicScanParams.cycleIntervals[ uIndex ] = 

   538             ENDIAN_HANDLE_LONG (pPeriodicScanParams->uCycleIntervalMsec[ uIndex ]);

   539     }

   540     tFWPeriodicScanParams.maxNumOfCycles = (TI_UINT8)pPeriodicScanParams->uCycleNum;

   541     tFWPeriodicScanParams.numProbe = (TI_UINT8)pPeriodicScanParams->uProbeRequestNum;

   542     tFWPeriodicScanParams.reportThreshold = (TI_UINT8)pPeriodicScanParams->uFrameCountReportThreshold;

   543     tFWPeriodicScanParams.rssiThreshold = (TI_UINT8)pPeriodicScanParams->iRssiThreshold;

   544     tFWPeriodicScanParams.snrThreshold = (TI_INT8)pPeriodicScanParams->iSnrThreshold;

   545     tFWPeriodicScanParams.terminateOnReport = (TI_UINT8)pPeriodicScanParams->bTerminateOnReport;

   546     tFWPeriodicScanParams.resultsTag = (TI_UINT8)eScanTag;

   547     switch (pPeriodicScanParams->uSsidNum)

   548     {

   549     case 0: /* No SSIDs defined - no need to filter according to SSID */

   550         tFWPeriodicScanParams.ssidFilterType = (ScanSsidFilterType_e)SCAN_SSID_FILTER_TYPE_ANY;

   551         tFWPeriodicScanParams.ssidLength = 0;

   552         break;

   553 

   554     case 1: /* Only one SSID defined - copy it to the scan command (no need to send SSID list as well) */

   555         tFWPeriodicScanParams.ssidFilterType = (ScanSsidFilterType_e)SCAN_SSID_FILTER_TYPE_SPECIFIC;

   556         tFWPeriodicScanParams.ssidLength = (TI_UINT8)pPeriodicScanParams->tDesiredSsid[ 0 ].tSsid.len;

   557         os_memoryCopy (pCmdBld->hOs, (void*)&(tFWPeriodicScanParams.ssid[ 0 ]), 

   558                        (void*)&(pPeriodicScanParams->tDesiredSsid[ 0 ].tSsid.str[ 0 ]),

   559                        pPeriodicScanParams->tDesiredSsid[ 0 ].tSsid.len);

   560         break;

   561 

   562     default: /* More than one SSID - copy SSIDs to SSID list command */

   563         tFWPeriodicScanParams.ssidFilterType = (ScanSsidFilterType_e)SCAN_SSID_FILTER_TYPE_LIST;

   564         tFWPeriodicScanParams.ssidLength = 0;

   565         tFWSsidList.numOfSSIDEntries = (TI_UINT8)pPeriodicScanParams->uSsidNum;

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

   567         {

   568             tFWSsidList.SSIDList[ uIndex ].ssidType = 

   569                 (TI_UINT8)pPeriodicScanParams->tDesiredSsid[ uIndex ].eVisability;

   570             tFWSsidList.SSIDList[ uIndex ].ssidLength = 

   571                 (TI_UINT8)pPeriodicScanParams->tDesiredSsid[ uIndex ].tSsid.len;

   572             os_memoryCopy (pCmdBld->hOs, (void*)&(tFWSsidList.SSIDList[ uIndex ].ssid[ 0 ]),

   573                            (void*)&(pPeriodicScanParams->tDesiredSsid[ uIndex ].tSsid.str[ 0 ]),

   574                            tFWSsidList.SSIDList[ uIndex ].ssidLength);

   575         }

   576 

   577         /* print the SSID list parameters */

   578         cmdBld_debugPrintPeriodicScanSsidList (hCmdBld, &tFWSsidList);

   579 

   580         /* send the SSID list command */

   581         tStatus = cmdBld_CmdIeScanSsidList (hCmdBld, &tFWSsidList, NULL, NULL);

   582         if (TI_OK != tStatus)

   583         {

   584             TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR , "cmdBld_StartPeriodicScan: status %d when configuring SSID list", tStatus);

   585             return tStatus;

   586         }

   587         break;

   588     }

   589 

   590     /* copy channels */

   591     tFWPeriodicScanParams.numOfPassive[ 0 ] =  /* build passive B/G channels */

   592         cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ 0 ]),

   593                                           SCAN_TYPE_NORMAL_PASSIVE, RADIO_BAND_2_4_GHZ, uPassiveScanDfsDwellTimeMs);

   594     tFWPeriodicScanParams.numOfActive[ 0 ] = /* build active B/G channels */

   595         cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ tFWPeriodicScanParams.numOfPassive[ 0 ] ]),

   596                                           SCAN_TYPE_NORMAL_ACTIVE, RADIO_BAND_2_4_GHZ, uPassiveScanDfsDwellTimeMs);

   597     tFWPeriodicScanParams.numOfPassive[ 1 ] = /* build passive A channels */

   598         cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ CONN_SCAN_MAX_CHANNELS_BG ]),

   599                                           SCAN_TYPE_NORMAL_PASSIVE, RADIO_BAND_5_0_GHZ, uPassiveScanDfsDwellTimeMs);

   600     tFWPeriodicScanParams.numOfDfs = /* build DFS A channels */

   601         cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ CONN_SCAN_MAX_CHANNELS_BG + tFWPeriodicScanParams.numOfPassive[ 1 ] ]),

   602                                           SCAN_TYPE_PACTSIVE, RADIO_BAND_5_0_GHZ, uPassiveScanDfsDwellTimeMs);

   603     tFWPeriodicScanParams.numOfActive[ 1 ] = /* build active A channels */

   604         cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ CONN_SCAN_MAX_CHANNELS_BG + tFWPeriodicScanParams.numOfPassive[ 1 ] + tFWPeriodicScanParams.numOfDfs ]),

   605                                           SCAN_TYPE_NORMAL_ACTIVE, RADIO_BAND_5_0_GHZ, uPassiveScanDfsDwellTimeMs);

   606 

   607     /* until J is supported, mark zero channels for J passive and active */

   608     tFWPeriodicScanParams.numOfPassive[ 2 ] = 0;

   609     tFWPeriodicScanParams.numOfActive[ 2 ] = 0;

   610 

   611     /* print the command */

   612     cmdBld_debugPrintPeriodicScanParams (hCmdBld, &tFWPeriodicScanParams);

   613 

   614     /* Send the periodic scan parameters command */

   615     tStatus = cmdBld_CmdIePeriodicScanParams (hCmdBld, &tFWPeriodicScanParams, NULL, NULL);

   616     if (TI_OK != tStatus)

   617     {

   618         TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR , "cmdBld_StartPeriodicScan: status %d when configuring periodic scan parameters", tStatus);

   619         return tStatus;

   620     }

   621 

   622     /* send the periodic scan start command */

   623     tScanStart.scanTag = eScanTag;

   624     return cmdBld_CmdIeStartPeriodicScan (hCmdBld, &tScanStart, fScanCommandResponseCB, hCb);

   625 }

   626 

   627 /** 

   628  * \fn     cmdBld_StopPeriodicScan 

   629  * \brief  Stops an on-going periodic scan operation

   630  * 

   631  * Stops an on-going periodic scan operation 

   632  * 

   633  * \param  hCmdBld - handle to the command builder object

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

   635  * \param  fScanCommandResponseCB - scan command complete CB

   636  * \param  hCb - scan command response handle

   637  * \return TI_OK on success, other codes indicate failure

   638  * \sa     cmdBld_BuildPeriodicScanChannles, cmdBld_StartPeriodicScan

   639  */ 

   640 TI_STATUS cmdBld_StopPeriodicScan (TI_HANDLE hCmdBld, EScanResultTag eScanTag, 

   641                                    void* fScanCommandResponseCB, TI_HANDLE hCb)

   642 {

   643     PeriodicScanTag tScanStop;

   644 

   645     /* send the periodic scan stop command */

   646     tScanStop.scanTag = eScanTag;

   647     return cmdBld_CmdIeStopPeriodicScan (hCmdBld, &tScanStop, fScanCommandResponseCB, hCb);

   648 }

   649 

   650 /****************************************************************************

   651  *                      cmdBld_SetBssType()

   652  ****************************************************************************

   653  * DESCRIPTION: Set Bss type, set RxFilter 

   654  * 

   655  * INPUTS: None 

   656  * 

   657  * OUTPUT:  None

   658  * 

   659  * RETURNS: TI_OK or TI_NOK

   660  ****************************************************************************/

   661 static TI_STATUS cmdBld_CmdSetBssType (TI_HANDLE hCmdBld, ScanBssType_e BssType, TI_UINT8 *HwBssType)

   662 {

   663     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

   664 

   665     switch (BssType)

   666     {

   667     case BSS_INFRASTRUCTURE:

   668         DB_BSS(hCmdBld).BssType = BSS_TYPE_STA_BSS;

   669         cmdBld_SetRxFilter (hCmdBld, RX_CONFIG_OPTION_FOR_JOIN, RX_FILTER_OPTION_JOIN);

   670         break;

   671 

   672     case BSS_INDEPENDENT:

   673         DB_BSS(hCmdBld).BssType = BSS_TYPE_IBSS;

   674         cmdBld_SetRxFilter (hCmdBld, RX_CONFIG_OPTION_FOR_IBSS_JOIN, RX_FILTER_OPTION_DEF);

   675         break;

   676 

   677     default: 

   678         TRACE1(pCmdBld->hReport, REPORT_SEVERITY_FATAL_ERROR, "cmdBld_SetBssType: FATAL_ERROR, unknown BssType %d\n", BssType);

   679         return TI_NOK;

   680     }

   681 

   682     *HwBssType = DB_BSS(hCmdBld).BssType;

   683 

   684     return TI_OK;

   685 }

   686 

   687 

   688 /****************************************************************************

   689  *                      cmdBld_StartJoin()

   690  ****************************************************************************

   691  * DESCRIPTION: Enable Rx/Tx and send Start/Join command 

   692  * 

   693  * INPUTS: None 

   694  * 

   695  * OUTPUT:  None

   696  * 

   697  * RETURNS: TI_OK or TI_NOK

   698  ****************************************************************************/

   699 TI_STATUS cmdBld_CmdStartJoin (TI_HANDLE hCmdBld, ScanBssType_e BssType, void *fJoinCompleteCB, TI_HANDLE hCb)

   700 {

   701     TI_UINT8  HwBssType = 0;

   702 #ifdef TI_DBG  

   703     TCmdBld  *pCmdBld = (TCmdBld *)hCmdBld;

   704     TI_UINT8 *pBssId = DB_BSS(hCmdBld).BssId;

   705 

   706     TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INIT, "cmdBld_StartJoin: Enable Tx, Rx and Start the Bss, type=%d\n", BssType);

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

   708     TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INIT, "START/JOIN, SSID=, BSSID=%02X-%02X-%02X-%02X-%02X-%02X, Chan=%d\n", pBssId[0], pBssId[1], pBssId[2], pBssId[3], pBssId[4], pBssId[5], DB_BSS(hCmdBld).RadioChannel);

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

   710 #endif /* TI_DBG */

   711 

   712     /* 

   713      * set RxFilter (but don't write it to the FW, this is done in the join command),

   714      * Configure templates content, ...

   715      */

   716     cmdBld_CmdSetBssType (hCmdBld, BssType, &HwBssType);

   717 

   718     return cmdBld_CmdIeStartBss (hCmdBld, HwBssType, fJoinCompleteCB, hCb);

   719 }

   720 

   721 

   722 TI_STATUS cmdBld_CmdJoinBss (TI_HANDLE hCmdBld, TJoinBss *pJoinBssParams, void *fCb, TI_HANDLE hCb)

   723 {

   724     TCmdBld        *pCmdBld = (TCmdBld *)hCmdBld;

   725     TWlanParams    *pWlanParams = &DB_WLAN(hCmdBld);

   726     TBssInfoParams *pBssInfoParams = &DB_BSS(hCmdBld);

   727 #ifdef TI_DBG

   728     TI_UINT8 dbgSsidStr[33];

   729 #endif /* TI_DBG */

   730 

   731     /* for debug purpose, can be removed later*/

   732     if (pJoinBssParams->ssidLength > 32)

   733         pJoinBssParams->ssidLength = 32;

   734 

   735     /* Update Tx-Session-Counter in the Ctrl field of the Join command. */

   736     pBssInfoParams->Ctrl &= ~JOIN_CMD_CTRL_TX_SESSION;

   737     pBssInfoParams->Ctrl |= (TI_UINT8)(pJoinBssParams->txSessionCount << JOIN_CMD_CTRL_OFFSET_TX_SESSION);

   738 

   739 #ifdef TI_DBG

   740     os_memoryCopy (pCmdBld->hOs, (void *)dbgSsidStr, (void *)pJoinBssParams->pSSID, pJoinBssParams->ssidLength);

   741     dbgSsidStr[pJoinBssParams->ssidLength] = '\0';

   742 

   743     TRACE14(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "TWD_JoinBss : bssType = %d, beaconInterval = %d, dtimInterval = %d, channel = %d, BSSID = %x-%x-%x-%x-%x-%x, ssidLength = %d, basicRateSet = 0x%x, RadioBand = %d, Ctrl = 0x%x", pJoinBssParams->bssType, pJoinBssParams->beaconInterval, pJoinBssParams->dtimInterval, pJoinBssParams->channel, pJoinBssParams->pBSSID[0], pJoinBssParams->pBSSID[1], pJoinBssParams->pBSSID[2], pJoinBssParams->pBSSID[3], pJoinBssParams->pBSSID[4], pJoinBssParams->pBSSID[5], pJoinBssParams->ssidLength, pJoinBssParams->basicRateSet, pJoinBssParams->radioBand, pBssInfoParams->Ctrl);

   744 #endif /* TI_DBG */

   745     /*

   746      * save Bss info parameters

   747      */

   748     DB_BSS(hCmdBld).ReqBssType = pJoinBssParams->bssType;

   749     MAC_COPY (DB_BSS(hCmdBld).BssId, pJoinBssParams->pBSSID);

   750     pBssInfoParams->tSsid.len = pJoinBssParams->ssidLength;

   751     os_memoryZero (pCmdBld->hOs, (void *)pBssInfoParams->tSsid.str, sizeof (pBssInfoParams->tSsid.str));

   752     os_memoryCopy (pCmdBld->hOs, (void *)pBssInfoParams->tSsid.str, (void *)pJoinBssParams->pSSID, pJoinBssParams->ssidLength);

   753     DB_BSS(hCmdBld).BeaconInterval = pJoinBssParams->beaconInterval;

   754     DB_BSS(hCmdBld).DtimInterval = (TI_UINT8)pJoinBssParams->dtimInterval;

   755     DB_BSS(hCmdBld).RadioChannel = pJoinBssParams->channel;

   756     DB_WLAN(hCmdBld).RadioBand = (TI_UINT8)pJoinBssParams->radioBand;

   757     DB_BSS(hCmdBld).BasicRateSet = pJoinBssParams->basicRateSet;

   758 

   759     /* In case we're joining a new BSS, reset the TKIP/AES sequence counter. */

   760     /* The firmware resets its own counter - so we won't have mismatch in the following TX complete events */

   761     pCmdBld->uSecuritySeqNumLow = 0;

   762     pCmdBld->uSecuritySeqNumHigh = 0;

   763 

   764     /* clear HT commands flags */

   765     DB_BSS(hCmdBld).bHtCap = TI_FALSE;

   766     DB_BSS(hCmdBld).bHtInf = TI_FALSE;

   767 

   768     pWlanParams->bJoin = TI_TRUE;

   769     pWlanParams->bStaConnected = TI_FALSE;

   770     /*

   771      * call the hardware to start/join the bss

   772      */

   773     return cmdBld_CmdStartJoin (hCmdBld, pJoinBssParams->bssType, fCb, hCb);

   774 }

   775 

   776 

   777 TI_STATUS cmdBld_CmdTemplate (TI_HANDLE hCmdBld, TSetTemplate *pTemplateParams, void *fCb, TI_HANDLE hCb)

   778 {

   779     TCmdBld   *pCmdBld = (TCmdBld *)hCmdBld;

   780     TI_STATUS  Stt;

   781     TTemplateParams *pTemplate;

   782     TI_UINT8   uIndex = 0;

   783     TemplateType_e eType;

   784 

   785     TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "cmdBld_CmdTemplate: Type=%d, size=%d, index=%d, RateMask=0x%x\n", pTemplateParams->type, pTemplateParams->len, pTemplateParams->index, pTemplateParams->uRateMask);

   786 

   787     switch (pTemplateParams->type)

   788     {

   789         case BEACON_TEMPLATE:

   790         eType = TEMPLATE_BEACON;

   791         pTemplate = &(DB_TEMP(hCmdBld).Beacon);

   792             break;

   793 

   794         case PROBE_RESPONSE_TEMPLATE:

   795         eType = TEMPLATE_PROBE_RESPONSE;

   796         pTemplate = &(DB_TEMP(hCmdBld).ProbeResp);

   797             break;

   798 

   799         case PROBE_REQUEST_TEMPLATE:

   800             if (pTemplateParams->eBand == RADIO_BAND_2_4_GHZ)

   801             {

   802             eType = CFG_TEMPLATE_PROBE_REQ_2_4;

   803             pTemplate = &(DB_TEMP(hCmdBld).ProbeReq24);

   804             }

   805             else

   806             {

   807             eType = CFG_TEMPLATE_PROBE_REQ_5;

   808             pTemplate = &(DB_TEMP(hCmdBld).ProbeReq50);

   809             }

   810             break;

   811 

   812         case NULL_DATA_TEMPLATE:

   813         eType = TEMPLATE_NULL_DATA;

   814         pTemplate = &(DB_TEMP(hCmdBld).NullData);

   815             break;

   816 

   817         case PS_POLL_TEMPLATE:

   818         eType = TEMPLATE_PS_POLL;

   819         pTemplate = &(DB_TEMP(hCmdBld).PsPoll);

   820             break;

   821 

   822         case QOS_NULL_DATA_TEMPLATE:

   823         eType = TEMPLATE_QOS_NULL_DATA;

   824         pTemplate = &(DB_TEMP(hCmdBld).QosNullData);

   825             break;

   826 

   827         case KEEP_ALIVE_TEMPLATE:

   828         eType = TEMPLATE_KLV;

   829         uIndex = pTemplateParams->index;

   830         pTemplate = &(DB_TEMP(hCmdBld).KeepAlive[uIndex]);

   831             break;

   832 

   833         case DISCONN_TEMPLATE:

   834         eType = TEMPLATE_DISCONNECT;

   835         pTemplate = &(DB_TEMP(hCmdBld).Disconn);

   836         break;

   837 

   838     default:

   839         return TI_NOK;

   840     }

   841 

   842     /* Save template information to DB (for recovery) */

   843     pTemplate->Size = pTemplateParams->len;

   844     pTemplate->uRateMask = pTemplateParams->uRateMask;

   845             os_memoryCopy (pCmdBld->hOs, 

   846                    (void *)(pTemplate->Buffer), 

   847                    (void *)(pTemplateParams->ptr), 

   848                            pTemplateParams->len);

   849 

   850     /* Configure template to FW */

   851             Stt = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld, 

   852                                               pTemplate, 

   853                                                       (TI_UINT16)pTemplateParams->len,

   854                                               eType,

   855                                               uIndex, /* index is only relevant for keep-alive template */

   856                                                       fCb,

   857                                                       hCb);

   858 

   859     return Stt;

   860 }

   861 

   862 

   863 /****************************************************************************

   864  *                      cmdBld_switchChannel()

   865  ****************************************************************************

   866  * DESCRIPTION: Switching the serving channel 

   867  * 

   868  * INPUTS: channel  -   new channel number  

   869  * 

   870  * OUTPUT:  None

   871  * 

   872  * RETURNS: TI_OK or TI_NOK

   873  ****************************************************************************/

   874 TI_STATUS cmdBld_CmdEnableTx (TI_HANDLE hCmdBld, TI_UINT8 channel, void *fCb, TI_HANDLE hCb)

   875 {

   876     return cmdBld_CmdIeEnableTx (hCmdBld, channel, fCb, hCb);

   877 }

   878 

   879 

   880 /****************************************************************************

   881  *                      cmdBld_DisableTx()

   882  ****************************************************************************

   883  * DESCRIPTION: Disable Tx path. 

   884  * 

   885  * INPUTS: None

   886  * 

   887  * OUTPUT:  None

   888  * 

   889  * RETURNS: TI_OK or TI_NOK

   890  ****************************************************************************/

   891 TI_STATUS cmdBld_CmdDisableTx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)

   892 {

   893     return cmdBld_CmdIeDisableTx (hCmdBld, fCb, hCb);

   894 }

   895 

   896 

   897 

   898 /****************************************************************************

   899  *                      cmdBld_SwitchChannelCmd()

   900  ****************************************************************************

   901  * DESCRIPTION: Send Switch Channel command 

   902  * 

   903  * INPUTS: None  

   904  * 

   905  * OUTPUT:  None

   906  * 

   907  * RETURNS: TI_OK or TI_NOK

   908  ****************************************************************************/

   909 TI_STATUS cmdBld_CmdSwitchChannel (TI_HANDLE hCmdBld, TSwitchChannelParams *pSwitchChannelCmd, void *fCb, TI_HANDLE hCb)

   910 {

   911     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

   912 

   913     TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "\n SwitchChannelCmd :\n                             channelNumber = %d\n                             switchTime = %d\n                             txFlag = %d\n                             flush = %d \n ", pSwitchChannelCmd->channelNumber, pSwitchChannelCmd->switchTime, pSwitchChannelCmd->txFlag, pSwitchChannelCmd->flush);

   914 

   915     DB_BSS(hCmdBld).RadioChannel = pSwitchChannelCmd->channelNumber;

   916 

   917     return cmdBld_CmdIeSwitchChannel (hCmdBld, pSwitchChannelCmd, fCb, hCb);

   918 }

   919 

   920 

   921 /****************************************************************************

   922  *                      cmdBld_SwitchChannelCmd()

   923  ****************************************************************************

   924  * DESCRIPTION: Send Switch Channel command 

   925  * 

   926  * INPUTS: None  

   927  * 

   928  * OUTPUT:  None

   929  * 

   930  * RETURNS: TI_OK or TI_NOK

   931  ****************************************************************************/

   932 TI_STATUS cmdBld_CmdSwitchChannelCancel (TI_HANDLE hCmdBld, TI_UINT8 channel, void *fCb, TI_HANDLE hCb)

   933 {

   934     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

   935 

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

   937 

   938     DB_BSS(hCmdBld).RadioChannel = channel;

   939 

   940     return cmdBld_CmdIeSwitchChannelCancel (hCmdBld, fCb, hCb);

   941 }

   942 

   943 

   944 /****************************************************************************

   945  *                      cmdBld_FwDisconnect()

   946  ****************************************************************************

   947  * DESCRIPTION: Disconnect. 

   948  * 

   949  * INPUTS: None

   950  * 

   951  * OUTPUT:  None

   952  * 

   953  * RETURNS: TI_OK or TI_NOK

   954  ****************************************************************************/

   955 TI_STATUS cmdBld_CmdFwDisconnect (TI_HANDLE hCmdBld, TI_UINT32 uConfigOptions, TI_UINT32 uFilterOptions, DisconnectType_e uDisconType, TI_UINT16 uDisconReason, void *fCb, TI_HANDLE hCb)

   956 {

   957     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

   958     TWlanParams *pWlanParams = &DB_WLAN(hCmdBld);

   959 

   960     pWlanParams->bJoin = TI_FALSE;

   961     pWlanParams->bStaConnected = TI_FALSE;

   962 

   963     TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Sending FW disconnect, ConfigOptions=%x, FilterOPtions=%x, uDisconType=%d, uDisconReason=%d\n",uConfigOptions, uFilterOptions, uDisconType, uDisconReason);

   964 

   965 

   966     return cmdBld_CmdIeFwDisconnect (hCmdBld, uConfigOptions, uFilterOptions, uDisconType, uDisconReason, fCb, hCb);

   967 }

   968 

   969 

   970 TI_STATUS cmdBld_CmdMeasurement (TI_HANDLE          hCmdBld, 

   971                                  TMeasurementParams *pMeasurementParams,

   972                                  void               *fCommandResponseCB, 

   973                                  TI_HANDLE          hCb)

   974 {

   975     return cmdBld_CmdIeMeasurement (hCmdBld, pMeasurementParams, fCommandResponseCB, hCb);

   976 }

   977 

   978 

   979 /****************************************************************************

   980  *                      cmdBld_measurementStop()

   981  ****************************************************************************

   982  * DESCRIPTION: send Command for stoping measurement  

   983  * 

   984  * INPUTS: None 

   985  * 

   986  * OUTPUT:  None

   987  * 

   988  * RETURNS: TI_OK or TI_NOK

   989  ****************************************************************************/

   990 TI_STATUS cmdBld_CmdMeasurementStop (TI_HANDLE hCmdBld, void* fMeasureCommandResponseCB, TI_HANDLE hCb)

   991 {

   992     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

   993 

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

   995 

   996     return cmdBld_CmdIeMeasurementStop (hCmdBld, fMeasureCommandResponseCB, hCb);

   997 }

   998 

   999 

  1000 /****************************************************************************

  1001  *                      cmdBld_ApDiscovery()

  1002  ****************************************************************************

  1003  * DESCRIPTION: send Command for AP Discovery 

  1004  *              to the mailbox

  1005  * 

  1006  * INPUTS: None 

  1007  * 

  1008  * OUTPUT:  None

  1009  * 

  1010  * RETURNS: TI_OK or TI_NOK

  1011  ****************************************************************************/

  1012 TI_STATUS cmdBld_CmdApDiscovery (TI_HANDLE hCmdBld, TApDiscoveryParams *pApDiscoveryParams, void *fCb, TI_HANDLE hCb)

  1013 {

  1014     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

  1015 

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

  1017 

  1018     return cmdBld_CmdIeApDiscovery (hCmdBld, pApDiscoveryParams, fCb, hCb);

  1019 }

  1020 

  1021 

  1022 /****************************************************************************

  1023  *                      cmdBld_ApDiscoveryStop()

  1024  ****************************************************************************

  1025  * DESCRIPTION: send Command for stoping AP Discovery

  1026  * 

  1027  * INPUTS: None 

  1028  * 

  1029  * OUTPUT:  None

  1030  * 

  1031  * RETURNS: TI_OK or TI_NOK

  1032  ****************************************************************************/

  1033 TI_STATUS cmdBld_CmdApDiscoveryStop (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)

  1034 {

  1035     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

  1036 

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

  1038     

  1039     return cmdBld_CmdIeApDiscoveryStop (hCmdBld, fCb, hCb);

  1040 }

  1041 

  1042 

  1043 TI_STATUS cmdBld_CmdNoiseHistogram (TI_HANDLE hCmdBld, TNoiseHistogram *pNoiseHistParams, void *fCb, TI_HANDLE hCb)

  1044 {

  1045     return cmdBld_CmdIeNoiseHistogram (hCmdBld, pNoiseHistParams, fCb, hCb);

  1046 }

  1047 

  1048 

  1049 /****************************************************************************

  1050  *                      cmdBld_PowerMgmtConfigurationSet ()

  1051  ****************************************************************************

  1052  * DESCRIPTION: Set the ACX power management option IE

  1053  * 

  1054  * INPUTS: powerSaveParams

  1055  * 

  1056  * OUTPUT:  

  1057  * 

  1058  * RETURNS: TI_OK or TI_NOK

  1059  ****************************************************************************/

  1060 TI_STATUS cmdBld_CmdSetPsMode (TI_HANDLE hCmdBld, TPowerSaveParams* powerSaveParams, void *fCb, TI_HANDLE hCb)

  1061 {

  1062     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

  1063 

  1064     /* Rate conversion is done in the HAL */

  1065     cmdBld_ConvertAppRatesBitmap (powerSaveParams->NullPktRateModulation, 

  1066                                   0, 

  1067                                   &powerSaveParams->NullPktRateModulation);

  1068 

  1069     TRACE5(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " cmdBld_PowerMgmtConfigurationSet  ps802_11Enable=0x%x hangOverPeriod=%d needToSendNullData=0x%x  numNullPktRetries=%d  NullPktRateModulation=0x%x\n", powerSaveParams->ps802_11Enable, powerSaveParams->hangOverPeriod, powerSaveParams->needToSendNullData, powerSaveParams->numNullPktRetries, powerSaveParams->NullPktRateModulation);

  1070 

  1071     return cmdBld_CmdIeSetPsMode (hCmdBld, powerSaveParams, fCb, hCb);

  1072 }

  1073 

  1074 

  1075 /****************************************************************************

  1076  *                      cmdBld_EnableRx()

  1077  ****************************************************************************

  1078  * DESCRIPTION: Enable Rx and send Start/Join command 

  1079  * 

  1080  * INPUTS: None 

  1081  * 

  1082  * OUTPUT:  None

  1083  * 

  1084  * RETURNS: TI_OK or TI_NOK

  1085  ****************************************************************************/

  1086 TI_STATUS cmdBld_CmdEnableRx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)

  1087 {

  1088     return cmdBld_CmdIeEnableRx (hCmdBld, fCb, hCb);

  1089 }

  1090 

  1091 

  1092 TI_STATUS cmdBld_CmdAddKey (TI_HANDLE hCmdBld, TSecurityKeys* pKey, TI_BOOL reconfFlag, void *fCb, TI_HANDLE hCb)

  1093 {

  1094     TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;

  1095     TI_UINT8     keyIdx  = (TI_UINT8)pKey->keyIndex;

  1096 

  1097     /* store the security key for reconfigure phase (FW reload)*/

  1098     if (reconfFlag != TI_TRUE)

  1099     {

  1100         if (keyIdx >= (pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS))

  1101         {

  1102             TRACE2(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_CmdAddKey: ERROR Key keyIndex field out of range =%d, range is (0 to %d)\n", pKey->keyIndex, pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION+NO_OF_EXTRA_RECONF_SECUR_KEYS - 1);

  1103             

  1104             return TI_NOK;

  1105         }

  1106 

  1107         if (pKey->keyType == KEY_NULL)

  1108         {

  1109             TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_CmdAddKey: ERROR KeyType is NULL_KEY\n");

  1110             

  1111             return TI_NOK;

  1112         }

  1113 

  1114         os_memoryCopy (pCmdBld->hOs, 

  1115                        (void *)(DB_KEYS(pCmdBld).pReconfKeys + keyIdx),

  1116                        (void *)pKey, 

  1117                        sizeof(TSecurityKeys));

  1118     }

  1119     

  1120     switch (pCmdBld->tSecurity.eSecurityMode)

  1121     {

  1122         case TWD_CIPHER_WEP:

  1123         case TWD_CIPHER_WEP104:

  1124 				return cmdBld_CmdAddWepKey (hCmdBld, pKey, fCb, hCb);

  1125                         

  1126         case TWD_CIPHER_TKIP:

  1127         case TWD_CIPHER_AES_CCMP:

  1128         #ifdef GEM_SUPPORT

  1129             case TWD_CIPHER_GEM:

  1130         #endif

  1131             return cmdBld_CmdAddWpaKey (hCmdBld, pKey, fCb, hCb);

  1132 

  1133         default:

  1134             return TI_NOK;

  1135     }