/** * \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; } }