/*
* ScanCncnApp.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 ScanCncnApp.c
* \brief Scan concentrator application scan module implementation
*
* \see ScanCncn.h, ScanCncn.c
*/
#define __FILE_ID__ FILE_ID_77
#include "ScanCncnPrivate.h"
#include "ScanCncn.h"
#include "ScanCncnOsSm.h"
#include "EvHandler.h"
#include "report.h"
#include "GenSM.h"
#include "scanResultTable.h"
#include "sme.h"
#include "smeApi.h"
/**
* \fn scanCncnApp_SetParam
* \brief Parses and executes a set param command
*
* Parses and executes a set param command (start/stop one-shot/periodic/OS scan)
*
* \param hScanCncn - handle to the scan concentrator object
* \param pParam - the param to set
* \return operation status (OK / NOK / PARAM_NOT_SUPPORTED)
* \sa scanCncnApp_GetParam
*/
TI_STATUS scanCncnApp_SetParam (TI_HANDLE hScanCncn, paramInfo_t *pParam)
{
TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
TI_UINT32 uCurrentTimeStamp;
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnApp_SetParam: recevived request of type 0x%x\n", pParam->paramType);
switch (pParam->paramType)
{
case SCAN_CNCN_START_APP_SCAN:
/* verify that scan is not currently running */
if (pScanCncn->eCurrentRunningAppScanClient != SCAN_SCC_NO_CLIENT)
{
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_WARNING, "scanCncnApp_SetParam: trying to start app one-shot scan when client %d is currently running!\n", pScanCncn->eCurrentRunningAppScanClient);
/* Scan was not started successfully, send a scan complete event to the user */
return TI_NOK;
}
/* set one-shot scan as running app scan client */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_APP_ONE_SHOT;
/* Perform aging process before the scan */
scanResultTable_PerformAging(pScanCncn->hScanResultTable);
/* start the scan */
if (SCAN_CRS_SCAN_RUNNING !=
scanCncn_Start1ShotScan (hScanCncn, SCAN_SCC_APP_ONE_SHOT, pParam->content.pScanParams))
{
/* Scan was not started successfully, mark that no app scan is running */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT;
return TI_NOK;
}
break;
case SCAN_CNCN_STOP_APP_SCAN:
/* verify that scan is currently running */
if (pScanCncn->eCurrentRunningAppScanClient != SCAN_SCC_NO_CLIENT)
{
scanCncn_StopScan (hScanCncn, SCAN_SCC_APP_ONE_SHOT);
}
break;
case SCAN_CNCN_START_PERIODIC_SCAN:
/* verify that scan is not currently running */
if (SCAN_SCC_NO_CLIENT != pScanCncn->eCurrentRunningAppScanClient)
{
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_WARNING, "scanCncnApp_SetParam: trying to start app periodic scan when client %d is currently running!\n", pScanCncn->eCurrentRunningAppScanClient);
/* Scan was not started successfully, send a scan complete event to the user */
return TI_NOK;
}
/* set one-shot scan as running app scan client */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_APP_PERIODIC;
/* Perform aging process before the scan */
scanResultTable_PerformAging(pScanCncn->hScanResultTable);
/* start the scan */
if (SCAN_CRS_SCAN_RUNNING !=
scanCncn_StartPeriodicScan (hScanCncn, SCAN_SCC_APP_PERIODIC, pParam->content.pPeriodicScanParams))
{
TRACE0(pScanCncn->hReport, REPORT_SEVERITY_CONSOLE , "Scan was not started. Verify scan parametrs or SME mode\n");
WLAN_OS_REPORT (("Scan was not started. Verify scan parametrs or SME mode\n"));
/* Scan was not started successfully, mark that no app scan is running */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT;
return TI_NOK;
}
break;
case SCAN_CNCN_STOP_PERIODIC_SCAN:
/* verify that scan is currently running */
if (pScanCncn->eCurrentRunningAppScanClient != SCAN_SCC_NO_CLIENT)
{
scanCncn_StopPeriodicScan (hScanCncn, SCAN_SCC_APP_PERIODIC);
}
break;
case SCAN_CNCN_BSSID_LIST_SCAN_PARAM:
/* check if OID scans are enabled in the registry */
if (0 == pScanCncn->tInitParams.uMinimumDurationBetweenOsScans)
{
TRACE0(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnApp_SetParam: received OS scan request when OS scans are disabled, quitting...\n");
return TI_NOK;
}
/* check if the last OID scan didn't start at a shorter duration than the configured minimum */
uCurrentTimeStamp = os_timeStampMs (pScanCncn->hOS);
if ( (uCurrentTimeStamp - pScanCncn->uOSScanLastTimeStamp) <
(pScanCncn->tInitParams.uMinimumDurationBetweenOsScans * 1000) ) /*converted to ms */
{
TRACE3(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnApp_SetParam: last OID scan performed at: %d, now is: %d, min duration is: %d, too early for another scan!\n", pScanCncn->uOSScanLastTimeStamp, uCurrentTimeStamp, pScanCncn->tInitParams.uMinimumDurationBetweenOsScans);
return TI_NOK;
}
/* check that no other scan is currently running */
if (SCAN_SCC_NO_CLIENT != pScanCncn->eCurrentRunningAppScanClient)
{
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnApp_SetParam: received OS scan request when client %d is currently running!\n", pScanCncn->eCurrentRunningAppScanClient);
return TI_NOK;
}
/* set one-shot scan as running app scan client */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_APP_ONE_SHOT;
/* mark that an OID scan process has started */
pScanCncn->bOSScanRunning = TI_TRUE;
pScanCncn->uOSScanLastTimeStamp = uCurrentTimeStamp;
TRACE0(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnApp_SetParam: starting OID scan process...\n");
if(0 != pParam->content.pScanParams->desiredSsid.len)
{
pScanCncn->tOsScanParams.desiredSsid.len = pParam->content.pScanParams->desiredSsid.len;
os_memoryCopy(pScanCncn->hOS, pScanCncn->tOsScanParams.desiredSsid.str, pParam->content.pScanParams->desiredSsid.str, pParam->content.pScanParams->desiredSsid.len);
}
else
{
pScanCncn->tOsScanParams.desiredSsid.len = 0;
pScanCncn->tOsScanParams.desiredSsid.str[ 0 ] = '\0'; /* broadcast scan */
}
pScanCncn->tOsScanParams.scanType = pParam->content.pScanParams->scanType;
/* and actually start the scan */
genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_START_SCAN, hScanCncn);
break;
case SCAN_CNCN_SET_SRA:
scanResultTable_SetSraThreshold(pScanCncn->hScanResultTable, pParam->content.uSraThreshold);
break;
case SCAN_CNCN_SET_RSSI:
pScanCncn->tInitParams.nRssiThreshold = pParam->content.nRssiThreshold;
break;
default:
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnApp_SetParam: unrecognized param type :%d\n", pParam->paramType);
return PARAM_NOT_SUPPORTED;
}
return TI_OK;
}
/**
* \fn scanCncnApp_GetParam
* \brief Parses and executes a get param command
*
* Parses and executes a get param command (get BSSID list)
*
* \param hScanCncn - handle to the scan concentrator object
* \param pParam - the param to get
* \return operation status (OK / NOK / PARAM_NOT_SUPPORTED)
* \sa scanCncnApp_SetParam
*/
TI_STATUS scanCncnApp_GetParam (TI_HANDLE hScanCncn, paramInfo_t *pParam)
{
TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnApp_GetParam: received request of type %d\n", pParam->paramType);
switch (pParam->paramType)
{
case SCAN_CNCN_NUM_BSSID_IN_LIST_PARAM:
/* retrieve the number of BSSID's in the scan result table*/
pParam->paramLength = sizeof(TI_UINT32);
pParam->content.uNumBssidInList = scanResultTable_GetNumOfBSSIDInTheList (pScanCncn->hScanResultTable);
break;
case SCAN_CNCN_BSSID_LIST_SIZE_PARAM:
/* retrieves the size to allocate for the app scan result taBle BBSID list (see next code) */
pParam->paramLength = sizeof(TI_UINT32);
pParam->content.uBssidListSize = scanResultTable_CalculateBssidListSize (pScanCncn->hScanResultTable, TI_TRUE);
break;
case SCAN_CNCN_BSSID_LIST_PARAM:
/* retrieve the app scan result table */
return scanResultTable_GetBssidList (pScanCncn->hScanResultTable, pParam->content.pBssidList,
&pParam->paramLength, TI_TRUE);
case SCAN_CNCN_BSSID_RATE_LIST_PARAM:
/* retrieve supported rates list equivalent to the supported rates list
in the scan result table, but is extended to include 11n rates as well*/
return scanResultTable_GetBssidSupportedRatesList (pScanCncn->hScanResultTable, pParam->content.pRateList,
&pParam->paramLength);
default:
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnApp_GetParam: unrecognized param type :%d\n", pParam->paramType);
return PARAM_NOT_SUPPORTED;
}
return TI_OK;
}
/**
* \fn scanCncn_AppScanResultCB
* \brief Scan result callback for application scan
*
* Scan result callback for application scan
*
* \param hScanCncn - handle to the scan concentrator object
* \param status - the scan result status (scan complete, result received etc.)
* \param frameInfo - a pointer to the structure holding all frame related info (in case a frame was received)
* \param SPSStatus - a bitmap indicating on which channels scan was attempted (valid for SPS scan only!)
* \return None
*/
void scanCncn_AppScanResultCB (TI_HANDLE hScanCncn, EScanCncnResultStatus status,
TScanFrameInfo* frameInfo, TI_UINT16 SPSStatus)
{
TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
TI_UINT32 statusData;
/* Since in Manual Mode the app and the SME use the same table
* there is no need to forward data to SME */
switch (status)
{
case SCAN_CRS_RECEIVED_FRAME:
/* Save the result in the app scan result table */
if (TI_OK != scanResultTable_UpdateEntry (pScanCncn->hScanResultTable, frameInfo->bssId, frameInfo))
{
TRACE0(pScanCncn->hReport, REPORT_SEVERITY_WARNING , "scanCncn_AppScanResultCB, scanResultTable_UpdateEntry() failed\n");
}
break;
case SCAN_CRS_SCAN_COMPLETE_OK:
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_AppScanResultCB, received scan complete with status :%d\n", status);
/* if OS scan is running */
if (TI_TRUE == pScanCncn->bOSScanRunning)
{
/* send a scan complete event to the OS scan SM. It will stabliza the table when needed */
genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
}
else
{
/* move the scan result table to stable state */
scanResultTable_SetStableState (pScanCncn->hScanResultTable);
/* mark that no app scan is running */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT;
/*
* The scan was finished, send a scan complete event to the user
* (regardless of why the scan was completed)
*/
statusData = SCAN_STATUS_COMPLETE; /* Completed status */
EvHandlerSendEvent (pScanCncn->hEvHandler, IPC_EVENT_SCAN_COMPLETE, (TI_UINT8 *)&statusData, sizeof(TI_UINT32));
}
break;
case SCAN_CRS_SCAN_STOPPED:
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_AppScanResultCB, received scan complete with status :%d\n", status);
/* if OS scan is running */
if (TI_TRUE == pScanCncn->bOSScanRunning)
{
/* send a scan complete event to the OS scan SM. It will stabliza the table when needed */
genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
}
else
{
/* move the scan result table to stable state */
scanResultTable_SetStableState (pScanCncn->hScanResultTable);
/* mark that no app scan is running */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT;
/*
* The scan was finished, send a scan complete event to the user
* (regardless of why the scan was completed)
*/
statusData = SCAN_STATUS_STOPPED; /* Stopped status */
EvHandlerSendEvent (pScanCncn->hEvHandler, IPC_EVENT_SCAN_COMPLETE, (TI_UINT8 *)&statusData, sizeof(TI_UINT32));
}
break;
case SCAN_CRS_TSF_ERROR:
case SCAN_CRS_SCAN_RUNNING:
case SCAN_CRS_SCAN_FAILED:
case SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY:
case SCAN_CRS_SCAN_ABORTED_FW_RESET:
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncn_AppScanResultCB, received scan complete with status :%d\n", status);
/* if OS scan is running */
if (TI_TRUE == pScanCncn->bOSScanRunning)
{
/* send a scan complete event to the OS scan SM. It will stabliza the table when needed */
genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
}
else
{
/* move the scan result table to stable state */
scanResultTable_SetStableState (pScanCncn->hScanResultTable);
/* mark that no app scan is running */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT;
/*
* The scan was finished, send a scan complete event to the user
* (regardless of why the scan was completed)
*/
statusData = SCAN_STATUS_FAILED; /* Failed status */
EvHandlerSendEvent (pScanCncn->hEvHandler, IPC_EVENT_SCAN_COMPLETE, (TI_UINT8 *)&statusData, sizeof(TI_UINT32));
}
break;
case SCAN_CRS_NUM_OF_RES_STATUS:
default:
TRACE1(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncn_AppScanResultCB, received erroneuos scan result with status :%d\n", status);
break;
}
}