1 /* 2 * roamingMngr_autoSM.c 3 * 4 * Copyright(c) 1998 - 2009 Texas Instruments. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name Texas Instruments nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 /** \file roamingMngr_autoSM.c 35 * \brief Roaming Manager 36 * 37 * \see roamingMngr_autoSM.h 38 */ 39 40 /**************************************************************************** 41 * * 42 * MODULE: Roaming Manager * 43 * PURPOSE: * 44 * Roaming manager is responsible to receive Roaming triggers and try 45 * to select a better AP. 46 * The Roaming triggers are: Low RSSI, PER, consecutive No ACK on TX, 47 * beacon Missed or External request. 48 * In each Internal Roaming request, scan is performed and selection for 49 * better AP. Better AP is defined as a different AP with better RSSI, 50 * and similar SSID and security settings. 51 * If better AP is found, there is a check for fast-roaming via the 52 * Supplicant. Then connection to the new AP is invoked. 53 * * 54 ****************************************************************************/ 55 56 #define __FILE_ID__ FILE_ID_135 57 #include "osApi.h" 58 59 #include "paramOut.h" 60 #include "report.h" 61 #include "scanMngrApi.h" 62 #include "roamingMngrApi.h" 63 #include "apConnApi.h" 64 #include "roamingMngrTypes.h" 65 #include "bssTypes.h" 66 #include "DrvMainModules.h" 67 #include "TWDriver.h" 68 #include "siteMgrApi.h" 69 #include "GenSM.h" 70 #include "roamingMngr_autoSM.h" 71 72 73 /***************************************************************************** 74 ** Private Function section ** 75 *****************************************************************************/ 76 /* SM functions */ 77 78 static void roamingMngr_smStartIdle(TI_HANDLE hRoamingMngr); 79 static void roamingMngr_smRoamTrigger(TI_HANDLE hRoamingMngr); 80 static void roamingMngr_smInvokeScan(TI_HANDLE hRoamingMngr); 81 static void roamingMngr_smSelection(TI_HANDLE hRoamingMngr); 82 static void roamingMngr_smHandover(TI_HANDLE hRoamingMngr); 83 static void roamingMngr_smSuccHandover(TI_HANDLE hRoamingMngr); 84 static void roamingMngr_smFailHandover(TI_HANDLE hRoamingMngr); 85 static void roamingMngr_smScanFailure(TI_HANDLE hRoamingMngr); 86 static void roamingMngr_smDisconnectWhileConnecting(TI_HANDLE hRoamingMngr); 87 88 /*static TI_STATUS roamingMngr_smUnexpected(TI_HANDLE hRoamingMngr); 89 static TI_STATUS roamingMngr_smNop(TI_HANDLE hRoamingMngr); 90 static TI_STATUS roamingMngr_smStopWhileScanning(TI_HANDLE hRoamingMngr); 91 */ 92 93 typedef enum 94 { 95 REASSOC_RESP_SUCCESS =0, 96 REASSOC_RESP_FAILURE, 97 REASSOC_RESP_REJECT 98 } reassociationResp_e; 99 100 101 /*-----------*/ 102 /* Constants */ 103 /*-----------*/ 104 105 TGenSM_actionCell roamingMngrAuto_matrix[ROAMING_MNGR_NUM_STATES][ROAMING_MNGR_NUM_EVENTS] = 106 { 107 /* next state and actions for IDLE state */ 108 { {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smStartIdle}, /* START */ 109 {ROAMING_STATE_IDLE, roamingMngr_smNop}, /* STOP */ 110 {ROAMING_STATE_IDLE, roamingMngr_smNop}, /* ROAM_TRIGGER */ 111 {ROAMING_STATE_IDLE, roamingMngr_smUnexpected}, /* SCAN */ 112 {ROAMING_STATE_IDLE, roamingMngr_smUnexpected}, /* SELECT */ 113 {ROAMING_STATE_IDLE, roamingMngr_smUnexpected}, /* REQ_HANDOVER */ 114 {ROAMING_STATE_IDLE, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ 115 {ROAMING_STATE_IDLE, roamingMngr_smUnexpected} /* FAILURE */ 116 }, 117 118 /* next state and actions for WAIT_4_TRIGGER state */ 119 { {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* START */ 120 {ROAMING_STATE_IDLE, roamingMngr_smStop}, /* STOP */ 121 {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smRoamTrigger}, /* ROAM_TRIGGER */ 122 {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* SCAN */ 123 {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* SELECT */ 124 {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* REQ_HANDOVER */ 125 {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ 126 {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smUnexpected} /* FAILURE */ 127 }, 128 129 /* next state and actions for WAIT_4_CMD state */ 130 { {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* START */ 131 {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* STOP */ 132 {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* ROAM_TRIGGER */ 133 {ROAMING_STATE_SCANNING, roamingMngr_smInvokeScan}, /* SCAN */ 134 {ROAMING_STATE_SELECTING, roamingMngr_smSelection}, /* SELECT */ 135 {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* REQ_HANDOVER */ 136 {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ 137 {ROAMING_STATE_WAIT_4_CMD, roamingMngr_smUnexpected} /* FAILURE */ 138 }, 139 140 /* next state and actions for SCANNING state */ 141 { {ROAMING_STATE_SCANNING, roamingMngr_smUnexpected}, /* START */ 142 {ROAMING_STATE_IDLE, roamingMngr_smStopWhileScanning}, /* STOP */ 143 {ROAMING_STATE_SCANNING, roamingMngr_smNop}, /* ROAM_TRIGGER */ 144 {ROAMING_STATE_SCANNING, roamingMngr_smInvokeScan}, /* SCAN */ 145 {ROAMING_STATE_SELECTING, roamingMngr_smSelection}, /* SELECT */ 146 {ROAMING_STATE_SCANNING, roamingMngr_smUnexpected}, /* REQ_HANDOVER */ 147 {ROAMING_STATE_SCANNING, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ 148 {ROAMING_STATE_IDLE, roamingMngr_smScanFailure} /* FAILURE */ 149 150 }, 151 152 /* next state and actions for SELECTING state */ 153 { {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* START */ 154 {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* STOP */ 155 {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* ROAM_TRIGGER */ 156 {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* SCAN */ 157 {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* SELECT */ 158 {ROAMING_STATE_CONNECTING, roamingMngr_smHandover}, /* REQ_HANDOVER */ 159 {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected}, /* ROAM_SUCCESS */ 160 {ROAMING_STATE_SELECTING, roamingMngr_smUnexpected} /* FAILURE */ 161 162 }, 163 164 /* next state and actions for CONNECTING state */ 165 { {ROAMING_STATE_CONNECTING, roamingMngr_smUnexpected}, /* START */ 166 {ROAMING_STATE_IDLE, roamingMngr_smStop}, /* STOP */ 167 {ROAMING_STATE_IDLE, roamingMngr_smDisconnectWhileConnecting}, /* ROAM_TRIGGER */ 168 {ROAMING_STATE_CONNECTING, roamingMngr_smUnexpected}, /* SCAN, */ 169 {ROAMING_STATE_CONNECTING, roamingMngr_smUnexpected}, /* SELECT */ 170 {ROAMING_STATE_CONNECTING, roamingMngr_smHandover}, /* REQ_HANDOVER */ 171 {ROAMING_STATE_WAIT_4_TRIGGER, roamingMngr_smSuccHandover} , /* ROAM_SUCCESS */ 172 {ROAMING_STATE_IDLE, roamingMngr_smFailHandover} /* FAILURE */ 173 174 } 175 }; 176 177 178 TI_INT8* AutoRoamStateDescription[] = 179 { 180 "IDLE", 181 "WAIT_4_TRIGGER", 182 "WAIT_4_CMD", 183 "SCANNING", 184 "SELECTING", 185 "CONNECTING" 186 }; 187 188 TI_INT8* AutoRoamEventDescription[] = 189 { 190 "START", 191 "STOP", 192 "ROAM_TRIGGER", 193 "SCAN", 194 "SELECT", 195 "REQ_HANDOVER", 196 "ROAM_SUCCESS", 197 "FAILURE" 198 }; 199 200 /** 201 * 202 * roamingMngr_smRoamTrigger 203 * 204 * \b Description: 205 * 206 * This procedure is called when an Roaming event occurs: BSS LOSS, LOW Quality etc. 207 * Performs the following: 208 * - If Roaming is disabled, ignore. 209 * - Indicate Driver that Roaming process is starting 210 * - Get the BSS list from the Scan Manager. 211 * - If the list is not empty, start SELECTION 212 * - If the list is empty, start SCANNING. The type of scan is decided 213 * according to the Neigbor APs existence. 214 * 215 * \b ARGS: 216 * 217 * I - hRoamingMngr - roamingMngr SM context \n 218 * 219 * \b RETURNS: 220 * 221 * TI_OK if successful, TI_NOK otherwise. 222 * 223 * 224 */ 225 static void roamingMngr_smRoamTrigger(TI_HANDLE hRoamingMngr) 226 { 227 roamingMngr_t *pRoamingMngr; 228 roamingMngr_smEvents roamingEvent; 229 230 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 231 TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smRoamTrigger, enableDisable = %d\n",pRoamingMngr->roamingMngrConfig.enableDisable); 232 233 if (!pRoamingMngr->roamingMngrConfig.enableDisable) 234 { 235 /* Ignore any other Roaming event when Roaming is disabled */ 236 TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_ERROR, "roamingMngr_smRoamTrigger, when Roaming is disabled\n"); 237 return; 238 } 239 /* Indicate the driver that Roaming process is starting */ 240 apConn_prepareToRoaming(pRoamingMngr->hAPConnection, pRoamingMngr->roamingTrigger); 241 242 /* Get the current BSSIDs from ScanMngr */ 243 pRoamingMngr->pListOfAPs = scanMngr_getBSSList(pRoamingMngr->hScanMngr); 244 if ((pRoamingMngr->pListOfAPs != NULL) && (pRoamingMngr->pListOfAPs->numOfEntries > 0)) 245 { /* No need to SCAN, start SELECTING */ 246 roamingEvent = ROAMING_EVENT_SELECT; 247 } 248 else 249 { /* check if list of APs exists in order to verify which scan to start */ 250 roamingEvent = ROAMING_EVENT_SCAN; 251 if (pRoamingMngr->neighborApsExist) 252 { /* Scan only Neighbor APs */ 253 pRoamingMngr->scanType = ROAMING_PARTIAL_SCAN; 254 } 255 else 256 { /* Scan all channels */ 257 pRoamingMngr->scanType = ROAMING_FULL_SCAN; 258 } 259 } 260 TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smRoamTrigger, scanType = %d\n", pRoamingMngr->scanType); 261 262 roamingMngr_smEvent(roamingEvent, pRoamingMngr); 263 } 264 265 /** 266 * 267 * roamingMngr_smInvokeScan 268 * 269 * \b Description: 270 * 271 * This procedure is called when scan should be performed in order 272 * to select an AP to roam to. 273 * This can be the first scan, a second scan after partail scan, 274 * or scan after previous scan was failed. 275 * In any case, the scan can either be: 276 * partail, on list of channles or 277 * full on all channels. 278 * 279 * \b ARGS: 280 * 281 * I - hRoamingMngr - roamingMngr SM context \n 282 * 283 * \b RETURNS: 284 * 285 * TI_OK if successful, TI_NOK otherwise. 286 * 287 * 288 */ 289 static void roamingMngr_smInvokeScan(TI_HANDLE hRoamingMngr) 290 { 291 roamingMngr_t *pRoamingMngr; 292 scan_mngrResultStatus_e scanResult; 293 294 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 295 296 /* check which scan should be performed: Partial on list of channels, or full scan */ 297 if ((pRoamingMngr->scanType == ROAMING_PARTIAL_SCAN) || 298 (pRoamingMngr->scanType == ROAMING_PARTIAL_SCAN_RETRY)) 299 { 300 scanResult = scanMngr_startImmediateScan (pRoamingMngr->hScanMngr, TI_TRUE); 301 } 302 else 303 { /* Scan all channels */ 304 scanResult = scanMngr_startImmediateScan (pRoamingMngr->hScanMngr, TI_FALSE); 305 } 306 307 if (scanResult != SCAN_MRS_SCAN_RUNNING) 308 { /* the scan failed, immitate scan complete event */ 309 TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smInvokeScan, scanResult = %d\n", scanResult); 310 roamingMngr_immediateScanComplete(pRoamingMngr, scanResult); 311 } 312 } 313 314 /** 315 * 316 * roamingMngr_smSelection 317 * 318 * \b Description: 319 * 320 * This procedure is called when selection should be performed. 321 * It perform the following: 322 * Prepare the candidate APs to roam according to: 323 * - Priority APs 324 * - Pre-Authenticated APs 325 * If the candidate AP list is empty, only the current AP can be re-selected 326 * Select one AP and trigger REQ_HANDOVER event. 327 * 328 * \b ARGS: 329 * 330 * I - hRoamingMngr - roamingMngr SM context \n 331 * 332 * \b RETURNS: 333 * 334 * TI_OK if successful, TI_NOK otherwise. 335 * 336 * 337 */ 338 static void roamingMngr_smSelection(TI_HANDLE hRoamingMngr) 339 { 340 roamingMngr_t *pRoamingMngr; 341 TI_UINT32 index; 342 343 344 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 345 pRoamingMngr->listOfCandidateAps.numOfNeighborBSS = 0; 346 pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS = 0; 347 pRoamingMngr->listOfCandidateAps.numOfRegularBSS = 0; 348 349 pRoamingMngr->candidateApIndex = INVALID_CANDIDATE_INDEX; 350 351 if ((pRoamingMngr->pListOfAPs == NULL) || 352 (pRoamingMngr->pListOfAPs->numOfEntries == 0)) 353 { /* Error, there cannot be selection */ 354 TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smSelection pListOfAPs is empty \n"); 355 roamingMngr_smEvent(ROAMING_EVENT_REQ_HANDOVER, pRoamingMngr); 356 return; 357 } 358 359 /* Build the candidate AP list */ 360 for (index=0; index<pRoamingMngr->pListOfAPs->numOfEntries; index++ ) 361 { 362 if ( (pRoamingMngr->roamingTrigger <= ROAMING_TRIGGER_LOW_QUALITY_GROUP) && 363 (pRoamingMngr->pListOfAPs->BSSList[index].RSSI < pRoamingMngr->roamingMngrConfig.apQualityThreshold)) 364 { /* Do not insert APs with low quality to the selection table, 365 if the Roaming Trigger was low Quality */ 366 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); 367 368 continue; 369 } 370 371 if (apConn_isSiteBanned(pRoamingMngr->hAPConnection, &pRoamingMngr->pListOfAPs->BSSList[index].BSSID) == TI_TRUE) 372 { 373 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]); 374 continue; 375 } 376 377 if (pRoamingMngr->pListOfAPs->BSSList[index].bNeighborAP) 378 { /* The AP is a neighbor AP, insert its index to the neighbor APs list */ 379 pRoamingMngr->listOfCandidateAps.neighborBSSList[pRoamingMngr->listOfCandidateAps.numOfNeighborBSS] = index; 380 pRoamingMngr->listOfCandidateAps.numOfNeighborBSS++; 381 } 382 else if (apConn_getPreAuthAPStatus(pRoamingMngr->hAPConnection, 383 &pRoamingMngr->pListOfAPs->BSSList[index].BSSID)) 384 { /* This AP is a pre-auth AP */ 385 pRoamingMngr->listOfCandidateAps.preAuthBSSList[pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS] = index; 386 pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS++; 387 } 388 else 389 { /* This AP is not Neighbor nor Pre-Auth */ 390 pRoamingMngr->listOfCandidateAps.regularBSSList[pRoamingMngr->listOfCandidateAps.numOfRegularBSS] = index; 391 pRoamingMngr->listOfCandidateAps.numOfRegularBSS++; 392 } 393 } 394 395 #ifdef TI_DBG 396 { /* for debug */ 397 paramInfo_t param; 398 399 param.paramType = ROAMING_MNGR_PRINT_CANDIDATE_TABLE; 400 roamingMngr_getParam(pRoamingMngr, ¶m); 401 402 } 403 #endif 404 roamingMngr_smEvent(ROAMING_EVENT_REQ_HANDOVER, pRoamingMngr); 405 406 } 407 408 /** 409 * 410 * roamingMngr_smHandover 411 * 412 * \b Description: 413 * 414 * This procedure is called when handover should be invoked. 415 * Go over the candidate APs and start handover to each of them. 416 * If there's no candidate APs, disconnect. 417 * Handover to the current AP is allowed only if the trigger is 418 * low quality. 419 * 420 * \b ARGS: 421 * 422 * I - hRoamingMngr - roamingMngr SM context \n 423 * 424 * \b RETURNS: 425 * 426 * TI_OK if successful, TI_NOK otherwise. 427 * 428 * 429 */ 430 static void roamingMngr_smHandover(TI_HANDLE hRoamingMngr) 431 { 432 roamingMngr_t *pRoamingMngr; 433 bssEntry_t *pApToConnect; 434 apConn_connRequest_t requestToApConn; 435 436 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 437 438 if ((pRoamingMngr->handoverWasPerformed) && (pRoamingMngr->candidateApIndex == CURRENT_AP_INDEX)) 439 { /* Handover with the current AP already failed, Disconnect */ 440 roamingMngr_smEvent(ROAMING_EVENT_FAILURE, pRoamingMngr); 441 return; 442 } 443 if (pRoamingMngr->listOfCandidateAps.numOfNeighborBSS > 0) 444 { /* Neighbor APs are the highest priority to Roam */ 445 pRoamingMngr->candidateApIndex = 446 pRoamingMngr->listOfCandidateAps.neighborBSSList[pRoamingMngr->listOfCandidateAps.numOfNeighborBSS-1]; 447 pRoamingMngr->listOfCandidateAps.numOfNeighborBSS--; 448 } 449 else if (pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS > 0) 450 { /* Pre-Auth APs are the second priority to Roam */ 451 pRoamingMngr->candidateApIndex = 452 pRoamingMngr->listOfCandidateAps.preAuthBSSList[pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS-1]; 453 pRoamingMngr->listOfCandidateAps.numOfPreAuthBSS--; 454 } 455 else if (pRoamingMngr->listOfCandidateAps.numOfRegularBSS > 0) 456 { /* Regular APs are APs that are not pre-authenticated and not Neighbor */ 457 pRoamingMngr->candidateApIndex = 458 pRoamingMngr->listOfCandidateAps.regularBSSList[pRoamingMngr->listOfCandidateAps.numOfRegularBSS-1]; 459 pRoamingMngr->listOfCandidateAps.numOfRegularBSS--; 460 } 461 else 462 { /* No Candidate APs */ 463 pRoamingMngr->candidateApIndex = INVALID_CANDIDATE_INDEX; 464 } 465 466 TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smHandover, candidateApIndex=%d \n", pRoamingMngr->candidateApIndex); 467 468 469 if (pRoamingMngr->candidateApIndex == INVALID_CANDIDATE_INDEX) 470 { /* No cnadidate to Roam to, only the current AP is candidate */ 471 if (pRoamingMngr->roamingTrigger <= ROAMING_TRIGGER_LOW_QUALITY_GROUP) 472 { /* If the trigger to Roam is low quality, and there are no candidate APs 473 to roam to, retain connected to the current AP */ 474 requestToApConn.requestType = (pRoamingMngr->handoverWasPerformed) ? AP_CONNECT_RECONNECT_CURR_AP : AP_CONNECT_RETAIN_CURR_AP; 475 pRoamingMngr->candidateApIndex = CURRENT_AP_INDEX; 476 } 477 else 478 { /* Disconnect the BSS, there are no more APs to roam to */ 479 roamingMngr_smEvent(ROAMING_EVENT_FAILURE, pRoamingMngr); 480 return; 481 } 482 } 483 else 484 { /* There is a valid candidate AP */ 485 if (pRoamingMngr->roamingTrigger > ROAMING_TRIGGER_FAST_CONNECT_GROUP) 486 { /* Full re-connection should be perfromed */ 487 requestToApConn.requestType = AP_CONNECT_FULL_TO_AP; 488 } 489 else 490 { /* Fast re-connection should be perfromed */ 491 requestToApConn.requestType = AP_CONNECT_FAST_TO_AP; 492 } 493 } 494 #ifdef TI_DBG 495 /* For debug */ 496 if (!pRoamingMngr->handoverWasPerformed) 497 { /* Take the time before the first handover started */ 498 pRoamingMngr->roamingHandoverStartedTimestamp = os_timeStampMs(pRoamingMngr->hOs); 499 } 500 #endif 501 502 if (pRoamingMngr->candidateApIndex == CURRENT_AP_INDEX) 503 { /* get the current AP */ 504 pApToConnect = apConn_getBSSParams(pRoamingMngr->hAPConnection); 505 } 506 else 507 { /* get the candidate AP */ 508 pRoamingMngr->handoverWasPerformed = TI_TRUE; 509 pApToConnect = &pRoamingMngr->pListOfAPs->BSSList[pRoamingMngr->candidateApIndex]; 510 } 511 TRACE3(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smHandover, candidateApIndex=%d, requestType = %d, channel=%d \n", pRoamingMngr->candidateApIndex, requestToApConn.requestType, pApToConnect->channel); 512 513 requestToApConn.dataBufLength = 0; 514 apConn_connectToAP(pRoamingMngr->hAPConnection, pApToConnect, &requestToApConn, TI_TRUE); 515 } 516 517 /** 518 * 519 * roamingMngr_smDisconnectWhileConnecting 520 * 521 * \b Description: 522 * 523 * This procedure is called when the Station is in the process of connection, 524 * and the AP disconnects the station. 525 * 526 * \b ARGS: 527 * 528 * I - hRoamingMngr - roamingMngr SM context \n 529 * 530 * \b RETURNS: 531 * 532 * TI_OK if successful, TI_NOK otherwise. 533 * 534 * 535 */ 536 static void roamingMngr_smDisconnectWhileConnecting(TI_HANDLE hRoamingMngr) 537 { 538 roamingMngr_t *pRoamingMngr; 539 540 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 541 542 TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smDisconnectWhileConnecting, candidateApIndex=%d \n", pRoamingMngr->candidateApIndex); 543 544 if (pRoamingMngr->roamingTrigger > ROAMING_TRIGGER_FAST_CONNECT_GROUP) 545 { /* If the trigger is from the Full Connect group, then stop the connection. */ 546 /* clean intenal variables */ 547 pRoamingMngr->maskRoamingEvents = TI_TRUE; 548 pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; 549 550 scanMngr_stopContScan(pRoamingMngr->hScanMngr); 551 #ifdef TI_DBG 552 pRoamingMngr->roamingFailedHandoverNum++; 553 #endif 554 apConn_disconnect(pRoamingMngr->hAPConnection); 555 556 } 557 } 558 559 /** 560 * 561 * roamingMngr_smSuccHandover 562 * 563 * \b Description: 564 * 565 * This procedure is called when handover succeeded. 566 * Inform Scan Manager about the new AP. 567 * UnMask Roaming Triggers. 568 * 569 * \b ARGS: 570 * 571 * I - hRoamingMngr - roamingMngr SM context \n 572 * 573 * \b RETURNS: 574 * 575 * TI_OK if successful, TI_NOK otherwise. 576 * 577 * 578 */ 579 static void roamingMngr_smSuccHandover(TI_HANDLE hRoamingMngr) 580 { 581 roamingMngr_t *pRoamingMngr; 582 bssEntry_t *pNewConnectedAp; 583 584 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 585 586 TRACE1(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smSuccHandover, candidateApIndex=%d \n", pRoamingMngr->candidateApIndex); 587 588 if (pRoamingMngr->handoverWasPerformed && 589 (pRoamingMngr->pListOfAPs != NULL) && 590 (pRoamingMngr->pListOfAPs->numOfEntries>0)) 591 { 592 if (pRoamingMngr->candidateApIndex == CURRENT_AP_INDEX) 593 { 594 /* get the current AP */ 595 pNewConnectedAp = apConn_getBSSParams(pRoamingMngr->hAPConnection); 596 } 597 else 598 { 599 /* get the candidate AP */ 600 pNewConnectedAp = &pRoamingMngr->pListOfAPs->BSSList[pRoamingMngr->candidateApIndex]; 601 } 602 603 scanMngr_handoverDone(pRoamingMngr->hScanMngr, 604 &pNewConnectedAp->BSSID, 605 pNewConnectedAp->band); 606 } 607 pRoamingMngr->maskRoamingEvents = TI_FALSE; 608 pRoamingMngr->candidateApIndex = INVALID_CANDIDATE_INDEX; 609 pRoamingMngr->handoverWasPerformed = TI_FALSE; 610 pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; 611 612 /* Start pre-authentication in order to set PMKID 613 for the current AP */ 614 if (pRoamingMngr->staCapabilities.authMode==os802_11AuthModeWPA2) 615 { 616 /* No Pre-Auth is required */ 617 bssList_t *pBssList; 618 619 TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smStartIdle, Pre-Auth to cur AP\n"); 620 pBssList = os_memoryAlloc(pRoamingMngr->hOs, sizeof(bssList_t)); 621 if (!pBssList) 622 return; 623 pBssList->numOfEntries = 0; 624 apConn_preAuthenticate(pRoamingMngr->hAPConnection, pBssList); 625 os_memoryFree(pRoamingMngr->hOs, pBssList, sizeof(bssList_t)); 626 } 627 } 628 629 /** 630 * 631 * roamingMngr_smFailHandover 632 * 633 * \b Description: 634 * 635 * This procedure is called when handover failed and there are no more 636 * APs to roam to. Disconnect the BSS and retrun to IDLE state. 637 * 638 * \b ARGS: 639 * 640 * I - hRoamingMngr - roamingMngr SM context \n 641 * 642 * \b RETURNS: 643 * 644 * TI_OK if successful, TI_NOK otherwise. 645 * 646 * 647 */ 648 static void roamingMngr_smFailHandover(TI_HANDLE hRoamingMngr) 649 { 650 roamingMngr_t *pRoamingMngr; 651 652 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 653 TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smFailHandover \n"); 654 655 /* clean intenal variables */ 656 pRoamingMngr->maskRoamingEvents = TI_TRUE; 657 pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; 658 659 scanMngr_stopContScan(pRoamingMngr->hScanMngr); 660 #ifdef TI_DBG 661 pRoamingMngr->roamingFailedHandoverNum++; 662 #endif 663 apConn_disconnect(pRoamingMngr->hAPConnection); 664 } 665 666 /** 667 * 668 * roamingMngr_smScanFailure 669 * 670 * \b Description: 671 * 672 * This procedure is called when all scan attempts failed. 673 * Send Disconnect event and return to IDLE state. 674 * 675 * 676 * \b ARGS: 677 * 678 * I - hRoamingMngr - roamingMngr SM context \n 679 * 680 * \b RETURNS: 681 * 682 * TI_OK if successful, TI_NOK otherwise. 683 * 684 * 685 */ 686 static void roamingMngr_smScanFailure(TI_HANDLE hRoamingMngr) 687 { 688 roamingMngr_t *pRoamingMngr; 689 690 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 691 TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smScanFailure \n"); 692 693 /* clean intenal variables */ 694 pRoamingMngr->maskRoamingEvents = TI_TRUE; 695 pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; 696 697 scanMngr_stopContScan(pRoamingMngr->hScanMngr); 698 699 apConn_disconnect(pRoamingMngr->hAPConnection); 700 } 701 702 #if 0 703 /** 704 * 705 * roamingMngr_smCmdFailure 706 * 707 * \b Description: 708 * 709 * This procedure is called when all the driver failed to prepare to Roaming. 710 * Mask all future Roaming triggers. 711 * 712 * 713 * \b ARGS: 714 * 715 * I - hRoamingMngr - roamingMngr SM context \n 716 * 717 * \b RETURNS: 718 * 719 * TI_OK if successful, TI_NOK otherwise. 720 * 721 * 722 */ 723 static void roamingMngr_smCmdFailure(TI_HANDLE hRoamingMngr) 724 { 725 roamingMngr_t *pRoamingMngr; 726 727 pRoamingMngr = (roamingMngr_t*)hRoamingMngr; 728 TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smCmdFailure \n"); 729 730 /* clean intenal variables */ 731 pRoamingMngr->maskRoamingEvents = TI_TRUE; 732 pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; 733 } 734 #endif 735 736 /** 737 * 738 * roamingMngr_smStartIdle - Start event when in Idle state 739 * 740 * \b Description: 741 * 742 * Start event when in Idle state. 743 * This function is called when the station becomes CONNECTED. 744 * Perform the following: 745 * - The current state becomes WAIT_4_TRIGGER 746 * - Unmask Roaming events 747 * - Set handoverWasPerformed to TI_FALSE 748 * - Start the Scan Manager 749 * 750 * \b ARGS: 751 * 752 * I - pData - pointer to the roamingMngr SM context \n 753 * 754 * \b RETURNS: 755 * 756 * TI_OK if successful, TI_NOK otherwise. 757 * 758 * 759 */ 760 static void roamingMngr_smStartIdle(void *pData) 761 { 762 roamingMngr_t *pRoamingMngr; 763 bssEntry_t *pCurBssEntry; 764 765 pRoamingMngr = (roamingMngr_t*)pData; 766 TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smStartIdle, Unmask Roaming events and start continuos scan \n"); 767 768 pRoamingMngr->maskRoamingEvents = TI_FALSE; 769 pRoamingMngr->handoverWasPerformed = TI_FALSE; 770 pRoamingMngr->roamingTrigger = ROAMING_TRIGGER_NONE; 771 772 pCurBssEntry = apConn_getBSSParams(pRoamingMngr->hAPConnection); 773 scanMngr_startContScan(pRoamingMngr->hScanMngr, &pCurBssEntry->BSSID, pCurBssEntry->band); 774 775 /* Start pre-authentication in order to set PMKID 776 for the current AP */ 777 if (pRoamingMngr->staCapabilities.authMode==os802_11AuthModeWPA2) 778 { /* No Pre-Auth is required */ 779 bssList_t *pBssList; 780 781 TRACE0(pRoamingMngr->hReport, REPORT_SEVERITY_INFORMATION, "roamingMngr_smStartIdle, Pre-Auth to cur AP\n"); 782 pBssList = os_memoryAlloc(pRoamingMngr->hOs, sizeof(bssList_t)); 783 if (!pBssList) 784 return; 785 786 pBssList->numOfEntries = 0; 787 apConn_preAuthenticate(pRoamingMngr->hAPConnection, pBssList); 788 os_memoryFree(pRoamingMngr->hOs, pBssList, sizeof(bssList_t)); 789 } 790 } 791 792
