| /* |
| * roamingMngr_autoSM.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 roamingMngr_autoSM.c |
| * \brief Roaming Manager |
| * |
| * \see roamingMngr_autoSM.h |
| */ |
| |
| /**************************************************************************** |
| * * |
| * MODULE: Roaming Manager * |
| * PURPOSE: * |
| * Roaming manager is responsible to receive Roaming triggers and try |
| * to select a better AP. |
| * The Roaming triggers are: Low RSSI, PER, consecutive No ACK on TX, |
| * beacon Missed or External request. |
| * In each Internal Roaming request, scan is performed and selection for |
| * better AP. Better AP is defined as a different AP with better RSSI, |
| * and similar SSID and security settings. |
| * If better AP is found, there is a check for fast-roaming via the |
| * Supplicant. Then connection to the new AP is invoked. |
| * * |
| ****************************************************************************/ |
| |
| #define __FILE_ID__ FILE_ID_135 |
| #include "osApi.h" |
| |
| #include "paramOut.h" |
| #include "report.h" |
| #include "scanMngrApi.h" |
| #include "roamingMngrApi.h" |
| #include "apConnApi.h" |
| #include "roamingMngrTypes.h" |
| #include "bssTypes.h" |
| #include "DrvMainModules.h" |
| #include "TWDriver.h" |
| #include "siteMgrApi.h" |
| #include "GenSM.h" |
| #include "roamingMngr_autoSM.h" |
| |
| |
| /***************************************************************************** |
| ** Private Function section ** |
| *****************************************************************************/ |
| /* SM functions */ |
| |
| static void roamingMngr_smStartIdle(TI_HANDLE hRoamingMngr); |
| static void roamingMngr_smRoamTrigger(TI_HANDLE hRoamingMngr); |
| static void roamingMngr_smInvokeScan(TI_HANDLE hRoamingMngr); |
| static void roamingMngr_smSelection(TI_HANDLE hRoamingMngr); |
| static void roamingMngr_smHandover(TI_HANDLE hRoamingMngr); |
| static void roamingMngr_smSuccHandover(TI_HANDLE hRoamingMngr); |
| static void roamingMngr_smFailHandover(TI_HANDLE hRoamingMngr); |
| static void roamingMngr_smScanFailure(TI_HANDLE hRoamingMngr); |
| static void roamingMngr_smDisconnectWhileConnecting(TI_HANDLE hRoamingMngr); |
| |
| /*static TI_STATUS roamingMngr_smUnexpected(TI_HANDLE hRoamingMngr); |
| static TI_STATUS roamingMngr_smNop(TI_HANDLE hRoamingMngr); |
| static TI_STATUS roamingMngr_smStopWhileScanning(TI_HANDLE hRoamingMngr); |
| */ |
| |
| typedef enum |
| { |
| REASSOC_RESP_SUCCESS =0, |
| REASSOC_RESP_FAILURE, |
| REASSOC_RESP_REJECT |
| } reassociationResp_e; |
| |
| |
| /*-----------*/ |
| /* Constants */ |
| /*-----------*/ |
| |
| TGenSM_actionCell roamingMngrAuto_matrix[ROAMING_MNGR_NUM_STATES][ROAMING_MNGR_NUM_EVENTS] = |
| { |
| /* next state and actions for IDLE state */ |
| { {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smStartIdle}, /* START */ |
| {ROAMING_STATE_IDLE, roamingMngr_smNop}, /* STOP */ |
| {ROAMING_STATE_IDLE, roamingMngr_smNop}, /* ROAM_TRIGGER */ |
| {ROAMING_STATE_IDLE, roamingMngr_smUnexpected}, /* SCAN */ |
| {ROAMING_STATE_IDLE, roamingMngr_smUnexpected}, /* SELECT */ |
| {ROAMING_STATE_IDLE, roamingMngr_smUnexpected}, /* REQ_HANDOVER */ |
| {ROAMING_STATE_IDLE, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ |
| {ROAMING_STATE_IDLE, roamingMngr_smUnexpected} /* FAILURE */ |
| }, |
| |
| /* next state and actions for WAIT_4_TRIGGER state */ |
| { {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* START */ |
| {ROAMING_STATE_IDLE, roamingMngr_smStop}, /* STOP */ |
| {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smRoamTrigger}, /* ROAM_TRIGGER */ |
| {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* SCAN */ |
| {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* SELECT */ |
| {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* REQ_HANDOVER */ |
| {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ |
| {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected} /* FAILURE */ |
| }, |
| |
| /* next state and actions for WAIT_4_CMD state */ |
| { {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* START */ |
| {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* STOP */ |
| {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* ROAM_TRIGGER */ |
| {ROAMING_STATE_SCANNING, roamingMngr_smInvokeScan}, /* SCAN */ |
| {ROAMING_STATE_SELECTING, roamingMngr_smSelection}, /* SELECT */ |
| {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* REQ_HANDOVER */ |
| {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ |
| {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected} /* FAILURE */ |
| }, |
| |
| /* next state and actions for SCANNING state */ |
| { {ROAMING_STATE_SCANNING, roamingMngr_smUnexpected}, /* START */ |
| {ROAMING_STATE_IDLE, roamingMngr_smStopWhileScanning}, /* STOP */ |
| {ROAMING_STATE_SCANNING, roamingMngr_smNop}, /* ROAM_TRIGGER */ |
| {ROAMING_STATE_SCANNING, roamingMngr_smInvokeScan}, /* SCAN */ |
| {ROAMING_STATE_SELECTING, roamingMngr_smSelection}, /* SELECT */ |
| {ROAMING_STATE_SCANNING, roamingMngr_smUnexpected}, /* REQ_HANDOVER */ |
| {ROAMING_STATE_SCANNING, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ |
| {ROAMING_STATE_IDLE, roamingMngr_smScanFailure} /* FAILURE */ |
| |
| }, |
| |
| /* next state and actions for SELECTING state */ |
| { {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* START */ |
| {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* STOP */ |
| {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* ROAM_TRIGGER */ |
| {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* SCAN */ |
| {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* SELECT */ |
| {ROAMING_STATE_CONNECTING, roamingMngr_smHandover}, /* REQ_HANDOVER */ |
| {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ |
| {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected} /* FAILURE */ |
| |
| }, |
| |
| /* next state and actions for CONNECTING state */ |
| { {ROAMING_STATE_CONNECTING, roamingMngr_smUnexpected}, /* START */ |
| {ROAMING_STATE_IDLE, roamingMngr_smStop}, /* STOP */ |
| {ROAMING_STATE_IDLE, roamingMngr_smDisconnectWhileConnecting}, /* ROAM_TRIGGER */ |
| {ROAMING_STATE_CONNECTING, roamingMngr_smUnexpected}, /* SCAN, */ |
| {ROAMING_STATE_CONNECTING, roamingMngr_smUnexpected}, /* SELECT */ |
| {ROAMING_STATE_CONNECTING, roamingMngr_smHandover}, /* REQ_HANDOVER */ |
| {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smSuccHandover} , /* ROAM_SUCCESS */ |
| {ROAMING_STATE_IDLE, roamingMngr_smFailHandover} /* FAILURE */ |
| |
| } |
| }; |
| |
| |
| TI_INT8* AutoRoamStateDescription[] = |
| { |
| "IDLE", |
| "WAIT_4_TRIGGER", |
| "WAIT_4_CMD", |
| "SCANNING", |
| "SELECTING", |
| "CONNECTING" |
| }; |
| |
| TI_INT8* AutoRoamEventDescription[] = |
| { |
| "START", |
| "STOP", |
| "ROAM_TRIGGER", |
| "SCAN", |
| "SELECT", |
| "REQ_HANDOVER", |
| "ROAM_SUCCESS", |
| "FAILURE" |
| }; |
| |
| /** |
| * |
| * roamingMngr_smRoamTrigger |
| * |
| * \b Description: |
| * |
| * This procedure is called when an Roaming event occurs: BSS LOSS, LOW Quality etc. |
| * Performs the following: |
| * - If Roaming is disabled, ignore. |
| * - Indicate Driver that Roaming process is starting |
| * - Get the BSS list from the Scan Manager. |
| * - If the list is not empty, start SELECTION |
| * - If the list is empty, start SCANNING. The type of scan is decided |
| * according to the Neigbor APs existence. |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smRoamTrigger(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| roamingMngr_smEvents roamingEvent; |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smRoamTrigger, enableDisable = %d\n",pRoamingMngr->roamingMngrConfig.enableDisable); |
| |
| if (!pRoamingMngr->roamingMngrConfig.enableDisable) |
| { |
| /* Ignore any other Roaming event when Roaming is disabled */ |
| TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_ERROR, "roamingMngr_smRoamTrigger, when Roaming is disabled\n"); |
| return; |
| } |
| /* Indicate the driver that Roaming process is starting */ |
| apConn_prepareToRoaming(pRoamingMngr->hAPConnection, pRoamingMngr->roamingTrigger); |
| |
| /* Get the current BSSIDs from ScanMngr */ |
| pRoamingMngr->pListOfAPs = scanMngr_getBSSList(pRoamingMngr->hScanMngr); |
| if ((pRoamingMngr->pListOfAPs != NULL) && (pRoamingMngr->pListOfAPs->numOfEntries > 0)) |
| { /* No need to SCAN, start SELECTING */ |
| roamingEvent = ROAMING_EVENT_SELECT; |
| } |
| else |
| { /* check if list of APs exists in order to verify which scan to start */ |
| roamingEvent = ROAMING_EVENT_SCAN; |
| if (pRoamingMngr->neighborApsExist) |
| { /* Scan only Neighbor APs */ |
| pRoamingMngr->scanType = ROAMING_PARTIAL_SCAN; |
| } |
| else |
| { /* Scan all channels */ |
| pRoamingMngr->scanType = ROAMING_FULL_SCAN; |
| } |
| } |
| TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smRoamTrigger, scanType = %d\n", pRoamingMngr->scanType); |
| |
| roamingMngr_smEvent(roamingEvent, pRoamingMngr); |
| } |
| |
| /** |
| * |
| * roamingMngr_smInvokeScan |
| * |
| * \b Description: |
| * |
| * This procedure is called when scan should be performed in order |
| * to select an AP to roam to. |
| * This can be the first scan, a second scan after partail scan, |
| * or scan after previous scan was failed. |
| * In any case, the scan can either be: |
| * partail, on list of channles or |
| * full on all channels. |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smInvokeScan(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| scan_mngrResultStatus_e scanResult; |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| |
| /* check which scan should be performed: Partial on list of channels, or full scan */ |
| if ((pRoamingMngr->scanType == ROAMING_PARTIAL_SCAN) || |
| (pRoamingMngr->scanType == ROAMING_PARTIAL_SCAN_RETRY)) |
| { |
| scanResult = scanMngr_startImmediateScan (pRoamingMngr->hScanMngr, TI_TRUE); |
| } |
| else |
| { /* Scan all channels */ |
| scanResult = scanMngr_startImmediateScan (pRoamingMngr->hScanMngr, TI_FALSE); |
| } |
| |
| if (scanResult != SCAN_MRS_SCAN_RUNNING) |
| { /* the scan failed, immitate scan complete event */ |
| TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smInvokeScan, scanResult = %d\n", scanResult); |
| roamingMngr_immediateScanComplete(pRoamingMngr, scanResult); |
| } |
| } |
| |
| /** |
| * |
| * roamingMngr_smSelection |
| * |
| * \b Description: |
| * |
| * This procedure is called when selection should be performed. |
| * It perform the following: |
| * Prepare the candidate APs to roam according to: |
| * - Priority APs |
| * - Pre-Authenticated APs |
| * If the candidate AP list is empty, only the current AP can be re-selected |
| * Select one AP and trigger REQ_HANDOVER event. |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smSelection(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| TI_UINT32 index; |
| |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| pRoamingMngr->listOfCandidateAps.numOfNeighborBSS = 0; |
| pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS = 0; |
| pRoamingMngr->listOfCandidateAps.numOfRegularBSS = 0; |
| |
| pRoamingMngr->candidateApIndex = INVALID_CANDIDATE_INDEX; |
| |
| if ((pRoamingMngr->pListOfAPs == NULL) || |
| (pRoamingMngr->pListOfAPs->numOfEntries == 0)) |
| { /* Error, there cannot be selection */ |
| TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smSelection pListOfAPs is empty \n"); |
| roamingMngr_smEvent(ROAMING_EVENT_REQ_HANDOVER, pRoamingMngr); |
| return; |
| } |
| |
| /* Build the candidate AP list */ |
| for (index=0; index<pRoamingMngr->pListOfAPs->numOfEntries; index++ ) |
| { |
| if ( (pRoamingMngr->roamingTrigger <= ROAMING_TRIGGER_LOW_QUALITY_GROUP) && |
| (pRoamingMngr->pListOfAPs->BSSList[index].RSSI < pRoamingMngr->roamingMngrConfig.apQualityThreshold)) |
| { /* Do not insert APs with low quality to the selection table, |
| if the Roaming Trigger was low Quality */ |
| TRACE8(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "candidate AP %x-%x-%x-%x-%x-%x with RSSI too low =%d, Quality=%d \n", pRoamingMngr->pListOfAPs->BSSList[index].BSSID[0], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[1], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[2], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[3], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[4], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[5], pRoamingMngr->pListOfAPs->BSSList[index].RSSI, pRoamingMngr->roamingMngrConfig.apQualityThreshold); |
| |
| continue; |
| } |
| |
| if (apConn_isSiteBanned(pRoamingMngr->hAPConnection, &pRoamingMngr->pListOfAPs->BSSList[index].BSSID) == TI_TRUE) |
| { |
| TRACE6(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, ": Candidate AP %02X-%02X-%02X-%02X-%02X-%02X is banned!\n", pRoamingMngr->pListOfAPs->BSSList[index].BSSID[0], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[1], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[2], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[3], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[4], pRoamingMngr->pListOfAPs->BSSList[index].BSSID[5]); |
| continue; |
| } |
| |
| if (pRoamingMngr->pListOfAPs->BSSList[index].bNeighborAP) |
| { /* The AP is a neighbor AP, insert its index to the neighbor APs list */ |
| pRoamingMngr->listOfCandidateAps.neighborBSSList[pRoamingMngr->listOfCandidateAps.numOfNeighborBSS] = index; |
| pRoamingMngr->listOfCandidateAps.numOfNeighborBSS++; |
| } |
| else if (apConn_getPreAuthAPStatus(pRoamingMngr->hAPConnection, |
| &pRoamingMngr->pListOfAPs->BSSList[index].BSSID)) |
| { /* This AP is a pre-auth AP */ |
| pRoamingMngr->listOfCandidateAps.preAuthBSSList[pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS] = index; |
| pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS++; |
| } |
| else |
| { /* This AP is not Neighbor nor Pre-Auth */ |
| pRoamingMngr->listOfCandidateAps.regularBSSList[pRoamingMngr->listOfCandidateAps.numOfRegularBSS] = index; |
| pRoamingMngr->listOfCandidateAps.numOfRegularBSS++; |
| } |
| } |
| |
| #ifdef TI_DBG |
| { /* for debug */ |
| paramInfo_t param; |
| |
| param.paramType = ROAMING_MNGR_PRINT_CANDIDATE_TABLE; |
| roamingMngr_getParam(pRoamingMngr, ¶m); |
| |
| } |
| #endif |
| roamingMngr_smEvent(ROAMING_EVENT_REQ_HANDOVER, pRoamingMngr); |
| |
| } |
| |
| /** |
| * |
| * roamingMngr_smHandover |
| * |
| * \b Description: |
| * |
| * This procedure is called when handover should be invoked. |
| * Go over the candidate APs and start handover to each of them. |
| * If there's no candidate APs, disconnect. |
| * Handover to the current AP is allowed only if the trigger is |
| * low quality. |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smHandover(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| bssEntry_t *pApToConnect; |
| apConn_connRequest_t requestToApConn; |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| |
| if ((pRoamingMngr->handoverWasPerformed) && (pRoamingMngr->candidateApIndex == CURRENT_AP_INDEX)) |
| { /* Handover with the current AP already failed, Disconnect */ |
| roamingMngr_smEvent(ROAMING_EVENT_FAILURE, pRoamingMngr); |
| return; |
| } |
| if (pRoamingMngr->listOfCandidateAps.numOfNeighborBSS > 0) |
| { /* Neighbor APs are the highest priority to Roam */ |
| pRoamingMngr->candidateApIndex = |
| pRoamingMngr->listOfCandidateAps.neighborBSSList[pRoamingMngr->listOfCandidateAps.numOfNeighborBSS-1]; |
| pRoamingMngr->listOfCandidateAps.numOfNeighborBSS--; |
| } |
| else if (pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS > 0) |
| { /* Pre-Auth APs are the second priority to Roam */ |
| pRoamingMngr->candidateApIndex = |
| pRoamingMngr->listOfCandidateAps.preAuthBSSList[pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS-1]; |
| pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS--; |
| } |
| else if (pRoamingMngr->listOfCandidateAps.numOfRegularBSS > 0) |
| { /* Regular APs are APs that are not pre-authenticated and not Neighbor */ |
| pRoamingMngr->candidateApIndex = |
| pRoamingMngr->listOfCandidateAps.regularBSSList[pRoamingMngr->listOfCandidateAps.numOfRegularBSS-1]; |
| pRoamingMngr->listOfCandidateAps.numOfRegularBSS--; |
| } |
| else |
| { /* No Candidate APs */ |
| pRoamingMngr->candidateApIndex = INVALID_CANDIDATE_INDEX; |
| } |
| |
| TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smHandover, candidateApIndex=%d \n", pRoamingMngr->candidateApIndex); |
| |
| |
| if (pRoamingMngr->candidateApIndex == INVALID_CANDIDATE_INDEX) |
| { /* No cnadidate to Roam to, only the current AP is candidate */ |
| if (pRoamingMngr->roamingTrigger <= ROAMING_TRIGGER_LOW_QUALITY_GROUP) |
| { /* If the trigger to Roam is low quality, and there are no candidate APs |
| to roam to, retain connected to the current AP */ |
| requestToApConn.requestType = (pRoamingMngr->handoverWasPerformed) ? AP_CONNECT_RECONNECT_CURR_AP : AP_CONNECT_RETAIN_CURR_AP; |
| pRoamingMngr->candidateApIndex = CURRENT_AP_INDEX; |
| } |
| else |
| { /* Disconnect the BSS, there are no more APs to roam to */ |
| roamingMngr_smEvent(ROAMING_EVENT_FAILURE, pRoamingMngr); |
| return; |
| } |
| } |
| else |
| { /* There is a valid candidate AP */ |
| if (pRoamingMngr->roamingTrigger > ROAMING_TRIGGER_FAST_CONNECT_GROUP) |
| { /* Full re-connection should be perfromed */ |
| requestToApConn.requestType = AP_CONNECT_FULL_TO_AP; |
| } |
| else |
| { /* Fast re-connection should be perfromed */ |
| requestToApConn.requestType = AP_CONNECT_FAST_TO_AP; |
| } |
| } |
| #ifdef TI_DBG |
| /* For debug */ |
| if (!pRoamingMngr->handoverWasPerformed) |
| { /* Take the time before the first handover started */ |
| pRoamingMngr->roamingHandoverStartedTimestamp = os_timeStampMs(pRoamingMngr->hOs); |
| } |
| #endif |
| |
| if (pRoamingMngr->candidateApIndex == CURRENT_AP_INDEX) |
| { /* get the current AP */ |
| pApToConnect = apConn_getBSSParams(pRoamingMngr->hAPConnection); |
| } |
| else |
| { /* get the candidate AP */ |
| pRoamingMngr->handoverWasPerformed = TI_TRUE; |
| pApToConnect = &pRoamingMngr->pListOfAPs->BSSList[pRoamingMngr->candidateApIndex]; |
| } |
| TRACE3(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smHandover, candidateApIndex=%d, requestType = %d, channel=%d \n", pRoamingMngr->candidateApIndex, requestToApConn.requestType, pApToConnect->channel); |
| |
| requestToApConn.dataBufLength = 0; |
| |
| #ifdef XCC_MODULE_INCLUDED |
| apConn_connectToAP(pRoamingMngr->hAPConnection, pApToConnect, &requestToApConn, pRoamingMngr->bSendTspecInReassPkt); |
| #else |
| apConn_connectToAP(pRoamingMngr->hAPConnection, pApToConnect, &requestToApConn, TI_TRUE); |
| #endif |
| } |
| |
| /** |
| * |
| * roamingMngr_smDisconnectWhileConnecting |
| * |
| * \b Description: |
| * |
| * This procedure is called when the Station is in the process of connection, |
| * and the AP disconnects the station. |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smDisconnectWhileConnecting(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| |
| TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smDisconnectWhileConnecting, candidateApIndex=%d \n", pRoamingMngr->candidateApIndex); |
| |
| if (pRoamingMngr->roamingTrigger > ROAMING_TRIGGER_FAST_CONNECT_GROUP) |
| { /* If the trigger is from the Full Connect group, then stop the connection. */ |
| /* clean intenal variables */ |
| pRoamingMngr->maskRoamingEvents = TI_TRUE; |
| pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; |
| |
| scanMngr_stopContScan(pRoamingMngr->hScanMngr); |
| #ifdef TI_DBG |
| pRoamingMngr->roamingFailedHandoverNum++; |
| #endif |
| apConn_disconnect(pRoamingMngr->hAPConnection); |
| |
| } |
| } |
| |
| /** |
| * |
| * roamingMngr_smSuccHandover |
| * |
| * \b Description: |
| * |
| * This procedure is called when handover succeeded. |
| * Inform Scan Manager about the new AP. |
| * UnMask Roaming Triggers. |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smSuccHandover(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| bssEntry_t *pNewConnectedAp; |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| |
| TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smSuccHandover, candidateApIndex=%d \n", pRoamingMngr->candidateApIndex); |
| |
| if (pRoamingMngr->handoverWasPerformed && |
| (pRoamingMngr->pListOfAPs != NULL) && |
| (pRoamingMngr->pListOfAPs->numOfEntries>0)) |
| { |
| if (pRoamingMngr->candidateApIndex == CURRENT_AP_INDEX) |
| { |
| /* get the current AP */ |
| pNewConnectedAp = apConn_getBSSParams(pRoamingMngr->hAPConnection); |
| } |
| else |
| { |
| /* get the candidate AP */ |
| pNewConnectedAp = &pRoamingMngr->pListOfAPs->BSSList[pRoamingMngr->candidateApIndex]; |
| } |
| |
| scanMngr_handoverDone(pRoamingMngr->hScanMngr, |
| &pNewConnectedAp->BSSID, |
| pNewConnectedAp->band); |
| } |
| pRoamingMngr->maskRoamingEvents = TI_FALSE; |
| pRoamingMngr->candidateApIndex = INVALID_CANDIDATE_INDEX; |
| pRoamingMngr->handoverWasPerformed = TI_FALSE; |
| pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; |
| |
| /* Start pre-authentication in order to set PMKID |
| for the current AP */ |
| if (pRoamingMngr->staCapabilities.authMode==os802_11AuthModeWPA2) |
| { |
| /* No Pre-Auth is required */ |
| bssList_t *pBssList; |
| |
| pBssList = os_memoryAlloc(pRoamingMngr->hOs, sizeof(bssList_t)); |
| if (!pBssList) |
| { |
| return; |
| } |
| pBssList->numOfEntries = 0; |
| apConn_preAuthenticate(pRoamingMngr->hAPConnection, pBssList); |
| os_memoryFree(pRoamingMngr->hOs, pBssList, sizeof(bssList_t)); |
| } |
| } |
| |
| /** |
| * |
| * roamingMngr_smFailHandover |
| * |
| * \b Description: |
| * |
| * This procedure is called when handover failed and there are no more |
| * APs to roam to. Disconnect the BSS and retrun to IDLE state. |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smFailHandover(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smFailHandover \n"); |
| |
| /* clean intenal variables */ |
| pRoamingMngr->maskRoamingEvents = TI_TRUE; |
| pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; |
| |
| scanMngr_stopContScan(pRoamingMngr->hScanMngr); |
| #ifdef TI_DBG |
| pRoamingMngr->roamingFailedHandoverNum++; |
| #endif |
| apConn_disconnect(pRoamingMngr->hAPConnection); |
| } |
| |
| /** |
| * |
| * roamingMngr_smScanFailure |
| * |
| * \b Description: |
| * |
| * This procedure is called when all scan attempts failed. |
| * Send Disconnect event and return to IDLE state. |
| * |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smScanFailure(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smScanFailure \n"); |
| |
| /* clean intenal variables */ |
| pRoamingMngr->maskRoamingEvents = TI_TRUE; |
| pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; |
| |
| scanMngr_stopContScan(pRoamingMngr->hScanMngr); |
| |
| apConn_disconnect(pRoamingMngr->hAPConnection); |
| } |
| |
| #if 0 |
| /** |
| * |
| * roamingMngr_smCmdFailure |
| * |
| * \b Description: |
| * |
| * This procedure is called when all the driver failed to prepare to Roaming. |
| * Mask all future Roaming triggers. |
| * |
| * |
| * \b ARGS: |
| * |
| * I - hRoamingMngr - roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smCmdFailure(TI_HANDLE hRoamingMngr) |
| { |
| roamingMngr_t *pRoamingMngr; |
| |
| pRoamingMngr = (roamingMngr_t*)hRoamingMngr; |
| TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smCmdFailure \n"); |
| |
| /* clean intenal variables */ |
| pRoamingMngr->maskRoamingEvents = TI_TRUE; |
| pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; |
| } |
| #endif |
| |
| /** |
| * |
| * roamingMngr_smStartIdle - Start event when in Idle state |
| * |
| * \b Description: |
| * |
| * Start event when in Idle state. |
| * This function is called when the station becomes CONNECTED. |
| * Perform the following: |
| * - The current state becomes WAIT_4_TRIGGER |
| * - Unmask Roaming events |
| * - Set handoverWasPerformed to TI_FALSE |
| * - Start the Scan Manager |
| * |
| * \b ARGS: |
| * |
| * I - pData - pointer to the roamingMngr SM context \n |
| * |
| * \b RETURNS: |
| * |
| * TI_OK if successful, TI_NOK otherwise. |
| * |
| * |
| */ |
| static void roamingMngr_smStartIdle(void *pData) |
| { |
| roamingMngr_t *pRoamingMngr; |
| bssEntry_t *pCurBssEntry; |
| |
| pRoamingMngr = (roamingMngr_t*)pData; |
| TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smStartIdle, Unmask Roaming events and start continuos scan \n"); |
| |
| pRoamingMngr->maskRoamingEvents = TI_FALSE; |
| pRoamingMngr->handoverWasPerformed = TI_FALSE; |
| pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; |
| |
| pCurBssEntry = apConn_getBSSParams(pRoamingMngr->hAPConnection); |
| scanMngr_startContScan(pRoamingMngr->hScanMngr, &pCurBssEntry->BSSID, pCurBssEntry->band); |
| |
| /* Start pre-authentication in order to set PMKID |
| for the current AP */ |
| if (pRoamingMngr->staCapabilities.authMode==os802_11AuthModeWPA2) |
| { /* No Pre-Auth is required */ |
| bssList_t *pBssList; |
| |
| TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smStartIdle, Pre-Auth to cur AP\n"); |
| pBssList = os_memoryAlloc(pRoamingMngr->hOs, sizeof(bssList_t)); |
| if (!pBssList) |
| { |
| return; |
| } |
| |
| pBssList->numOfEntries = 0; |
| apConn_preAuthenticate(pRoamingMngr->hAPConnection, pBssList); |
| os_memoryFree(pRoamingMngr->hOs, pBssList, sizeof(bssList_t)); |
| } |
| } |
| |
