| /* |
| * smeSm.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 smeSm.c |
| * \brief SME state machine implementation |
| * |
| * \see smeSm.h, sme.c, sme.h |
| */ |
| |
| |
| #define __FILE_ID__ FILE_ID_43 |
| #include "GenSM.h" |
| #include "smeSm.h" |
| #include "smePrivate.h" |
| #include "connApi.h" |
| #include "apConn.h" |
| #include "ScanCncn.h" |
| #include "scanResultTable.h" |
| #include "EvHandler.h" |
| #include "regulatoryDomainApi.h" |
| #include "siteMgrApi.h" |
| #include "DrvMain.h" |
| |
| |
| static OS_802_11_DISASSOCIATE_REASON_E eDisassocConvertTable[ MGMT_STATUS_MAX_NUM +1] = |
| { |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_AUTH_REJECT, |
| OS_DISASSOC_STATUS_ASSOC_REJECT, |
| OS_DISASSOC_STATUS_SECURITY_FAILURE, |
| OS_DISASSOC_STATUS_AP_DEAUTHENTICATE, |
| OS_DISASSOC_STATUS_AP_DISASSOCIATE, |
| OS_DISASSOC_STATUS_ROAMING_TRIGGER, |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_UNSPECIFIED, |
| OS_DISASSOC_STATUS_UNSPECIFIED |
| }; |
| |
| #define SME_CONVERT_DISASSOC_CODES(disassocReason) (eDisassocConvertTable[ (disassocReason) ]) |
| |
| static void smeSm_Start (TI_HANDLE hSme); |
| static void smeSm_Stop (TI_HANDLE hSme); |
| static void smeSm_PreConnect (TI_HANDLE hSme); |
| static void smeSm_Connect (TI_HANDLE hSme); |
| static void smeSm_ConnectSuccess (TI_HANDLE hSme); |
| static void smeSm_Disconnect (TI_HANDLE hSme); |
| static void smeSm_DisconnectDone (TI_HANDLE hSme); |
| static void smeSm_StopScan (TI_HANDLE hSme); |
| static void smeSm_StopConnect (TI_HANDLE hSme); |
| static void smeSm_ConnWhenConnecting (TI_HANDLE hSme); |
| static void smeSm_ActionUnexpected (TI_HANDLE hSme); |
| static void smeSm_NopAction (TI_HANDLE hSme); |
| static void smeSm_CheckStartConditions (TI_HANDLE hSme); |
| |
| static TI_STATUS sme_StartScan (TI_HANDLE hSme); |
| static void sme_updateScanCycles (TI_HANDLE hSme, |
| TI_BOOL bDEnabled, |
| TI_BOOL bCountryValid, |
| TI_BOOL bConstantScan); |
| static void sme_CalculateCyclesNumber (TI_HANDLE hSme, TI_UINT32 uTotalTimeMs); |
| |
| TGenSM_actionCell tSmMatrix[ SME_SM_NUMBER_OF_STATES ][ SME_SM_NUMBER_OF_EVENTS ] = |
| { |
| { /* SME_SM_STATE_IDLE */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_Start }, /* SME_SM_EVENT_START */ |
| { SME_SM_STATE_IDLE, smeSm_ActionUnexpected }, /* SME_SM_EVENT_STOP */ |
| { SME_SM_STATE_IDLE, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT */ |
| { SME_SM_STATE_IDLE, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT_SUCCESS */ |
| { SME_SM_STATE_IDLE, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT_FAILURE */ |
| { SME_SM_STATE_IDLE, smeSm_CheckStartConditions }, /* SME_SM_EVENT_DISCONNECT */ |
| }, |
| { /* SME_SM_STATE_WAIT_CONNECT */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_ActionUnexpected }, /* SME_SM_EVENT_START */ |
| { SME_SM_STATE_IDLE, smeSm_Stop }, /* SME_SM_EVENT_STOP */ |
| { SME_SM_STATE_SCANNING, smeSm_PreConnect }, /* SME_SM_EVENT_CONNECT */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT_SUCCESS */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT_FAILURE */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_Start }, /* SME_SM_EVENT_DISCONNECT */ |
| }, |
| { /* SME_SM_STATE_SCANNING */ |
| { SME_SM_STATE_SCANNING, smeSm_ActionUnexpected }, /* SME_SM_EVENT_START */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_StopScan }, /* SME_SM_EVENT_STOP */ |
| { SME_SM_STATE_CONNECTING, smeSm_Connect }, /* SME_SM_EVENT_CONNECT */ |
| { SME_SM_STATE_SCANNING, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT_SUCCESS */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_DisconnectDone }, /* SME_SM_EVENT_CONNECT_FAILURE */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_StopScan }, /* SME_SM_EVENT_DISCONNECT */ |
| }, |
| { /* SME_SM_STATE_CONNECTING */ |
| { SME_SM_STATE_CONNECTING, smeSm_ActionUnexpected }, /* SME_SM_EVENT_START */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_StopConnect }, /* SME_SM_EVENT_STOP */ |
| { SME_SM_STATE_CONNECTING, smeSm_ConnWhenConnecting }, /* SME_SM_EVENT_CONNECT */ |
| { SME_SM_STATE_CONNECTED, smeSm_ConnectSuccess }, /* SME_SM_EVENT_CONNECT_SUCCESS */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_DisconnectDone }, /* SME_SM_EVENT_CONNECT_FAILURE */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_StopConnect }, /* SME_SM_EVENT_DISCONNECT */ |
| }, |
| { /* SME_SM_STATE_CONNECTED */ |
| { SME_SM_STATE_CONNECTED, smeSm_ActionUnexpected }, /* SME_SM_EVENT_START */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_Disconnect }, /* SME_SM_EVENT_STOP */ |
| { SME_SM_STATE_CONNECTED, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT */ |
| { SME_SM_STATE_CONNECTED, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT_SUCCESS */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_DisconnectDone }, /* SME_SM_EVENT_CONNECT_FAILURE */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_Disconnect }, /* SME_SM_EVENT_DISCONNECT */ |
| }, |
| { /* SME_SM_STATE_DISCONNECTING */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_ActionUnexpected }, /* SME_SM_EVENT_START */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_ActionUnexpected }, /* SME_SM_EVENT_STOP */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_ActionUnexpected }, /* SME_SM_EVENT_CONNECT_SUCCESS */ |
| { SME_SM_STATE_WAIT_CONNECT, smeSm_DisconnectDone }, /* SME_SM_EVENT_CONNECT_FAILURE */ |
| { SME_SM_STATE_DISCONNECTING, smeSm_NopAction }, /* SME_SM_EVENT_DISCONNECT */ |
| } |
| }; |
| |
| TI_INT8* uStateDescription[] = |
| { |
| "IDLE", |
| "WAIT_CONNECT", |
| "SCANNING", |
| "CONNECTING", |
| "CONNECTED", |
| "DISCONNECTING" |
| }; |
| |
| TI_INT8* uEventDescription[] = |
| { |
| "START", |
| "STOP", |
| "CONNECT", |
| "CONNECT_SUCCESS", |
| "CONNECT_FAILURE", |
| "DISCONNECT" |
| }; |
| |
| /** |
| * \fn smeSm_Start |
| * \brief Starts STA opeartion by moving SCR out of idle group and starting connection process |
| * |
| * Starts STA opeartion by moving SCR out of idle group and starting connection process |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_Stop, sme_start |
| */ |
| void smeSm_Start (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| |
| /* set SCR group according to connection mode */ |
| if (CONNECT_MODE_AUTO == pSme->eConnectMode) |
| { |
| TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "smeSm_Start: changing SCR group to DRV scan\n"); |
| scr_setGroup (pSme->hScr, SCR_GID_DRV_SCAN); |
| } |
| else |
| { |
| TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "smeSm_Start: changing SCR group to APP scan\n"); |
| scr_setGroup (pSme->hScr, SCR_GID_APP_SCAN); |
| } |
| |
| if ((TI_FALSE == pSme->bRadioOn) || (TI_FALSE == pSme->bRunning)) |
| { |
| /* Radio is off so send stop event */ |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_STOP, hSme); |
| } |
| else if (TI_TRUE == pSme->bConnectRequired) |
| { |
| /* if connection was required, start the process */ |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_CONNECT, hSme); |
| } |
| } |
| |
| /** |
| * \fn smeSm_Stop |
| * \brief Turns off the STA |
| * |
| * Turns off the STA by moving the SCr to idle |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_Start, sme_Stop |
| */ |
| void smeSm_Stop (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| |
| /* set SCR group to idle */ |
| scr_setGroup (pSme->hScr, SCR_GID_IDLE); |
| |
| if (TI_FALSE == pSme->bRunning) |
| { |
| /* call DrvMain */ |
| drvMain_SmeStop (pSme->hDrvMain); |
| } |
| } |
| |
| /** |
| * \fn smeSm_PreConnect |
| * \brief Initiates the connection process |
| * |
| * Initiates the connection process - for automatic mode, start scan, for manual mode - triggers connection |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_Connect, smeSm_ConnectSuccess |
| */ |
| void smeSm_PreConnect (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme *)hSme; |
| paramInfo_t *pParam; |
| |
| /* set the connection mode with which this connection attempt is starting */ |
| pSme->eLastConnectMode = pSme->eConnectMode; |
| |
| /* mark that no authentication/assocaition was yet sent */ |
| pSme->bAuthSent = TI_FALSE; |
| |
| /* try to find a connection candidate (manual mode have already performed scann */ |
| pSme->pCandidate = sme_Select (hSme); |
| if (NULL != pSme->pCandidate) |
| { |
| /* candidate is available - attempt connection */ |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_CONNECT, hSme); |
| } |
| /* no candidate */ |
| else |
| { |
| if (CONNECT_MODE_AUTO == pSme->eConnectMode) |
| { |
| /* automatic mode - start scanning */ |
| if (TI_OK != sme_StartScan (hSme)) |
| { |
| TRACE0(pSme->hReport, REPORT_SEVERITY_ERROR , "smeSm_PreConnect: unable to start scan, stopping the SME\n"); |
| pSme->bRadioOn = TI_FALSE; |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme); |
| } |
| |
| /* update scan count counter */ |
| if(pSme->uScanCount < PERIODIC_SCAN_MAX_INTERVAL_NUM) |
| { |
| pSme->uScanCount++; |
| } |
| |
| } |
| else /* Manual mode */ |
| { |
| /* for IBSS or any, if no entries where found, add the self site */ |
| if (pSme->eBssType == BSS_INFRASTRUCTURE) |
| { |
| /* makr whether we need to stop the attempt connection in manual mode */ |
| pSme->bConnectRequired = TI_FALSE; |
| |
| TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "smeSm_PreConnect: No candidate available, sending connect failure\n"); |
| /* manual mode and no connection candidate is available - connection failed */ |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme); |
| } |
| |
| else /* IBSS */ |
| { |
| TI_UINT8 uDesiredChannel; |
| TI_BOOL channelValidity; |
| |
| pSme->bConnectRequired = TI_FALSE; |
| |
| pParam = (paramInfo_t *)os_memoryAlloc(pSme->hOS, sizeof(paramInfo_t)); |
| if (!pParam) |
| { |
| return; |
| } |
| |
| pParam->paramType = SITE_MGR_DESIRED_CHANNEL_PARAM; |
| siteMgr_getParam(pSme->hSiteMgr, pParam); |
| uDesiredChannel = pParam->content.siteMgrDesiredChannel; |
| |
| if (uDesiredChannel >= SITE_MGR_CHANNEL_A_MIN) |
| { |
| pParam->content.channelCapabilityReq.band = RADIO_BAND_5_0_GHZ; |
| } |
| else |
| { |
| pParam->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 */ |
| pParam->paramType = REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES; |
| pParam->content.channelCapabilityReq.scanOption = ACTIVE_SCANNING; |
| pParam->content.channelCapabilityReq.channelNum = uDesiredChannel; |
| |
| regulatoryDomain_getParam (pSme->hRegDomain, pParam); |
| channelValidity = pParam->content.channelCapabilityRet.channelValidity; |
| os_memoryFree(pSme->hOS, pParam, sizeof(paramInfo_t)); |
| if (!channelValidity) |
| { |
| TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "IBSS SELECT FAILURE - No channel !!!\n\n"); |
| |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme); |
| |
| return; |
| } |
| |
| 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"); |
| |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme); |
| |
| return; |
| } |
| |
| #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 */ |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_CONNECT, hSme); |
| } |
| } |
| } |
| } |
| |
| /** |
| * \fn smeSm_Connect |
| * \brief Starts a connection process with the selected network |
| * |
| * Starts a connection process with the selected network |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_PreConnect, smeSm_ConnectSuccess |
| */ |
| void smeSm_Connect (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| TI_STATUS tStatus; |
| paramInfo_t *pParam; |
| |
| /* Sanity check - if no connection candidate was found so far */ |
| if (NULL == pSme->pCandidate) |
| { |
| TRACE0(pSme->hReport, REPORT_SEVERITY_ERROR , "smeSm_Connect: No candidate available, sending connect failure\n"); |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_CONNECT_FAILURE, hSme); |
| } |
| else |
| { |
| pParam = (paramInfo_t *)os_memoryAlloc(pSme->hOS, sizeof(paramInfo_t)); |
| if (!pParam) |
| { |
| return; |
| } |
| |
| /* set SCR group */ |
| if (BSS_INFRASTRUCTURE == pSme->pCandidate->bssType) |
| { |
| scr_setGroup (pSme->hScr, SCR_GID_CONNECT); |
| } |
| |
| /***************** Config Connection *************************/ |
| pParam->paramType = CONN_TYPE_PARAM; |
| if (BSS_INDEPENDENT == pSme->pCandidate->bssType) |
| if (SITE_SELF == pSme->pCandidate->siteType) |
| { |
| pParam->content.connType = CONNECTION_SELF; |
| } |
| else |
| { |
| pParam->content.connType = CONNECTION_IBSS; |
| } |
| else |
| pParam->content.connType = CONNECTION_INFRA; |
| conn_setParam(pSme->hConn, pParam); |
| os_memoryFree(pSme->hOS, pParam, sizeof(paramInfo_t)); |
| |
| /* start the connection process */ |
| tStatus = conn_start (pSme->hConn, CONN_TYPE_FIRST_CONN, sme_ReportConnStatus, hSme, TI_FALSE, TI_FALSE); |
| if (TI_OK != tStatus) |
| { |
| TRACE1(pSme->hReport, REPORT_SEVERITY_ERROR , "smeSm_Connect: conn_start returned status %d\n", tStatus); |
| } |
| } |
| } |
| |
| /** |
| * \fn smeSm_ConnectSuccess |
| * \brief Handles connection success indication |
| * |
| * Handles connection success indication - starts AP conn and set SCR group to connected |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_PreConnect, smeSm_Connect |
| */ |
| void smeSm_ConnectSuccess (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| |
| pSme->uScanCount = 0; |
| |
| /* connection succedded to the connection candidate - start AP connection */ |
| if (BSS_INFRASTRUCTURE == pSme->pCandidate->bssType) |
| { |
| /* Start the AP connection */ |
| apConn_start (pSme->hApConn, |
| (pSme->tSsid.len != 0) && !OS_802_11_SSID_JUNK (pSme->tSsid.str, pSme->tSsid.len)); |
| } |
| |
| /* Set SCR group to connected */ |
| scr_setGroup (pSme->hScr, SCR_GID_CONNECTED); |
| } |
| |
| /** |
| * \fn smeSm_Disconnect |
| * \brief Starts a disconnect by calling the AP connection or connect modules |
| * |
| * Starts a disconnect by calling the AP connection or connect modules |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_DisconnectDone |
| */ |
| void smeSm_Disconnect (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| TI_STATUS tStatus; |
| |
| /* set the SCr group to connecting */ |
| scr_setGroup (pSme->hScr, SCR_GID_CONNECT); |
| |
| if (BSS_INFRASTRUCTURE == pSme->pCandidate->bssType) |
| { |
| /* Call the AP connection to perform disconnect */ |
| tStatus = apConn_stop (pSme->hApConn, TI_TRUE); |
| } |
| else |
| { |
| /* In IBSS disconnect is done directly with the connection SM */ |
| tStatus = conn_stop(pSme->hConn, DISCONNECT_DE_AUTH, STATUS_UNSPECIFIED, |
| TI_TRUE, sme_ReportConnStatus, hSme); |
| if (tStatus != TI_OK) |
| { |
| TRACE1(pSme->hReport, REPORT_SEVERITY_ERROR , "smeSm_Disconnect: conn_stop retruned %d\n", tStatus); |
| } |
| } |
| } |
| |
| /** |
| * \fn smeSm_DisconnectDone |
| * \brief Finish a disconnect process |
| * |
| * Finish a disconnect process by sending the appropriate event and restarting the state-machine |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_Disconnect |
| */ |
| void smeSm_DisconnectDone (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| OS_802_11_DISASSOCIATE_REASON_T tEventReason; |
| |
| if (TI_FALSE == pSme->bReselect) |
| { |
| /* send an event notifying the disassocation */ |
| if (TI_TRUE == pSme->bAuthSent) |
| { |
| tEventReason.eDisAssocType = SME_CONVERT_DISASSOC_CODES (pSme->tDisAssoc.eMgmtStatus); |
| tEventReason.uStatusCode = pSme->tDisAssoc.uStatusCode; |
| EvHandlerSendEvent (pSme->hEvHandler, IPC_EVENT_DISASSOCIATED, (TI_UINT8*)&tEventReason, |
| sizeof(OS_802_11_DISASSOCIATE_REASON_T)); |
| } |
| else if (CONNECT_MODE_AUTO != pSme->eLastConnectMode) |
| { |
| EvHandlerSendEvent (pSme->hEvHandler, IPC_EVENT_NOT_ASSOCIATED, NULL, 0); |
| } |
| } |
| |
| siteMgr_disSelectSite (pSme->hSiteMgr); |
| |
| /* try to reconnect */ |
| smeSm_Start (hSme); |
| } |
| |
| /** |
| * \fn smeSm_StopScan |
| * \brief Stops the SME scan operation |
| * |
| * Stops the SME scan operation |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_PreConnect, sme_StartScan |
| */ |
| void smeSm_StopScan (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| |
| scanCncn_StopPeriodicScan (pSme->hScanCncn, SCAN_SCC_DRIVER); |
| } |
| |
| /** |
| * \fn smeSm_StopConnect |
| * \brief Stops the connect module |
| * |
| * Stops the connect module (if the SME is stopped during a connect attempt |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_Connect |
| */ |
| void smeSm_StopConnect (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| TI_STATUS tStatus; |
| |
| tStatus = conn_stop (pSme->hConn, DISCONNECT_DE_AUTH, STATUS_UNSPECIFIED, |
| TI_TRUE, sme_ReportConnStatus, hSme); |
| |
| if (TI_OK != tStatus) |
| { |
| TRACE1(pSme->hReport, REPORT_SEVERITY_ERROR , "smeSm_StopConnect: conn_stop returned status %d\n", tStatus); |
| } |
| } |
| |
| /** |
| * \fn smeSm_ConnWhenConnecting |
| * \brief Starts the connect process again |
| * |
| * Starts the connect process again |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| * \sa smeSm_Connect |
| */ |
| void smeSm_ConnWhenConnecting (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| TI_STATUS tStatus; |
| |
| /* start the connection process */ |
| tStatus = conn_start (pSme->hConn, CONN_TYPE_FIRST_CONN, sme_ReportConnStatus, hSme, TI_FALSE, TI_FALSE); |
| if (TI_OK != tStatus) |
| { |
| TRACE1(pSme->hReport, REPORT_SEVERITY_ERROR , "smeSm_ConnWhenConnecting: conn_start returned status %d\n", tStatus); |
| } |
| } |
| |
| /** |
| * \fn smeSm_ActionUnexpected |
| * \brief Called when an unexpected event (for current state) is received |
| * |
| * Called when an unexpected event (for current state) is received |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| */ |
| void smeSm_ActionUnexpected (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| |
| TRACE0(pSme->hReport, REPORT_SEVERITY_ERROR , "smeSm_ActionUnexpected called\n"); |
| } |
| |
| /** |
| * \fn smeSm_NopAction |
| * \brief Called when event call and don't need to do nothing. |
| * |
| * \param hSme - handle to the SME object |
| * \return None |
| */ |
| void smeSm_NopAction (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| |
| TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "smeSm_NopAction called\n"); |
| } |
| |
| void smeSm_CheckStartConditions (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| |
| if ((TI_TRUE == pSme->bRunning) && (TI_TRUE == pSme->bRadioOn)) |
| { |
| /* send a start event */ |
| sme_SmEvent (pSme->hSmeSm, SME_SM_EVENT_START, hSme); |
| } |
| } |
| |
| |
| /* do we need to verify G only / A only / dual-band with site mgr? or rely on channels only? */ |
| |
| /** |
| * \fn sme_StartScan |
| * \brief Set scan parameters and calls scan concnetartor to start the scan operation. |
| * |
| * Set scan parameters and calls scan concnetartor to start the scan operation. |
| * |
| * Scan parameters are set according to scan target - find country IE, find desired SSID, or both |
| * (one on each band). To find country IE we use passive scan forever, to find the desired SSID we |
| * use active scan until the current country IE expires. In addition, we take into account the WSC PB |
| * mode - scan constantly for two minutes (but under the country validity and expiry constraints) |
| * |
| * \param hSme - handle to the SME object |
| * \return TI_OK if scan started successfully, TI_NOK otherwise |
| * \sa smeSm_PreConnect |
| */ |
| TI_STATUS sme_StartScan (TI_HANDLE hSme) |
| { |
| TSme *pSme = (TSme*)hSme; |
| paramInfo_t *pParam; |
| TI_BOOL bDEnabled, bCountryValid; |
| TI_BOOL bBandChannelExist[ RADIO_BAND_NUM_OF_BANDS ]; |
| TI_BOOL bBandCountryFound[ RADIO_BAND_NUM_OF_BANDS ]; |
| TI_STATUS tStatus; |
| TI_UINT32 uIndex; |
| |
| /* get 802.11d enable state */ |
| pParam = (paramInfo_t *)os_memoryAlloc(pSme->hOS, sizeof(paramInfo_t)); |
| if (!pParam) |
| { |
| return TI_NOK; |
| } |
| |
| pParam->paramType = REGULATORY_DOMAIN_ENABLED_PARAM; |
| regulatoryDomain_getParam (pSme->hRegDomain, pParam); |
| bDEnabled = pParam->content.regulatoryDomainEnabled; |
| |
| pParam->paramType = REGULATORY_DOMAIN_IS_COUNTRY_FOUND; |
| /* get country validity for all bands */ |
| for (uIndex = 0; uIndex < RADIO_BAND_NUM_OF_BANDS; uIndex++) |
| { |
| pParam->content.eRadioBand = (ERadioBand)uIndex; |
| regulatoryDomain_getParam (pSme->hRegDomain, pParam); |
| bBandCountryFound[ uIndex ] = pParam->content.bIsCountryFound; |
| /* also nullify the channel exist indication for this band */ |
| bBandChannelExist[ uIndex ] = TI_FALSE; |
| } |
| os_memoryFree(pSme->hOS, pParam, sizeof(paramInfo_t)); |
| |
| /* First fill the channels */ |
| for (uIndex = 0; uIndex < pSme->tInitParams.uChannelNum; uIndex++) |
| { |
| /* for each channel, if country is found, set active scan */ |
| pSme->tScanParams.tChannels[ uIndex ].eBand = pSme->tInitParams.tChannelList[ uIndex ].eBand; |
| pSme->tScanParams.tChannels[ uIndex ].uChannel = pSme->tInitParams.tChannelList[ uIndex ].uChannel; |
| pSme->tScanParams.tChannels[ uIndex ].uMaxDwellTimeMs = pSme->tInitParams.uMaxScanDuration; |
| pSme->tScanParams.tChannels[ uIndex ].uMinDwellTimeMs = pSme->tInitParams.uMinScanDuration; |
| pSme->tScanParams.tChannels[ uIndex ].uTxPowerLevelDbm = DEF_TX_POWER; |
| |
| /* if 802.11d is disabled, or country is available for this band */ |
| if ((TI_FALSE == bDEnabled) || |
| (TI_TRUE == bBandCountryFound[ pSme->tInitParams.tChannelList[ uIndex ].eBand ])) |
| { |
| /* set active scan */ |
| pSme->tScanParams.tChannels[ uIndex ].eScanType = SCAN_TYPE_NORMAL_ACTIVE; |
| } |
| /* 802.11d is enabled and no country available */ |
| else |
| { |
| /* set passive scan */ |
| pSme->tScanParams.tChannels[ uIndex ].eScanType = SCAN_TYPE_NORMAL_PASSIVE; |
| |
| /* |
| * in order to fined country set uMaxDwellTimeMs ( that at passive scan set the passiveScanDuration ) |
| * to significant value |
| */ |
| pSme->tScanParams.tChannels[ uIndex ].uMaxDwellTimeMs = SCAN_CNCN_REGULATORY_DOMAIN_PASSIVE_DWELL_TIME_DEF; |
| } |
| /* mark that a channel exists for this band */ |
| bBandChannelExist[ pSme->tInitParams.tChannelList[ uIndex ].eBand ] = TI_TRUE; |
| } |
| /* set number of channels */ |
| pSme->tScanParams.uChannelNum = pSme->tInitParams.uChannelNum; |
| |
| /* now, fill global parameters */ |
| pSme->tScanParams.uProbeRequestNum = pSme->tInitParams.uProbeReqNum; |
| pSme->tScanParams.iRssiThreshold = pSme->tInitParams.iRssiThreshold; |
| pSme->tScanParams.iSnrThreshold = pSme->tInitParams.iSnrThreshold; |
| pSme->tScanParams.bTerminateOnReport = TI_TRUE; |
| pSme->tScanParams.uFrameCountReportThreshold = 1; |
| |
| /* |
| * if for at least one band country is known and scan is performed on this band - means we need to |
| * take into consideration country expiry, plus we are scanning for the desired SSID |
| */ |
| bCountryValid = ((TI_TRUE == bBandChannelExist[ RADIO_BAND_2_4_GHZ ]) && (TI_TRUE == bBandCountryFound[ RADIO_BAND_2_4_GHZ ])) || |
| ((TI_TRUE == bBandChannelExist[ RADIO_BAND_5_0_GHZ ]) && (TI_TRUE == bBandCountryFound[ RADIO_BAND_5_0_GHZ ])); |
| |
| /* set SSID(s) and BSS type according to 802.11d status, and country availability */ |
| /* if 802.11d is disabled */ |
| if (TI_FALSE == bDEnabled) |
| { |
| pSme->tScanParams.eBssType = pSme->eBssType; |
| /* set the deisred SSID, or any SSID if this is the desired SSID */ |
| if (SSID_TYPE_ANY == pSme->eSsidType) |
| { |
| pSme->tScanParams.uSsidNum = 0; |
| pSme->tScanParams.uSsidListFilterEnabled = 1; |
| } |
| else |
| { |
| pSme->tScanParams.tDesiredSsid[ 0 ].eVisability = SCAN_SSID_VISABILITY_HIDDEN; |
| os_memoryCopy (pSme->hOS, &(pSme->tScanParams.tDesiredSsid[ 0 ].tSsid), &(pSme->tSsid), sizeof (TSsid)); |
| pSme->tScanParams.uSsidNum = 1; |
| pSme->tScanParams.uSsidListFilterEnabled = 1; |
| |
| #ifdef XCC_MODULE_INCLUDED |
| pSme->tScanParams.uSsidListFilterEnabled = (TI_UINT8)TI_FALSE; |
| pSme->tScanParams.uSsidNum = 2; |
| pSme->tScanParams.tDesiredSsid[ 1 ].tSsid.len = 0; |
| pSme->tScanParams.tDesiredSsid[ 1 ].eVisability = SCAN_SSID_VISABILITY_PUBLIC; |
| #endif |
| |
| } |
| } |
| /* Country code exists and scan is performed on this band - take country expiry timr into account */ |
| else if (TI_TRUE == bCountryValid) |
| { |
| TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "sme_StartScan: performing active scan to find desired SSID\n"); |
| |
| /* we already know that at least on one band we know the country IE, so we scan for our SSID */ |
| pSme->tScanParams.tDesiredSsid[ 0 ].eVisability = SCAN_SSID_VISABILITY_HIDDEN; |
| os_memoryCopy (pSme->hOS, &(pSme->tScanParams.tDesiredSsid[ 0 ].tSsid), &(pSme->tSsid), sizeof (TSsid)); |
| /* |
| * if, in addition, we scan the other band to find its country, and the desired SSDI is not any SSID, |
| * add an empty SSID |
| */ |
| if ((SSID_TYPE_ANY != pSme->eSsidType) && |
| (((TI_TRUE == bBandChannelExist[ RADIO_BAND_2_4_GHZ ]) && (TI_FALSE == bBandCountryFound[ RADIO_BAND_2_4_GHZ ])) || |
| ((TI_TRUE == bBandChannelExist[ RADIO_BAND_5_0_GHZ ]) && (TI_FALSE == bBandCountryFound[ RADIO_BAND_5_0_GHZ ])))) |
| { |
| pSme->tScanParams.tDesiredSsid[ 1 ].eVisability = SCAN_SSID_VISABILITY_PUBLIC; |
| pSme->tScanParams.tDesiredSsid[ 1 ].tSsid.len = 0; |
| pSme->tScanParams.uSsidNum = 2; |
| pSme->tScanParams.uSsidListFilterEnabled = 1; |
| /* |
| * since we are also looking for an AP with country IE (not include in IBSS), we need to make sure |
| * the desired BSS type include infrastructure BSSes. |
| */ |
| if (BSS_INDEPENDENT == pSme->eBssType) |
| { |
| /* the desired is only IBSS - scan for any */ |
| pSme->tScanParams.eBssType = BSS_ANY; |
| } |
| else |
| { |
| /* the desired is either infrastructure or any - use it */ |
| pSme->tScanParams.eBssType = pSme->eBssType; |
| } |
| } |
| else |
| { |
| pSme->tScanParams.uSsidNum = 1; |
| pSme->tScanParams.uSsidListFilterEnabled = 1; |
| /* only looking for the desired SSID - set the desired BSS type */ |
| pSme->tScanParams.eBssType = pSme->eBssType; |
| } |
| } |
| /* no scanned band has a counrty code - meaning all scan is passive (to find country) */ |
| else |
| { |
| TRACE0(pSme->hReport, REPORT_SEVERITY_INFORMATION , "sme_StartScan: performing passive scan to find country IE\n"); |
| pSme->tScanParams.eBssType = BSS_INFRASTRUCTURE; /* only an AP would transmit a country IE */ |
| pSme->tScanParams.uSsidNum = 0; |
| pSme->tScanParams.uSsidListFilterEnabled = 1; |
| } |
| |
| /* update scan cycle number and scan intervals according to 802.11d status and country availability */ |
| sme_updateScanCycles (hSme, bDEnabled, bCountryValid, pSme->bConstantScan); |
| |
| /* Finally(!!!), start the scan */ |
| tStatus = scanCncn_StartPeriodicScan (pSme->hScanCncn, SCAN_SCC_DRIVER, &(pSme->tScanParams)); |
| if (SCAN_CRS_SCAN_RUNNING != tStatus) |
| { |
| TRACE1(pSme->hReport, REPORT_SEVERITY_ERROR , "sme_StartScan: scan concentrator returned status %d\n", tStatus); |
| return TI_NOK; |
| } |
| |
| return TI_OK; |
| } |
| |
| /** |
| * \fn sme_updateScanCycles |
| * \brief Updates the scan intervals and cycle number according to 802.11d status, country availability and WSC PB mode |
| * |
| * Updates the scan intervals and cycle number according to 802.11d status, country availability and WSC PB mode. |
| * Possible scenarios - D disabled - WSC PB off - scan forever with supplied intervals |
| * - D enabled - country unknown - WSC PB off - scan forever with supplied intervals |
| * - D disabled - WSC PB on - scan for two minutes with zero intervals |
| * - D enabled - country unknown - WSC PB on - scan for two minutes with zero intervals |
| * - D enabled - country known - WSC PB off - scan until country expiry with supplied intervals |
| * - D enabled - country known - WSC PB on - scan for the minimu of two minutes and country expiry with zero intervals |
| * |
| * \param hSme - handle to the SME object |
| * \param bDEnabled - TRUE if 802.11d is enabled |
| * \param bCountryValid - TRUE if a country IE is valid for a band on which we scan |
| * \param bConstantScan - TRUE if WSC PB mode is on |
| * \return None |
| * \sa sme_CalculateCyclesNumber, sme_StartScan |
| */ |
| void sme_updateScanCycles (TI_HANDLE hSme, |
| TI_BOOL bDEnabled, |
| TI_BOOL bCountryValid, |
| TI_BOOL bConstantScan) |
| { |
| TSme *pSme = (TSme*)hSme; |
| TI_UINT32 uIndex, uScanPeriodMs, uScanDurationMs; |
| paramInfo_t *pParam; |
| |
| /* 802.11d is disabled, or no country is valid */ |
| if ((TI_FALSE == bDEnabled) || (TI_FALSE == bCountryValid)) |
| { |
| /* WSC PB mode is disabled */ |
| if (TI_FALSE == bConstantScan) |
| { |
| /* |
| * copy intervals |
| * In order to avoid tight loop of scan-select or scan-select-connecting operation, |
| * the prepare scan function takes into account the value of the scan_count when setting the 16 periods in the scan command |
| */ |
| os_memoryCopy (pSme->hOS, &(pSme->tScanParams.uCycleIntervalMsec[ 0 ]), |
| &(pSme->tInitParams.uScanIntervals[ pSme->uScanCount ]), sizeof (TI_UINT32) * (PERIODIC_SCAN_MAX_INTERVAL_NUM - pSme->uScanCount)); |
| |
| for(uIndex = (PERIODIC_SCAN_MAX_INTERVAL_NUM - pSme->uScanCount); uIndex < PERIODIC_SCAN_MAX_INTERVAL_NUM; uIndex++) |
| { |
| pSme->tScanParams.uCycleIntervalMsec[ uIndex ] = pSme->tInitParams.uScanIntervals[ PERIODIC_SCAN_MAX_INTERVAL_NUM - 1 ]; |
| } |
| |
| /* scan for default number (until a result is found) */ |
| pSme->tScanParams.uCycleNum = pSme->tInitParams.uCycleNum; |
| } |
| /* WSC PB mode is enabled */ |
| else |
| { |
| |
| /* nullify all intervals */ |
| os_memoryZero (pSme->hOS, &(pSme->tScanParams.uCycleIntervalMsec[ 0 ]), |
| sizeof (TI_UINT32) * PERIODIC_SCAN_MAX_INTERVAL_NUM); |
| |
| /* calculate the duration of one scan cycle */ |
| uScanDurationMs = 0; |
| for (uIndex = 0; uIndex < pSme->tScanParams.uChannelNum; uIndex++) |
| { |
| uScanDurationMs += pSme->tScanParams.tChannels[ uIndex ].uMaxDwellTimeMs; |
| } |
| |
| /* set the number of cycles - 2 minutes divided by one cycle duration */ |
| pSme->tScanParams.uCycleNum = (120000 / uScanDurationMs) + 1; |
| } |
| } |
| /* 802.11d is enabled, and country is valid on at least one band */ |
| else |
| { |
| pParam = (paramInfo_t *)os_memoryAlloc(pSme->hOS, sizeof(paramInfo_t)); |
| if (!pParam) |
| { |
| return; |
| } |
| |
| /* get country expiry time */ |
| pParam->paramType = REGULATORY_DOMAIN_TIME_TO_COUNTRY_EXPIRY; |
| regulatoryDomain_getParam (pSme->hRegDomain, pParam); |
| |
| /* WSC PB mode is disabled */ |
| if (TI_FALSE == bConstantScan) |
| { |
| /* |
| * copy intervals |
| * In order to avoid tight loop of scan-select or scan-select-connecting operation, |
| * the prepare scan function takes into account the value of the scan_count when setting the 16 periods in the scan command |
| */ |
| os_memoryCopy (pSme->hOS, &(pSme->tScanParams.uCycleIntervalMsec[ 0 ]), |
| &(pSme->tInitParams.uScanIntervals[ pSme->uScanCount ]), sizeof (TI_UINT32) * (PERIODIC_SCAN_MAX_INTERVAL_NUM - pSme->uScanCount)); |
| |
| for(uIndex = (PERIODIC_SCAN_MAX_INTERVAL_NUM - pSme->uScanCount); uIndex < PERIODIC_SCAN_MAX_INTERVAL_NUM; uIndex++) |
| { |
| pSme->tScanParams.uCycleIntervalMsec[ uIndex ] = pSme->tInitParams.uScanIntervals[ PERIODIC_SCAN_MAX_INTERVAL_NUM - 1 ]; |
| } |
| |
| /* set cycle number according to country expiry time */ |
| sme_CalculateCyclesNumber (hSme, pParam->content.uTimeToCountryExpiryMs); |
| } |
| /* WSC PB mode is enabled */ |
| else |
| { |
| /* turn off WSC PB mode (for next scan) */ |
| pSme->bConstantScan = TI_FALSE; |
| |
| /* set scan period to minimum of WSC PB duration (2 minutes) and country expiry time */ |
| uScanPeriodMs = TI_MIN (120000, pParam->content.uTimeToCountryExpiryMs); |
| |
| /* nullify all intervals */ |
| os_memoryZero (pSme->hOS, &(pSme->tScanParams.uCycleIntervalMsec[ 0 ]), |
| sizeof (TI_UINT32) * PERIODIC_SCAN_MAX_INTERVAL_NUM); |
| |
| /* calculate the duration of one scan cycle */ |
| uScanDurationMs = 0; |
| for (uIndex = 0; uIndex < pSme->tScanParams.uChannelNum; uIndex++) |
| { |
| uScanDurationMs += pSme->tScanParams.tChannels[ uIndex ].uMaxDwellTimeMs; |
| } |
| |
| if (uScanDurationMs != 0) |
| { |
| /* set the number of cycles - scan period divided by one cycle duration */ |
| pSme->tScanParams.uCycleNum = (uScanPeriodMs / uScanDurationMs) + 1; |
| } |
| else |
| { |
| pSme->tScanParams.uCycleNum = pSme->tInitParams.uCycleNum; |
| } |
| } |
| os_memoryFree(pSme->hOS, pParam, sizeof(paramInfo_t)); |
| } |
| |
| /* in case independent mode and to avoid supplicant send disconnect event after 60s */ |
| if (pSme->eBssType != BSS_INFRASTRUCTURE) |
| { |
| pSme->tScanParams.uCycleNum = 1; |
| } |
| } |
| |
| /** |
| * \fn sme_CalculateCyclesNumber |
| * \brief Calculates the cycle number required for a gicen time, according to scan intervals |
| * |
| * Calculates the cycle number required for a gicen time, according to scan intervals. First check the 16 |
| * different intervals, and if more time is available, find how many cycles still fit. Write the result |
| * to the SME scan command |
| * |
| * \param hSme - handle to the SME object |
| * \param uToTalTimeMs - the total periodic scan operation duartion |
| * \return None |
| * \sa sme_updateScanCycles, sme_StartScan |
| */ |
| void sme_CalculateCyclesNumber (TI_HANDLE hSme, TI_UINT32 uTotalTimeMs) |
| { |
| TSme *pSme = (TSme*)hSme; |
| TI_UINT32 uIndex, uCurrentTimeMs = 0; |
| |
| /* |
| * the total time should exceed country code expiration by one interval (so that next scan wouldn't |
| * have a valid country code) |
| */ |
| |
| /* nullify cycle number */ |
| pSme->tScanParams.uCycleNum = 0; |
| /* now find how many cycles fit within this time. First, check if all first 16 configured intervals fit */ |
| for (uIndex = 0; |
| (uIndex < PERIODIC_SCAN_MAX_INTERVAL_NUM) && (uCurrentTimeMs < uTotalTimeMs); |
| uIndex++) |
| { |
| pSme->tScanParams.uCycleNum++; |
| uCurrentTimeMs += pSme->tScanParams.uCycleIntervalMsec[ uIndex ]; |
| } |
| /* now find out how many more cycles with the last interval still fits */ |
| if (uCurrentTimeMs < uTotalTimeMs) |
| { |
| /* |
| * divide the reamining time (time until expiry minus the total time calculated so far) |
| * by the last interval time, to get how many more scans would fit after the first 16 intervals |
| */ |
| pSme->tScanParams.uCycleNum += (uTotalTimeMs - uCurrentTimeMs) / |
| pSme->tScanParams.uCycleIntervalMsec[ PERIODIC_SCAN_MAX_INTERVAL_NUM - 1]; |
| /* and add one, to compensate for the reminder */ |
| pSme->tScanParams.uCycleNum++; |
| } |
| } |
| |
