/**
* \fn scanCncnOsSm_ActionCompleteScan
* \brief Scan concentartor OS state machine complete scan action function
*
* Scan concentartor OS state machine complete scan action function.
* Cleans up after an OS scan cycle - stabilize the scan result table
*
* \param hScanCncn - handle to the scan concentartor object
* \return None
*/
void scanCncnOsSm_ActionCompleteScan (TI_HANDLE hScanCncn)
{
TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
/*Update the table only if scan was not rejected*/
if ( !pScanCncn->pScanClients[ pScanCncn->eCurrentRunningAppScanClient ]->bScanRejectedOn2_4)
{
/*
* set the result table to stable state. Note: OID scans are always done for the application, so the
* results will always be sent to the scan concentartor app scan result table, regardless of the
* SME connection mode. However, it is expected that the SME will NOT attempt to connect when an OID
* scan request will be received
*/
scanResultTable_SetStableState (pScanCncn->hScanResultTable);
}
else
{
pScanCncn->pScanClients[ pScanCncn->eCurrentRunningAppScanClient ]->bScanRejectedOn2_4 = TI_FALSE;
}
/* mark that OID scan process is no longer running */
pScanCncn->bOSScanRunning = TI_FALSE;
/* also mark that no app scan client is running */
pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT;
/* no need to send scan complete event - WZC (or equivalent other OS apps) will query for the results */
}
/**
* \fn sme_AppScanResult
* \brief Callback function from scan concentrator app for results and scan complete indications
*
* Callback function from scan concentrator app for results and scan complete indications, used
* for scans wehen the SME is in manual.
*
* \param hSme - handle to the SME object
* \param eStatus - the reason for calling the CB
* \param pFrameInfo - frame information (if the CB is called due to received frame)
* \param uResultCount - number of results rceived
* \return None
*/
void sme_AppScanResult (TI_HANDLE hSme, EScanCncnResultStatus eStatus,
TScanFrameInfo* pFrameInfo)
{
TSme *pSme = (TSme*)hSme;
/* in manual mode, store the frame in the SME scan result table */
if (CONNECT_MODE_MANUAL == pSme->eConnectMode)
{
switch (eStatus)
{
/* a frame was received - update the scan result table */
case SCAN_CRS_RECEIVED_FRAME:
TRACE6(pSme->hReport, REPORT_SEVERITY_INFORMATION , "sme_AppScanResult: received frame from BSSID %02x:%02x:%02x:%02x:%02x:%02x\n", (*pFrameInfo->bssId)[ 0 ], (*pFrameInfo->bssId)[ 1 ], (*pFrameInfo->bssId)[ 2 ], (*pFrameInfo->bssId)[ 3 ], (*pFrameInfo->bssId)[ 4 ], (*pFrameInfo->bssId)[ 5 ]);
if (TI_OK != scanResultTable_UpdateEntry (pSme->hScanResultTable, pFrameInfo->bssId, pFrameInfo))
{
TRACE6(pSme->hReport, REPORT_SEVERITY_ERROR , "sme_AppScanResult: unable to update enrty for BSSID %02x:%02x:%02x:%02x:%02x:%02x because table is full\n", (*pFrameInfo->bssId)[ 0 ], (*pFrameInfo->bssId)[ 1 ], (*pFrameInfo->bssId)[ 2 ], (*pFrameInfo->bssId)[ 3 ], (*pFrameInfo->bssId)[ 4 ], (*pFrameInfo->bssId)[ 5 ]);
}
break;
/* scan was completed successfully */
case SCAN_CRS_SCAN_COMPLETE_OK:
/* an error occured, try selecting a site anyway */
case SCAN_CRS_SCAN_ABORTED_FW_RESET:
case SCAN_CRS_SCAN_STOPPED:
case SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY:
case SCAN_CRS_SCAN_FAILED:
case SCAN_CRS_TSF_ERROR:
TRACE1(pSme->hReport, REPORT_SEVERITY_INFORMATION , "sme_AppScanResult: received scan complete indication with status %d\n", eStatus);
/* stablizie the scan result table - delete its contenst if no results were recived during last scan */
scanResultTable_SetStableState (pSme->hScanResultTable);
break;
default:
TRACE1(pSme->hReport, REPORT_SEVERITY_ERROR , "sme_AppScanResult: received unrecognized status %d\n", eStatus);
break;
}
}
}
/**
* \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)) {
}
break;
case SCAN_CRS_SCAN_COMPLETE_OK:
/* 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:
/* 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:
/* 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:
break;
}
}
/**
* \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;
/* forward all data to SME */
sme_AppScanResult (pScanCncn->hSme, status, frameInfo);
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, clear it if no results were received */
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, clear it if no results were received */
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, clear it if no results were received */
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;
}
}
/**
* \fn sme_ScanResultCB
* \brief Callback function from scan concentrator for results and scan complete indications
*
* Callback function from scan concentrator for results and scan complete indications
*
* \param hSme - handle to the SME object
* \param eStatus - the reason for calling the CB
* \param pFrameInfo - frame information (if the CB is called due to received frame)
* \param uSPSStatus - SPS attened channels (if the CB is called to inidcate an SPS scan complete)
* \return None
*/
void sme_ScanResultCB (TI_HANDLE hSme, EScanCncnResultStatus eStatus,
TScanFrameInfo* pFrameInfo, TI_UINT16 uSPSStatus)
{
TSme *pSme = (TSme*)hSme;
paramInfo_t param;
switch (eStatus)
{
/* a frame was received - update the scan result table */
case SCAN_CRS_RECEIVED_FRAME:
TRACE6(pSme->hReport, REPORT_SEVERITY_INFORMATION , "sme_ScanResultCB: received frame from BSSID %02x:%02x:%02x:%02x:%02x:%02x\n", (*pFrameInfo->bssId)[ 0 ], (*pFrameInfo->bssId)[ 1 ], (*pFrameInfo->bssId)[ 2 ], (*pFrameInfo->bssId)[ 3 ], (*pFrameInfo->bssId)[ 4 ], (*pFrameInfo->bssId)[ 5 ]);
/*
* in auto mode in order to find country IE only !!!
* filter frames according to desired SSID, in case we are also trying to find
* country IE in passive scan, to avoid a table overflow (in manual mode, the SME table must be equal to the app
* table, the app is responsible to decide which SSIDs to use for scan)
*/
if (CONNECT_MODE_AUTO == pSme->eConnectMode)
{
if (SSID_TYPE_SPECIFIC == pSme->eSsidType)
{
#ifndef XCC_MODULE_INCLUDED
if ((pSme->tSsid.len == pFrameInfo->parsedIEs->content.iePacket.pSsid->hdr[ 1 ]) &&
(0 == os_memoryCompare (pSme->hOS, &(pSme->tSsid.str[ 0 ]),
&(pFrameInfo->parsedIEs->content.iePacket.pSsid->serviceSetId[ 0 ]),
pSme->tSsid.len)))
#endif
{
if (TI_OK != scanResultTable_UpdateEntry (pSme->hScanResultTable, pFrameInfo->bssId, pFrameInfo))
{
TRACE6(pSme->hReport, REPORT_SEVERITY_ERROR , "sme_ScanResultCB: unable to update specific enrty for BSSID %02x:%02x:%02x:%02x:%02x:%02x\n", (*pFrameInfo->bssId)[ 0 ], (*pFrameInfo->bssId)[ 1 ], (*pFrameInfo->bssId)[ 2 ], (*pFrameInfo->bssId)[ 3 ], (*pFrameInfo->bssId)[ 4 ], (*pFrameInfo->bssId)[ 5 ]);
}
}
}
else
{
if (TI_OK != scanResultTable_UpdateEntry (pSme->hScanResultTable, pFrameInfo->bssId, pFrameInfo))
{
TRACE6(pSme->hReport, REPORT_SEVERITY_ERROR , "sme_ScanResultCB: unable to update enrty for BSSID %02x:%02x:%02x:%02x:%02x:%02x because table is full\n", (*pFrameInfo->bssId)[ 0 ], (*pFrameInfo->bssId)[ 1 ], (*pFrameInfo->bssId)[ 2 ], (*pFrameInfo->bssId)[ 3 ], (*pFrameInfo->bssId)[ 4 ], (*pFrameInfo->bssId)[ 5 ]);
}
}
}
else
/* manual mode */
{
if (TI_OK != scanResultTable_UpdateEntry (pSme->hScanResultTable, pFrameInfo->bssId, pFrameInfo))
{
TRACE6(pSme->hReport, REPORT_SEVERITY_ERROR , "sme_ScanResultCB: unable to update application scan enrty for BSSID %02x:%02x:%02x:%02x:%02x:%02x\n", (*pFrameInfo->bssId)[ 0 ], (*pFrameInfo->bssId)[ 1 ], (*pFrameInfo->bssId)[ 2 ], (*pFrameInfo->bssId)[ 3 ], (*pFrameInfo->bssId)[ 4 ], (*pFrameInfo->bssId)[ 5 ]);
}
}
break;
/* scan was completed successfully */
case SCAN_CRS_SCAN_COMPLETE_OK:
/* an error occured, try selecting a site anyway */
case SCAN_CRS_SCAN_ABORTED_FW_RESET:
case SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY:
case SCAN_CRS_SCAN_FAILED:
case SCAN_CRS_TSF_ERROR:
TRACE1(pSme->hReport, REPORT_SEVERITY_INFORMATION , "sme_ScanResultCB: received scan complete indication with status %d\n", eStatus);
/* stablizie the scan result table - delete its contenst if no results were recived during last scan */
scanResultTable_SetStableState (pSme->hScanResultTable);
if (CONNECT_MODE_AUTO == pSme->eConnectMode)
{
/* try to select a site */
pSme->pCandidate = sme_Select (hSme);
/* if no matching site was found */
if (NULL == pSme->pCandidate)
{
/* for IBSS or any, if no entries where found, add the self site */
if (pSme->eBssType == BSS_INFRASTRUCTURE)
{
TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "sme_ScanResultCB: No candidate available, sending connect failure\n");
genSM_Event (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme);
break;
}
{
TI_UINT8 uDesiredChannel;
param.paramType = SITE_MGR_DESIRED_CHANNEL_PARAM;
siteMgr_getParam(pSme->hSiteMgr, ¶m);
uDesiredChannel = param.content.siteMgrDesiredChannel;
if (uDesiredChannel >= SITE_MGR_CHANNEL_A_MIN)
{
param.content.channelCapabilityReq.band = RADIO_BAND_5_0_GHZ;
}
else
{
param.content.channelCapabilityReq.band = RADIO_BAND_2_4_GHZ;
}
/*
update the regulatory domain with the selected band
*/
/* Check if the selected channel is valid according to regDomain */
param.paramType = REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES;
param.content.channelCapabilityReq.scanOption = ACTIVE_SCANNING;
param.content.channelCapabilityReq.channelNum = uDesiredChannel;
regulatoryDomain_getParam (pSme->hRegDomain,¶m);
if (!param.content.channelCapabilityRet.channelValidity)
{
TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "IBSS SELECT FAILURE - No channel !!!\n\n");
genSM_Event (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme);
break;
}
pSme->pCandidate = (TSiteEntry *)addSelfSite(pSme->hSiteMgr);
if (pSme->pCandidate == NULL)
{
TRACE0(pSme->hReport, REPORT_SEVERITY_ERROR , "IBSS SELECT FAILURE - could not open self site !!!\n\n");
genSM_Event (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme);
break;
}
#ifdef REPORT_LOG
TRACE6(pSme->hReport, REPORT_SEVERITY_CONSOLE,"%%%%%%%%%%%%%% SELF SELECT SUCCESS, bssid: %X-%X-%X-%X-%X-%X %%%%%%%%%%%%%%\n\n", pSme->pCandidate->bssid[0], pSme->pCandidate->bssid[1], pSme->pCandidate->bssid[2], pSme->pCandidate->bssid[3], pSme->pCandidate->bssid[4], pSme->pCandidate->bssid[5]);
WLAN_OS_REPORT (("%%%%%%%%%%%%%% SELF SELECT SUCCESS, bssid: %02x.%02x.%02x.%02x.%02x.%02x %%%%%%%%%%%%%%\n\n", pSme->pCandidate->bssid[0], pSme->pCandidate->bssid[1], pSme->pCandidate->bssid[2], pSme->pCandidate->bssid[3], pSme->pCandidate->bssid[4], pSme->pCandidate->bssid[5]));
#endif
}
}
/* a connection candidate is available, send a connect event */
genSM_Event (pSme->hSmeSm, SME_SM_EVENT_CONNECT, hSme);
}
break;
/*
* scan was stopped according to SME request (should happen when moving to disconnecting from scanning), send a
* connect failure event to move out of disconnecting
*/
case SCAN_CRS_SCAN_STOPPED:
TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "sme_ScanResultCB: received scan stopped indication\n");
genSM_Event (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme);
break;
default:
TRACE1(pSme->hReport, REPORT_SEVERITY_ERROR , "sme_ScanResultCB: received unrecognized status %d\n", eStatus);
break;
}
}
/**
* \fn scanCncnApp_ScanResultCB
* \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!)
* \param eScanClient - Client id of the scan initiator which will be sent back to the application
* \return None
*/
void scanCncnApp_ScanResultCB (TI_HANDLE hScanCncn, EScanCncnResultStatus status,
TScanFrameInfo* frameInfo, TI_UINT16 SPSStatus,
EScanClient eExternalScanClient,
EScanCncnClient eScanCncnClient)
{
TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
TScanCncnClient* pClient = NULL;
/* 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 and scan complete is upon one shot */
if (TI_TRUE == pScanCncn->bOSScanRunning && eScanCncnClient == SCAN_SCC_APP_ONE_SHOT)
{
/* 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
{
TScanCncnClient* pClient = NULL;
if (pScanCncn->pScanClients[eScanCncnClient]->bCurrentlyRunning)
{
pClient = pScanCncn->pScanClients[eScanCncnClient];
}
/* move the scan result table to stable state */
scanResultTable_SetStableState (pScanCncn->hScanResultTable);
/* mark that scan is no longer running */
pScanCncn->pScanClients[eScanCncnClient]->bCurrentlyRunning = TI_FALSE;
/*
* The scan was finished, send a scan complete event to the user
* (regardless of why the scan was completed)
*/
EvHandlerSendEvent (pScanCncn->hEvHandler, IPC_EVENT_SCAN_COMPLETE, (TI_UINT8 *)&eExternalScanClient, sizeof(TI_UINT32));
if (pClient)
{
scanCncn_ClientStopped(pScanCncn, pClient);
}
}
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 and scan complete is upon one shot*/
if (TI_TRUE == pScanCncn->bOSScanRunning && eScanCncnClient == SCAN_SCC_APP_ONE_SHOT)
{
/* 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_STOP_SCAN, hScanCncn);
pClient = pScanCncn->pScanClients[eScanCncnClient];
if (pClient)
{
scanCncn_ClientStopped(pScanCncn, pClient);
}
}
else
{
if (pScanCncn->pScanClients[eScanCncnClient]->bCurrentlyRunning)
{
pClient = pScanCncn->pScanClients[eScanCncnClient];
}
/* move the scan result table to stable state */
scanResultTable_SetStableState (pScanCncn->hScanResultTable);
/* mark that scan is no longer running */
pScanCncn->pScanClients[eScanCncnClient]->bCurrentlyRunning = TI_FALSE;
/*
* The scan was finished, send a scan complete event to the user
* (regardless of why the scan was completed)
*/
EvHandlerSendEvent (pScanCncn->hEvHandler, IPC_EVENT_SCAN_COMPLETE, (TI_UINT8 *)&eExternalScanClient, sizeof(TI_UINT32));
if (pClient)
{
scanCncn_ClientStopped(pScanCncn, pClient);
}
}
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 and scan complete is upon one shot */
if (TI_TRUE == pScanCncn->bOSScanRunning && eScanCncnClient == SCAN_SCC_APP_ONE_SHOT)
{
/* 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);
pClient = pScanCncn->pScanClients[eScanCncnClient];
if (pClient)
{
scanCncn_ClientStopped(pScanCncn, pClient);
}
}
else
{
TScanCncnClient* pClient = NULL;
if (pScanCncn->pScanClients[eScanCncnClient]->bCurrentlyRunning)
{
pClient = pScanCncn->pScanClients[eScanCncnClient];
}
/* move the scan result table to stable state */
scanResultTable_SetStableState (pScanCncn->hScanResultTable);
/* mark that scan is no longer running */
pScanCncn->pScanClients[eScanCncnClient]->bCurrentlyRunning = TI_FALSE;
/*
* The scan was finished, send a scan complete event to the user
* (regardless of why the scan was completed)
*/
EvHandlerSendEvent (pScanCncn->hEvHandler, IPC_EVENT_SCAN_COMPLETE, (TI_UINT8 *)&eExternalScanClient, sizeof(TI_UINT32));
if (pClient)
{
scanCncn_ClientStopped(pScanCncn, pClient);
}
}
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;
}
}
