| /* |
| * ScanCncnSmSpecific.c |
| * |
| * Copyright(c) 1998 - 2009 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 ScanCncnSmSpecific.c |
| * \brief Scan concentrator state machine type-specific functions implemenattion |
| * |
| * \see ScanCncnSm.h, ScanCncnSm.c |
| */ |
| |
| |
| #define __FILE_ID__ FILE_ID_80 |
| #include "scrApi.h" |
| #include "GenSM.h" |
| #include "TWDriver.h" |
| #include "ScanCncnSm.h" |
| #include "ScanCncnPrivate.h" |
| #include "apConn.h" |
| |
| /* |
| * Aplication one-shot scan |
| */ |
| /** |
| * \fn scanCncnSmApp1Shot_ScrRequest |
| * \brief Request the SCR for one-shot application scan |
| * |
| * Request the SCR for one-shot application scan. handle different results. |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmApp1Shot_ScrRequest (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| EScrClientRequestStatus eScrReplyStatus; |
| EScePendReason eScrPendReason; |
| |
| /* request the SCR as application scan client, and act according to return status */ |
| switch (eScrReplyStatus = scr_clientRequest (pScanCncnClient->hSCR, SCR_CID_APP_SCAN, |
| SCR_RESOURCE_SERVING_CHANNEL, &eScrPendReason)) |
| { |
| case SCR_CRS_PEND: |
| /* send a reject event to the SM */ |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmApp1Shot_ScrRequest: SCR pending, pend reason: %d.\n", eScrPendReason); |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| break; |
| |
| case SCR_CRS_RUN: |
| /* send a run event to the SM */ |
| TRACE0(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmApp1Shot_ScrRequest: SCR acquired.\n"); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_RUN, hScanCncnClient); |
| break; |
| |
| default: |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmApp1Shot_ScrRequest: SCR returned unrecognized status: %d.\n", eScrReplyStatus); |
| /* Send a reject event to recover from this error */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| break; |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmApp1Shot_ScrRelease |
| * \brief Release the SCR as one-shot application scan |
| * |
| * Release the SCR as one-shot application scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmApp1Shot_ScrRelease (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| |
| /* release the SCR */ |
| scr_clientComplete (pScanCncnClient->hSCR, SCR_CID_APP_SCAN, SCR_RESOURCE_SERVING_CHANNEL); |
| } |
| |
| /** |
| * \fn scanCncnSmApp1Shot_StartScan |
| * \brief Request scan start from TWD for one-shot application scan |
| * |
| * Request scan start from TWD for one-shot application scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmApp1Shot_StartScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TScanCncn *pScanCncn = (TScanCncn*)pScanCncnClient->hScanCncn; |
| TI_BOOL bPsRequired; |
| TI_STATUS tStatus; |
| |
| /* if the STA is connected, it is rquired to enter PS before scan */ |
| bPsRequired = (STA_CONNECTED == pScanCncn->eConnectionStatus ? TI_TRUE : TI_FALSE); |
| |
| /* call the TWD start scan - enter driver mode (PS) only if station is connected */ |
| tStatus = TWD_Scan (pScanCncnClient->hTWD, &(pScanCncnClient->uScanParams.tOneShotScanParams), SCAN_RESULT_TAG_APPLICATION_ONE_SHOT, |
| TI_FALSE, bPsRequired, TI_FALSE, POWER_SAVE_ON, /* this parameter is used only when driver mode requested */ |
| bPsRequired, NULL, NULL); |
| |
| if (TI_OK != tStatus) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmApp1Shot_StartScan: TWD returned status %d, quitting app scan.\n", tStatus); |
| |
| /* mark the return status */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| |
| /* could not start scan, send a scan complete event to reset the SM */ |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmApp1Shot_StopScan |
| * \brief Request scan stop from TWD for one-shot application scan |
| * |
| * Request scan stop from TWD for one-shot application scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmApp1Shot_StopScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TScanCncn *pScanCncn = (TScanCncn*)pScanCncnClient->hScanCncn; |
| TI_STATUS tStatus; |
| |
| /* call the TWD stop scan function */ |
| if (pScanCncn->eConnectionStatus != STA_CONNECTED) |
| { |
| tStatus = TWD_StopScan (pScanCncnClient->hTWD, SCAN_RESULT_TAG_APPLICATION_ONE_SHOT, TI_FALSE, NULL, NULL); |
| } |
| else |
| { |
| tStatus = TWD_StopScan (pScanCncnClient->hTWD, SCAN_RESULT_TAG_APPLICATION_ONE_SHOT, pScanCncnClient->bSendNullDataOnStop, NULL, NULL); |
| } |
| |
| /* if stop scan operation failed, send a scan complete event to reset the SM */ |
| if (TI_OK != tStatus) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmApp1Shot_StopScan: status %d from TWD_StopScan, sending scan complete to SM\n", tStatus); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmApp1Shot_Recovery |
| * \brief Handles recovery during scan for one-shot application scan |
| * |
| * Notifies the scan SRV to stop its timer |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmApp1Shot_Recovery (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| |
| /* Notify scan SRV to stop its timer */ |
| TWD_StopScanOnFWReset (pScanCncnClient->hTWD); |
| } |
| |
| /* |
| * Aplication Periodic scan |
| */ |
| /** |
| * \fn scanCncnSmAppP_ScrRequest |
| * \brief Request the SCR for periodic application scan |
| * |
| * Request the SCR for periodic application scan. Handle different results |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmAppP_ScrRequest (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| EScrClientRequestStatus eScrReplyStatus; |
| EScePendReason eScrPendReason; |
| |
| /* request the SCR as application scan client, and act according to return status */ |
| switch (eScrReplyStatus = scr_clientRequest (pScanCncnClient->hSCR, SCR_CID_APP_SCAN, |
| SCR_RESOURCE_PERIODIC_SCAN, &eScrPendReason)) |
| { |
| case SCR_CRS_PEND: |
| /* send a reject event to the SM */ |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmAppP_ScrRequest: SCR pending, pend reason: %d.\n", eScrPendReason); |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| break; |
| |
| case SCR_CRS_RUN: |
| /* send a run event to the SM */ |
| TRACE0(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmAppP_ScrRequest: SCR acquired.\n"); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_RUN, hScanCncnClient); |
| break; |
| |
| default: |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmAppP_ScrRequest: SCR returned unrecognized status: %d.\n", eScrReplyStatus); |
| /* Send a reject event to recover from this error */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| break; |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmAppP_ScrRelease |
| * \brief Release the SCR as periodic application scan |
| * |
| * Release the SCR as periodic application scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmAppP_ScrRelease (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| |
| /* release the SCR */ |
| scr_clientComplete (pScanCncnClient->hSCR, SCR_CID_APP_SCAN, SCR_RESOURCE_PERIODIC_SCAN); |
| } |
| |
| /** |
| * \fn scanCncnSmAppP_StartScan |
| * \brief Request scan start from TWD for periodic application scan |
| * |
| * Request scan start from TWD for periodic application scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmAppP_StartScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TScanCncn *pScanCncn = (TScanCncn*)pScanCncnClient->hScanCncn; |
| TI_STATUS tStatus; |
| |
| /* call the TWD start scan */ |
| tStatus = TWD_StartConnectionScan (pScanCncnClient->hTWD, &(pScanCncnClient->uScanParams.tPeriodicScanParams), |
| SCAN_RESULT_TAG_APPLICATION_PEIODIC, |
| pScanCncn->tInitParams.uDfsPassiveDwellTimeMs, NULL, NULL); |
| if (TI_OK != tStatus) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmAppP_StartScan: TWD returned status %d, quitting app scan.\n", tStatus); |
| |
| /* mark the return status */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| |
| /* could not start scan, send a scan complete event to reset the SM */ |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmAppP_StopScan |
| * \brief Request scan stop from TWD for periodic application scan |
| * |
| * Request scan stop from TWD for periodic application scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmAppP_StopScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TI_STATUS status; |
| |
| /* call the TWD stop periodic scan function */ |
| status = TWD_StopPeriodicScan (pScanCncnClient->hTWD, SCAN_RESULT_TAG_APPLICATION_PEIODIC, NULL, NULL); |
| |
| /* if stop scan operation failed, send a scan complete event to reset the SM */ |
| if (TI_OK != status) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmAppP_StopScan: status %d from TWD_StopPeriodicScan, sending scan complete to SM\n", status); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmAppP_Recovery |
| * \brief Handles recovery during scan for periodic application scan |
| * |
| * Handles recovery during scan for periodic application scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmAppP_Recovery (TI_HANDLE hScanCncnClient) |
| { |
| } |
| |
| /* |
| * Driver periodic scan |
| */ |
| /** |
| * \fn scanCncnSmDrvP_ScrRequest |
| * \brief Request the SCR for periodic driver scan |
| * |
| * Request the SCR for periodic driver scan. Handle different results |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmDrvP_ScrRequest (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| EScrClientRequestStatus eScrReplyStatus; |
| EScePendReason eScrPendReason; |
| |
| /* request the SCR as driver scan client, and act according to return status */ |
| switch (eScrReplyStatus = scr_clientRequest( pScanCncnClient->hSCR, SCR_CID_DRIVER_FG_SCAN, |
| SCR_RESOURCE_PERIODIC_SCAN, &eScrPendReason ) ) |
| { |
| case SCR_CRS_PEND: |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmAppP_ScrRequest: SCR pending, pend reason: %d.\n", eScrPendReason); |
| |
| /* check the pending reason */ |
| if (SCR_PR_OTHER_CLIENT_ABORTING != eScrPendReason) |
| { |
| /* |
| * send a reject event to the SM - would not scan if not in a different group or |
| * another un-abortable client is running |
| */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| } |
| /* if the pending reason is another client aborting wait untill it finish abort */ |
| break; |
| |
| case SCR_CRS_RUN: |
| /* send a run event to the SM */ |
| TRACE0(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmAppP_ScrRequest: SCR acquired.\n"); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_RUN, hScanCncnClient); |
| break; |
| |
| default: |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmAppP_ScrRequest: SCR returned unrecognized status: %d\n", eScrReplyStatus); |
| /* Send a reject event to recover from this error */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| break; |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmDrvP_ScrRelease |
| * \brief Release the SCR as periodic driver scan |
| * |
| * Release the SCR as periodic driver scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmDrvP_ScrRelease (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| |
| /* release the SCR */ |
| scr_clientComplete (pScanCncnClient->hSCR, SCR_CID_DRIVER_FG_SCAN, SCR_RESOURCE_PERIODIC_SCAN); |
| } |
| |
| /** |
| * \fn scanCncnSmDrvP_StartScan |
| * \brief Request scan start from TWD for periodic driver scan |
| * |
| * Request scan start from TWD for periodic driver scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmDrvP_StartScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TScanCncn *pScanCncn = (TScanCncn*)pScanCncnClient->hScanCncn; |
| TI_STATUS status; |
| |
| /* call the TWD_scan function */ |
| status = TWD_StartConnectionScan (pScanCncnClient->hTWD, &(pScanCncnClient->uScanParams.tPeriodicScanParams), |
| SCAN_RESULT_TAG_DRIVER_PERIODIC, |
| pScanCncn->tInitParams.uDfsPassiveDwellTimeMs, NULL, NULL); |
| |
| if (TI_OK != status) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmDrvP_StartScan: TWD returned status %d, quitting app scan.\n", status); |
| |
| /* mark the return status */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| |
| /* could not start scan, send a scan complete event to reset the SM */ |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmDrvP_StopScan |
| * \brief Request scan stop from TWD for periodic driver scan |
| * |
| * Request scan stop from TWD for periodic driver scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmDrvP_StopScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TI_STATUS status; |
| |
| /* call the TWD stop periodic scan */ |
| status = TWD_StopPeriodicScan (pScanCncnClient->hTWD, SCAN_RESULT_TAG_DRIVER_PERIODIC, NULL, NULL); |
| |
| /* if stop scan operation failed, send a scan complete event to reset the SM */ |
| if (TI_OK != status) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmDrvP_StopScan: status %d from TWD_StopPeriodicScan, sending scan complete to SM\n", status); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmApp1Shot_Recovery |
| * \brief Handles recovery during scan for periodic driver scan |
| * |
| * Handles recovery during scan for periodic driver scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmDrvP_Recovery (TI_HANDLE hScanCncnClient) |
| { |
| } |
| |
| /* |
| * Continuous one-shot scan |
| */ |
| /** |
| * \fn scanCncnSmCont1Shot_ScrRequest |
| * \brief Request the SCR for one-shot continuous scan |
| * |
| * Request the SCR for one-shot continuous scan. Handle different results |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmCont1Shot_ScrRequest (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| EScrClientRequestStatus eScrReplyStatus; |
| EScePendReason eScrPendReason; |
| |
| /* request the SCR as continuous roaming client, and act according to return status */ |
| switch (eScrReplyStatus = scr_clientRequest (pScanCncnClient->hSCR, SCR_CID_CONT_SCAN, |
| SCR_RESOURCE_SERVING_CHANNEL, &eScrPendReason ) ) |
| { |
| case SCR_CRS_PEND: |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmCont1Shot_ScrRequest: SCR pending, pend Reason: %d.\n", eScrPendReason); |
| /* check pend reason */ |
| if (SCR_PR_DIFFERENT_GROUP_RUNNING == eScrPendReason) |
| { |
| /* send a reject event to the SM - will not scan if not in connected group */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| } |
| /* for other pending reasons wait untill current client finishes */ |
| break; |
| |
| case SCR_CRS_RUN: |
| /* send a run event to the SM */ |
| TRACE0(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmCont1Shot_ScrRequest: SCR acquired.\n"); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_RUN, hScanCncnClient); |
| break; |
| |
| default: |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmCont1Shot_ScrRequest: SCR returned unrecognized status: %d.\n", eScrReplyStatus); |
| /* Send a reject event to recover from this error */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| break; |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmCont1Shot_ScrRelease |
| * \brief Release the SCR as one-shot continuous scan |
| * |
| * Release the SCR as one-shot continuous scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmCont1Shot_ScrRelease (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| |
| /* release the SCR */ |
| scr_clientComplete (pScanCncnClient->hSCR, SCR_CID_CONT_SCAN, SCR_RESOURCE_SERVING_CHANNEL); |
| } |
| |
| /** |
| * \fn scanCncnSmCont1Shot_StartScan |
| * \brief Request scan start from TWD for one-shot continuous scan |
| * |
| * Request scan start from TWD for one-shot continuous scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmCont1Shot_StartScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TI_STATUS status; |
| |
| /* call the TWD start scan function */ |
| status = TWD_Scan (pScanCncnClient->hTWD, &(pScanCncnClient->uScanParams.tOneShotScanParams), |
| SCAN_RESULT_TAG_CONTINUOUS, TI_FALSE, TI_TRUE, TI_FALSE, POWER_SAVE_ON, TI_TRUE, |
| NULL, NULL); |
| |
| if (TI_OK != status) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmCont1Shot_StartScan: TWD returned status %d, quitting continuous scan.\n", status); |
| |
| /* mark the return status */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| |
| /* could not start scan, send a scan complete event */ |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmCont1Shot_StopScan |
| * \brief Request scan stop from TWD for one-shot continuous scan |
| * |
| * Request scan stop from TWD for one-shot continuous scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmCont1Shot_StopScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TI_STATUS status; |
| |
| /* send a stop scan command to FW */ |
| status = TWD_StopScan (pScanCncnClient->hTWD, SCAN_RESULT_TAG_CONTINUOUS, pScanCncnClient->bSendNullDataOnStop, NULL, NULL); |
| |
| /* if stop scan operation failed, send a scan complete event to reset the SM */ |
| if (TI_OK != status) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmCont1Shot_StopScan: status %d from TWD_StopScan, sending scan complete to SM\n", status); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmCont1Shot_Recovery |
| * \brief Handles recovery during scan for one-shot continuous scan |
| * |
| * Notifies the scan SRV to stop its timer |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmCont1Shot_Recovery (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| |
| /* Notify scan SRV to stop its timer */ |
| TWD_StopScanOnFWReset (pScanCncnClient->hTWD); |
| } |
| |
| /* |
| * Immediate one-shot scan |
| */ |
| /** |
| * \fn scanCncnSmImmed1Shot_ScrRequest |
| * \brief Request the SCR for one-shot immediate scan |
| * |
| * Request the SCR for one-shot immediate scan. Handle different results |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmImmed1Shot_ScrRequest (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| EScrClientRequestStatus eScrReplyStatus; |
| EScePendReason eScrPendReason; |
| |
| /* request the SCR as immediate roaming client, and act according to return status */ |
| switch (eScrReplyStatus = scr_clientRequest (pScanCncnClient->hSCR, SCR_CID_IMMED_SCAN, |
| SCR_RESOURCE_SERVING_CHANNEL, &eScrPendReason)) |
| { |
| case SCR_CRS_PEND: |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmImmed1Shot_ScrRequest: SCR pending, pend Reason: %d.\n", eScrPendReason); |
| |
| /* check pend reason */ |
| if ( SCR_PR_DIFFERENT_GROUP_RUNNING == eScrPendReason ) |
| { |
| /* send a reject event to the SM - will not scan if not in the correct group */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| } |
| /* for other pending reasons wait untill current client finishes */ |
| break; |
| |
| case SCR_CRS_RUN: |
| /* send a run event to the SM */ |
| TRACE0(pScanCncnClient->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnSmImmed1Shot_ScrRequest: SCR acquired.\n"); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_RUN, hScanCncnClient); |
| break; |
| |
| default: |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmImmed1Shot_ScrRequest: SCR returned unrecognized status: %d.\n", eScrReplyStatus); |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| /* Send a reject event to recover from this error */ |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_REJECT, hScanCncnClient); |
| break; |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmImmed1Shot_ScrRelease |
| * \brief Release the SCR as one-shot immediate scan |
| * |
| * Release the SCR as one-shot immediate scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmImmed1Shot_ScrRelease (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| |
| /* release the SCR */ |
| scr_clientComplete (pScanCncnClient->hSCR, SCR_CID_IMMED_SCAN, SCR_RESOURCE_SERVING_CHANNEL); |
| } |
| |
| /** |
| * \fn scanCncnSmImmed1Shot_StartScan |
| * \brief Request scan start from TWD for one-shot immediate scan |
| * |
| * Request scan start from TWD for one-shot immediate scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmImmed1Shot_StartScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TI_BOOL bPsRequired, bTriggeredScan; |
| TI_STATUS status; |
| |
| /* check whether enter PS is required - according to the roaming reason severity */ |
| bPsRequired = apConn_isPsRequiredBeforeScan (pScanCncnClient->hApConn); |
| bTriggeredScan = ((SCAN_TYPE_TRIGGERED_ACTIVE == pScanCncnClient->uScanParams.tOneShotScanParams.scanType) || |
| (SCAN_TYPE_TRIGGERED_PASSIVE == pScanCncnClient->uScanParams.tOneShotScanParams.scanType) |
| ? TI_TRUE : TI_FALSE); |
| |
| status = TWD_Scan (pScanCncnClient->hTWD, &(pScanCncnClient->uScanParams.tOneShotScanParams), |
| SCAN_RESULT_TAG_IMMEDIATE, !bTriggeredScan, /* Triggered scan cannot be high priority */ |
| TI_TRUE, TI_TRUE, (bPsRequired ? POWER_SAVE_ON : POWER_SAVE_KEEP_CURRENT), |
| bPsRequired, NULL, NULL); |
| |
| /* call the scan SRV start scan */ |
| if (TI_OK != status) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmImmed1Shot_StartScan: TWD start scanreturned status %d, quitting immediate scan.\n", status); |
| |
| /* mark the return status */ |
| pScanCncnClient->eScanResult = SCAN_CRS_SCAN_FAILED; |
| |
| /* could not start scan, send a scan complete event */ |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmImmed1Shot_StopScan |
| * \brief Request scan stop from TWD for one-shot immediate scan |
| * |
| * Request scan stop from TWD for one-shot immediate scan |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmImmed1Shot_StopScan (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| TI_STATUS status; |
| |
| /* call the TWD stop scan */ |
| status = TWD_StopScan (pScanCncnClient->hTWD, SCAN_RESULT_TAG_IMMEDIATE, pScanCncnClient->bSendNullDataOnStop, NULL, NULL); |
| |
| /* if stop scan operation failed, send a scan complete event to reset the SM */ |
| if (TI_OK != status) |
| { |
| TRACE1(pScanCncnClient->hReport, REPORT_SEVERITY_ERROR , "scanCncnSmImmed1Shot_StopScan: status %d from TWD_StopScan, sending scan complete to SM\n", status); |
| genSM_Event (pScanCncnClient->hGenSM, SCAN_CNCN_SM_EVENT_SCAN_COMPLETE, hScanCncnClient); |
| } |
| } |
| |
| /** |
| * \fn scanCncnSmImmed1Shot_Recovery |
| * \brief Handles recovery during scan for one-shot immediate scan |
| * |
| * Notifies the scan SRV to stop its timer |
| * |
| * \param hScanCncnClient - handle to the specific client object |
| * \return None |
| */ |
| void scanCncnSmImmed1Shot_Recovery (TI_HANDLE hScanCncnClient) |
| { |
| TScanCncnClient *pScanCncnClient = (TScanCncnClient*)hScanCncnClient; |
| |
| /* Notify scan SRV to stop its timer */ |
| TWD_StopScanOnFWReset (pScanCncnClient->hTWD); |
| } |
| |
