1 /****************************************************************************
2 **+-----------------------------------------------------------------------+**
3 **| |**
4 **| Copyright(c) 1998 - 2008 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 ****************************************************************************/
35
36
37 /** \file smeSm.c
38 * \brief SME SM implementation
39 *
40 * \see smeSm.h
41 */
42
43 #include "osTIType.h"
44 #include "osApi.h"
45 #include "paramOut.h"
46 #include "paramIn.h"
47 #include "srcApi.h"
48 #include "report.h"
49 #include "connApi.h"
50 #include "siteMgrApi.h"
51 #include "smeSmApi.h"
52 #include "utils.h"
53 #include "fsm.h"
54 #include "smeSm.h"
55 #include "smeApi.h"
56 #include "DataCtrl_Api.h"
57 #include "regulatoryDomainApi.h"
58 #include "TrafficMonitorAPI.h"
59 #include "PowerMgr_API.h"
60 #include "EvHandler.h"
61 #include "TI_IPC_Api.h"
62 #include "ScanCncnApi.h"
63 #ifdef EXC_MODULE_INCLUDED
64 #include "DataCtrl_Api.h"
65 #endif
66 #include "apConn.h"
67
68
69 /* State Machine Functions */
70 static TI_STATUS idle_to_interScan(void *pData);
71
72 static TI_STATUS interScan_to_scanning(void *pData);
73
74 static TI_STATUS interScan_to_idle(void *pData);
75
76 static TI_STATUS scan_to_idle(void *pData);
77
78 static TI_STATUS scan_to_scan(void *pData);
79
80 static TI_STATUS scan_to_select(void *pData);
81
82 static TI_STATUS scan_to_interScan(void *pData);
83
84 static TI_STATUS select_to_InterScan(void *pData);
85
86 static TI_STATUS select_to_connect(void *pData);
87
88 static TI_STATUS connecting_To_Disconnecting(void *pData);
89
90 static TI_STATUS connecting_to_connected(void *pData);
91
92 static TI_STATUS connecting_to_selecting(void *pData);
93
94 static TI_STATUS connected_to_interScan(void *pData);
95
96 static TI_STATUS connected_To_disconnecting(void *pData);
97
98 static TI_STATUS disconnecting_to_interScan(void *pData);
99
100
101 /* Local functions prototypes */
102 static TI_STATUS actionUnexpected(void *pData);
103
104 static TI_STATUS actionNop(void *pData);
105
106 static TI_STATUS smeCallScan(void *pData);
107
108 static TI_STATUS chooseScanBand(smeSm_t* pSmeSm, radioBand_e *band);
109
110 static TI_STATUS smeSm_changeBandParams(TI_HANDLE hSmeSm, radioBand_e radioBand);
111
112 static TI_STATUS smeSm_startInterScanTimeout(TI_HANDLE hSmeSm);
113
114 static TI_STATUS smeSm_stopInterScanTimeout(TI_HANDLE hSmeSm);
115
116 static void smeSm_sendDisassociateEvent(smeSm_t* pSmeSm);
117
118 /****************************************************/
119 /* Interface Functions Implementations */
120 /****************************************************/
121
122
123 /***********************************************************************
124 * smeSm_smCreate
125 ***********************************************************************
126 DESCRIPTION: State machine creation function, called by the SME SM API. Allocates the state machine
127
128 INPUT: hOs - OS handle.
129
130 OUTPUT:
131
132 RETURN: State machine pointer on success, NULL otherwise
133
134 ************************************************************************/
smeSm_smCreate(TI_HANDLE hOs)135 fsm_stateMachine_t *smeSm_smCreate(TI_HANDLE hOs)
136 {
137 TI_STATUS status;
138 fsm_stateMachine_t *pFsm;
139
140 status = fsm_Create(hOs, &pFsm, SME_SM_NUM_STATES, SME_SM_NUM_EVENTS);
141
142 if (status != OK)
143 return NULL;
144
145 return pFsm;
146 }
147
148 /***********************************************************************
149 * smeSm_smConfig
150 ***********************************************************************
151 DESCRIPTION: State machine configuration function, called by the SME SM API. Configures the state machine
152
153 INPUT: pSmeSm - SME SM handle.
154
155 OUTPUT:
156
157 RETURN: OK on success, NOK otherwise
158
159 ************************************************************************/
smeSm_smConfig(smeSm_t * pSmeSm)160 TI_STATUS smeSm_smConfig(smeSm_t *pSmeSm)
161 {
162 paramInfo_t param;
163
164 fsm_actionCell_t smMatrix[SME_SM_NUM_STATES][SME_SM_NUM_EVENTS] =
165 {
166 /* next state and actions for IDLE state */
167 {
168 {SME_SM_STATE_INTER_SCAN, idle_to_interScan}, /* "EVENT_START", */
169 {SME_SM_STATE_IDLE, actionUnexpected}, /* "EVENT_STOP", */
170 {SME_SM_STATE_IDLE, actionUnexpected}, /* "EVENT_SCAN_COMPLETE", */
171 {SME_SM_STATE_IDLE, actionUnexpected}, /* "EVENT_SELECT_SUCCESS", */
172 {SME_SM_STATE_IDLE, actionUnexpected}, /* "EVENT_SELECT_FAILURE", */
173 {SME_SM_STATE_IDLE, actionUnexpected}, /* "EVENT_CONN_SUCCESS", */
174 {SME_SM_STATE_IDLE, actionUnexpected}, /* "EVENT_CONN_FAILURE", */
175 {SME_SM_STATE_IDLE, actionNop}, /* "EVENT_RESELECT", */
176 {SME_SM_STATE_IDLE, actionNop}, /* "EVENT_DISCONNECT"*/
177 },
178
179 /* next state and actions for SCANNING state */
180 {
181 {SME_SM_STATE_SCANNING, actionUnexpected}, /* "EVENT_START", */
182 {SME_SM_STATE_IDLE, scan_to_idle}, /* "EVENT_STOP", */
183 {SME_SM_STATE_SELECTING, scan_to_select}, /* "EVENT_SCAN_COMPLETE", */
184 {SME_SM_STATE_SCANNING, actionUnexpected}, /* "EVENT_SELECT_SUCCESS", */
185 {SME_SM_STATE_SCANNING, actionUnexpected}, /* "EVENT_SELECT_FAILURE", */
186 {SME_SM_STATE_SCANNING, actionUnexpected}, /* "EVENT_CONN_SUCCESS", */
187 {SME_SM_STATE_SCANNING, actionUnexpected}, /* "EVENT_CONN_FAILURE", */
188 {SME_SM_STATE_SCANNING, scan_to_scan}, /* "EVENT_RESELECT",*/
189 {SME_SM_STATE_INTER_SCAN, scan_to_interScan}, /* "EVENT_DISCONNECT"*/
190 },
191
192 /* next state and actions for SELECTING state */
193 {
194 {SME_SM_STATE_SELECTING, actionUnexpected}, /* "EVENT_START", */
195 {SME_SM_STATE_SELECTING, actionUnexpected}, /* "EVENT_STOP", */
196 {SME_SM_STATE_SELECTING, actionUnexpected}, /* "EVENT_SCAN_COMPLETE", */
197 {SME_SM_STATE_CONNECTING, select_to_connect}, /* "EVENT_SELECT_SUCCESS", */
198 {SME_SM_STATE_INTER_SCAN, select_to_InterScan}, /* "EVENT_SELECT_FAILURE", */
199 {SME_SM_STATE_SELECTING, actionUnexpected}, /* "EVENT_CONN_SUCCESS", */
200 {SME_SM_STATE_SELECTING, actionUnexpected}, /* "EVENT_CONN_FAILURE", */
201 {SME_SM_STATE_SELECTING, actionUnexpected}, /* "EVENT_RESELECT", */
202 {SME_SM_STATE_SELECTING, actionUnexpected}, /* "EVENT_DISCONNECT",*/
203 },
204
205 /* next state and actions for CONNECTING state */
206 {
207 {SME_SM_STATE_SCANNING, actionUnexpected}, /* "EVENT_START", */
208 {SME_SM_STATE_DISCONNECTING, connecting_To_Disconnecting}, /* "EVENT_STOP", */
209 {SME_SM_STATE_CONNECTING, actionUnexpected}, /* "EVENT_SCAN_COMPLETE", */
210 {SME_SM_STATE_CONNECTING, actionUnexpected}, /* "EVENT_SELECT_SUCCESS", */
211 {SME_SM_STATE_CONNECTING, actionUnexpected}, /* "EVENT_SELECT_FAILURE", */
212 {SME_SM_STATE_CONNECTED, connecting_to_connected}, /* "EVENT_CONN_SUCCESS", */
213 {SME_SM_STATE_SELECTING, connecting_to_selecting}, /* "EVENT_CONN_FAILURE", */
214 {SME_SM_STATE_DISCONNECTING, connecting_To_Disconnecting}, /* "EVENT_RESELECT", */
215 {SME_SM_STATE_DISCONNECTING, connecting_To_Disconnecting}, /* "EVENT_DISCONNECT", */
216 },
217
218 /* next state and actions for CONNECTED state */
219 {
220 {SME_SM_STATE_SCANNING, actionUnexpected}, /* "EVENT_START", */
221 {SME_SM_STATE_DISCONNECTING, connected_To_disconnecting}, /* "EVENT_STOP", */
222 {SME_SM_STATE_CONNECTED, actionUnexpected}, /* "EVENT_SCAN_COMPLETE", */
223 {SME_SM_STATE_CONNECTED, actionUnexpected}, /* "EVENT_SELECT_SUCCESS", */
224 {SME_SM_STATE_CONNECTED, actionUnexpected}, /* "EVENT_SELECT_FAILURE", */
225 {SME_SM_STATE_CONNECTED, actionUnexpected}, /* "EVENT_CONN_SUCCESS", */
226 {SME_SM_STATE_INTER_SCAN, connected_to_interScan}, /* "EVENT_CONN_FAILURE", */
227 {SME_SM_STATE_DISCONNECTING, connected_To_disconnecting}, /* "EVENT_RESELECT", */
228 {SME_SM_STATE_DISCONNECTING ,connected_To_disconnecting}, /* "EVENT_DISCONNECT",*/
229 },
230
231 /* next state and actions for DISCONNECTING state */
232 {
233 {SME_SM_STATE_DISCONNECTING, actionNop}, /* "EVENT_START", */
234 {SME_SM_STATE_DISCONNECTING, actionNop}, /* "EVENT_STOP", */
235 {SME_SM_STATE_DISCONNECTING, actionUnexpected}, /* "EVENT_SCAN_COMPLETE", */
236 {SME_SM_STATE_DISCONNECTING, actionUnexpected}, /* "EVENT_SELECT_SUCCESS", */
237 {SME_SM_STATE_DISCONNECTING, actionUnexpected}, /* "EVENT_SELECT_FAILURE", */
238 {SME_SM_STATE_DISCONNECTING, actionUnexpected}, /* "EVENT_CONN_SUCCESS", */
239 {SME_SM_STATE_INTER_SCAN, disconnecting_to_interScan}, /* "EVENT_CONN_FAILURE", */
240 {SME_SM_STATE_DISCONNECTING, actionNop}, /* "EVENT_RESELECT", */
241 {SME_SM_STATE_DISCONNECTING, actionNop}, /* "EVENT_DISCONNECT",*/
242 },
243
244
245 /* next state and actions for STATE_INTER_SCAN_TIMEOUT state */
246 {
247 {SME_SM_STATE_INTER_SCAN, actionUnexpected}, /* "EVENT_START", */
248 {SME_SM_STATE_IDLE, interScan_to_idle}, /* "EVENT_STOP", */
249 {SME_SM_STATE_INTER_SCAN, actionUnexpected}, /* "EVENT_SCAN_COMPLETE", */
250 {SME_SM_STATE_INTER_SCAN, actionUnexpected}, /* "EVENT_SELECT_SUCCESS", */
251 {SME_SM_STATE_INTER_SCAN, actionUnexpected}, /* "EVENT_SELECT_FAILURE", */
252 {SME_SM_STATE_INTER_SCAN, actionUnexpected}, /* "EVENT_CONN_SUCCESS", */
253 {SME_SM_STATE_INTER_SCAN, actionUnexpected}, /* "EVENT_CONN_FAILURE", */
254 {SME_SM_STATE_SCANNING, interScan_to_scanning}, /* "EVENT_RESELECT", */
255 {SME_SM_STATE_INTER_SCAN, actionNop}, /* "EVENT_DISCONNECT",*/
256 },
257
258 };
259
260 pSmeSm->dualBandReScanFlag = FALSE;
261 pSmeSm->reScanFlag = FALSE;
262 pSmeSm->radioOn = FALSE;
263 pSmeSm->immediateShutdownRequired = FALSE;
264
265 /* if desired SSID is junk SSID, don't connect (until new SSID is set) */
266 param.paramType = SITE_MGR_DESIRED_SSID_PARAM;
267 siteMgr_getParam( pSmeSm->hSiteMgr, ¶m );
268
269 if ( utils_isJunkSSID( &(param.content.siteMgrDesiredSSID) ) )
270 {
271 pSmeSm->connectEnabled = FALSE;
272 }
273 else
274 {
275 pSmeSm->connectEnabled = TRUE;
276 }
277
278 /* First event should indicate to the upper layer that STA is disassociated. */
279 pSmeSm->DisAssoc.mgmtStatus = STATUS_UNSPECIFIED;
280 pSmeSm->DisAssoc.uStatusCode = 0;
281 smeSm_sendDisassociateEvent(pSmeSm);
282
283 #ifdef TI_DBG
284 /* clear statistics */
285 smeSm_resetStats( (TI_HANDLE)pSmeSm );
286 #endif
287
288 return fsm_Config(pSmeSm->pFsm, (fsm_Matrix_t)smMatrix, SME_SM_NUM_STATES, SME_SM_NUM_EVENTS, smeSm_SMEvent, pSmeSm->hOs);
289 }
290
291 /***********************************************************************
292 * smeSm_smUnLoad
293 ***********************************************************************
294 DESCRIPTION: State machine unload function, called by the SME SM API. Unloads the state machine
295
296 INPUT: hOs - OS handle.
297 pFsm - Pointer to the state machine
298
299 OUTPUT:
300
301 RETURN: State machine pointer on success, NULL otherwise
302
303 ************************************************************************/
smeSm_smUnLoad(TI_HANDLE hOs,fsm_stateMachine_t * pFsm)304 TI_STATUS smeSm_smUnLoad(TI_HANDLE hOs, fsm_stateMachine_t *pFsm)
305 {
306 fsm_Unload(hOs, pFsm);
307
308 return OK;
309 }
310
311 /***********************************************************************
312 * smeSm_SMEvent
313 ***********************************************************************
314 DESCRIPTION: SME SM event processing function, called by the SME SM API
315 Perform the following:
316 - Print the state movement as a result from the event
317 - Calls the generic state machine event processing function which preform the following:
318 - Calls the corresponding callback function
319 - Move to next state
320
321 INPUT: currentState - Pointer to the connection current state.
322 event - Received event
323 pSmeSm - SME SM handle
324
325 OUTPUT:
326
327 RETURN: OK on success, NOK otherwise
328
329 ************************************************************************/
330
331 #ifdef REPORT_LOG
332
333 static char *stateDesc[SME_SM_NUM_STATES] =
334 {
335 "STATE_IDLE",
336 "STATE_SCANNING",
337 "STATE_SELECTING",
338 "STATE_CONNECTING",
339 "STATE_CONNECTED",
340 "STATE_DISCONNECTING",
341 "STATE_INTER_SCAN",
342 };
343
344 static char *eventDesc[SME_SM_NUM_EVENTS] =
345 {
346 "EVENT_START",
347 "EVENT_STOP",
348 "EVENT_SCAN_COMPLETE",
349 "EVENT_SELECT_SUCCESS",
350 "EVENT_SELECT_FAILURE",
351 "EVENT_CONN_SUCCESS",
352 "EVENT_CONN_FAILURE",
353 "EVENT_RESELECT",
354 "EVENT_DISCONNECT",
355 };
356
357 #endif
358
359
smeSm_SMEvent(UINT8 * currentState,UINT8 event,TI_HANDLE hSmeSm)360 TI_STATUS smeSm_SMEvent(UINT8 *currentState, UINT8 event, TI_HANDLE hSmeSm)
361 {
362 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm;
363 TI_STATUS status;
364 UINT8 nextState;
365
366 status = fsm_GetNextState(pSmeSm->pFsm, *currentState, event, &nextState);
367 if (status != OK)
368 {
369 WLAN_REPORT_SM(pSmeSm->hReport, SME_SM_MODULE_LOG, ("State machine error, failed getting next state\n"));
370 return(NOK);
371 }
372
373 WLAN_REPORT_SM(pSmeSm->hReport, SME_SM_MODULE_LOG,
374 ("<%s, %s> --> %s\n\n",
375 stateDesc[*currentState],
376 eventDesc[event],
377 stateDesc[nextState]));
378
379 status = fsm_Event(pSmeSm->pFsm, currentState, event, (void *)pSmeSm);
380
381 return status;
382 }
383
384
385 /************************************************************************************************************/
386 /* In the following section are listed the callback function used by the SME state machine */
387 /************************************************************************************************************/
388
389 /* START_SCAN */
sme_startScan(void * pData)390 TI_STATUS sme_startScan(void *pData)
391 {
392 paramInfo_t param;
393 smeSm_t *pSmeSm = (smeSm_t *)pData;
394
395 /*
396 * Support Dual Mode Operation
397 */
398
399 radioBand_e band;
400
401 /*
402 * If scan is disabled then send self scan complete event, skipping the scan procedure.
403 */
404 if (pSmeSm->scanEnabled != SCAN_ENABLED)
405 {
406 if (pSmeSm->scanEnabled == SKIP_NEXT_SCAN)
407 {
408 pSmeSm->scanEnabled = SCAN_ENABLED;
409 }
410 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_SCAN_COMPLETE , pSmeSm);
411 }
412
413
414 /* if performing a dual band rescan now */
415 if ( TRUE == pSmeSm->dualBandReScanFlag )
416 {
417 /* mark that no more scans are needed */
418 pSmeSm->dualBandReScanFlag = FALSE;
419 chooseScanBand(pSmeSm, &band);
420 smeSm_changeBandParams(pSmeSm, band);
421 }
422 else
423 {
424 param.paramType = SITE_MGR_DESIRED_DOT11_MODE_PARAM;
425 siteMgr_getParam(pSmeSm->hSiteMgr, ¶m);
426
427 if(param.content.siteMgrDot11Mode == DOT11_DUAL_MODE)
428 {
429 pSmeSm->dualBandReScanFlag = TRUE;
430 chooseScanBand(pSmeSm, &band);
431 smeSm_changeBandParams(pSmeSm, band);
432 }
433 }
434
435 return smeCallScan(pData);
436 }
437
438
439 /* RESTART_SCAN when exiting from IDLE state*/
idle_to_interScan(void * pData)440 static TI_STATUS idle_to_interScan(void *pData)
441 {
442 smeSm_t *pSmeSm = (smeSm_t *)pData;
443
444 pSmeSm->interScanTimeout = pSmeSm->interScanTimeoutMin;
445
446 /* Set the SCR group to inter SCAN */
447 scr_setGroup( pSmeSm->hScr, SCR_GID_INTER_SCAN );
448
449 /*
450 * If the connection is enabled then initiate "reselect" event that moves the
451 * SM into scan state.
452 */
453 if( pSmeSm->connectEnabled ){
454 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_RESELECT , pSmeSm);
455 }
456 /* connectEnabled is FALSE, need to stay at this state until it will be changed. */
457
458 return OK;
459 }
460
461
462
interScan_to_scanning(void * pData)463 TI_STATUS interScan_to_scanning(void *pData)
464 {
465 smeSm_t *pSmeSm = (smeSm_t *)pData;
466
467 pSmeSm->bSendDisAssocEvent = FALSE;
468
469 smeSm_stopInterScanTimeout(pSmeSm);
470
471 /* Set SCR to "first connection" */
472 scr_setGroup( pSmeSm->hScr, SCR_GID_CONNECT );
473
474 #ifdef TI_DBG
475 /* update statistics - count scan attempts for connection */
476 pSmeSm->smeStats.currentNumberOfScanAttempts++;
477 #endif
478 return (sme_startScan(pData));
479 }
480
481
482
disconnecting_to_interScan(void * pData)483 static TI_STATUS disconnecting_to_interScan(void *pData)
484 {
485 smeSm_t *pSmeSm = (smeSm_t *)pData;
486
487 pSmeSm->interScanTimeout = pSmeSm->interScanTimeoutMin;
488
489 scr_setGroup( pSmeSm->hScr, SCR_GID_INTER_SCAN );
490
491 siteMgr_disSelectSite(pSmeSm->hSiteMgr);
492
493 /*
494 * Notify that the driver is disassociated to the supplicant\IP stack.
495 */
496 smeSm_sendDisassociateEvent(pSmeSm);
497
498 if (!pSmeSm->scanEnabled)
499 {
500 pSmeSm->connectEnabled = FALSE;
501 }
502
503 /* Radio ON and connection is enabled go to scanning */
504 if( pSmeSm->radioOn )
505 {
506 if( pSmeSm->connectEnabled )
507 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_RESELECT , pSmeSm);
508
509 else {
510 /* Radio is on but connection is disabled, stay at interScan state
511 without starting the interscan timer. */
512
513 /* SCR is set to enable only APP scan */
514 return OK;
515 }
516 }
517
518 else{
519 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_STOP , pSmeSm);
520 }
521 }
522
523
connected_to_interScan(void * pData)524 static TI_STATUS connected_to_interScan(void *pData)
525 {
526 smeSm_t *pSmeSm = (smeSm_t *)pData;
527
528 pSmeSm->interScanTimeout = pSmeSm->interScanTimeoutMin;
529
530 siteMgr_disSelectSite(pSmeSm->hSiteMgr);
531
532 scr_setGroup( pSmeSm->hScr, SCR_GID_INTER_SCAN );
533
534 /*
535 * Notify that the driver is associated to the supplicant\IP stack.
536 */
537 smeSm_sendDisassociateEvent(pSmeSm);
538
539 if (!pSmeSm->scanEnabled)
540 {
541 pSmeSm->connectEnabled = FALSE;
542 }
543
544 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_RESELECT , pSmeSm);
545 }
546
547
select_to_InterScan(void * pData)548 static TI_STATUS select_to_InterScan(void *pData)
549 {
550 smeSm_t *pSmeSm = (smeSm_t *)pData;
551
552 siteMgr_disSelectSite(pSmeSm->hSiteMgr);
553
554 /* SCR is set to enable only APP scan */
555 scr_setGroup( pSmeSm->hScr, SCR_GID_INTER_SCAN );
556
557 if (pSmeSm->connectEnabled)
558 {
559 smeSm_startInterScanTimeout(pSmeSm);
560 }
561
562 if ((pSmeSm->bSendDisAssocEvent == TRUE) || (pSmeSm->scanEnabled == FALSE))
563 {
564 /*
565 * Notify that the driver is disassociated to the supplicant\IP stack.
566 */
567 smeSm_sendDisassociateEvent(pSmeSm);
568 }
569
570 return OK;
571 }
572
573
574
scan_to_interScan(void * pData)575 static TI_STATUS scan_to_interScan(void *pData)
576 {
577 smeSm_t *pSmeSm = (smeSm_t *)pData;
578
579 /* SCR is set to enable only APP scan */
580 scr_setGroup( pSmeSm->hScr, SCR_GID_INTER_SCAN );
581
582 pSmeSm->interScanTimeout = pSmeSm->interScanTimeoutMin;
583
584 if (pSmeSm->connectEnabled)
585 {
586 smeSm_startInterScanTimeout(pSmeSm);
587 }
588
589 return OK;
590
591 }
592
593
594 /* STOP_SCAN, START_SCAN */
scan_to_scan(void * pData)595 static TI_STATUS scan_to_scan(void *pData)
596 {
597 smeSm_t *pSmeSm = (smeSm_t *)pData;
598
599 WLAN_REPORT_INFORMATION(pSmeSm->hReport, SME_SM_MODULE_LOG, ("Setting reScanFlag to ON\n"));
600
601 pSmeSm->reScanFlag = TRUE;
602
603 scanConcentrator_stopScan( pSmeSm->hScanCncn, SCAN_SCC_DRIVER );
604
605 return OK;
606 }
607
608
609
610 /* CANCEL INTER_SCAN TIMEOUT*/
interScan_to_idle(void * pData)611 static TI_STATUS interScan_to_idle(void *pData)
612 {
613 smeSm_t *pSmeSm = (smeSm_t *)pData;
614
615 smeSm_stopInterScanTimeout(pSmeSm);
616
617 /* Change shutdown status flag to indicate SME is in IDLE state */
618 pSmeSm->shutDownStatus |= DRIVER_SHUTDOWN_SME_STOPPED;
619
620 /* Set SCR state to "Idle" */
621 scr_setGroup( pSmeSm->hScr, SCR_GID_IDLE );
622
623 return OK;
624
625 }
626
627
628 /* Stop current scanning and go to idle */
scan_to_idle(void * pData)629 static TI_STATUS scan_to_idle(void *pData)
630 {
631 smeSm_t *pSmeSm = (smeSm_t *)pData;
632
633 /* stopping the current active scan process */
634 scanConcentrator_stopScan( pSmeSm->hScanCncn, SCAN_SCC_DRIVER );
635
636 /* Change shutdown status flag to indicate SME is in IDLE state */
637 pSmeSm->shutDownStatus |= DRIVER_SHUTDOWN_SME_STOPPED;
638
639 /* Set the SCR group to "idle" */
640 scr_setGroup( pSmeSm->hScr, SCR_GID_IDLE );
641
642 return OK;
643 }
644
645 /* SELECT */
scan_to_select(void * pData)646 static TI_STATUS scan_to_select(void *pData)
647 {
648 smeSm_t *pSmeSm = (smeSm_t *)pData;
649
650 if (!pSmeSm->connectEnabled)
651 {
652 return smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_SELECT_FAILURE, pSmeSm);
653 }
654
655 siteMgr_resetAttemptsNumberParameter(pSmeSm->hSiteMgr);
656
657 return siteMgr_selectSite(pSmeSm->hSiteMgr);
658 }
659
660
661
662 /* START_TX, CONNECT */
select_to_connect(void * pData)663 static TI_STATUS select_to_connect(void *pData)
664 {
665 smeSm_t *pSmeSm = (smeSm_t *)pData;
666 paramInfo_t param;
667
668 /* From this moment forward we will send DisAssociation event even if the connection failed */
669 pSmeSm->bSendDisAssocEvent = TRUE;
670
671 /* if we are about o start an IBSS, the conn SM will wait for few seconds before sending connection
672 failure indication, so that the SME will rescan for IBSSes with the same SSID. To enable application
673 scan during this period, in this case ONLY we change here the SCR group ID to inter scan */
674 param.paramType = CONN_TYPE_PARAM;
675 conn_getParam(pSmeSm->hConn, ¶m);
676 if (CONNECTION_SELF == param.content.connType)
677 {
678 /* Set SCR group to inter-scan */
679 scr_setGroup( pSmeSm->hScr, SCR_GID_INTER_SCAN );
680 }
681
682 /* Configure QoS manager not to renegotiate TSPECs as this is first time connection */
683 return conn_start(pSmeSm->hConn, CONN_TYPE_FIRST_CONN, smeSm_reportConnStatus, pSmeSm, FALSE, FALSE);
684 }
685
686
687
688
689 /* Stop the connecting and go to disconnecting */
connecting_To_Disconnecting(void * pData)690 static TI_STATUS connecting_To_Disconnecting(void *pData)
691 {
692 smeSm_t *pSmeSm = (smeSm_t *)pData;
693
694 conn_stop(pSmeSm->hConn, DISCONN_TYPE_DEAUTH, STATUS_UNSPECIFIED,
695 TRUE, smeSm_reportConnStatus, pSmeSm);
696
697 return OK;
698 }
699
700
701 /* Stop the connection and go to disconnecting */
connected_To_disconnecting(void * pData)702 static TI_STATUS connected_To_disconnecting(void *pData)
703 {
704 TI_STATUS status;
705 paramInfo_t param;
706 smeSm_t *pSmeSm = (smeSm_t *)pData;
707
708 scr_setGroup( pSmeSm->hScr, SCR_GID_CONNECT );
709
710 param.paramType = SITE_MGR_CURRENT_BSS_TYPE_PARAM;
711 siteMgr_getParam(pSmeSm->hSiteMgr, ¶m);
712
713 if(param.content.siteMgrDesiredBSSType == BSS_INFRASTRUCTURE)
714 {
715 /* Call the AP connection to perform disconnect - If immidiateShutdownRequired is TRUE, no need to send DISASSOC frame */
716 status = apConn_stop(pSmeSm->hApConn, TRUE, pSmeSm->immediateShutdownRequired);
717 }
718 else
719 {
720 /* In IBSS disconnect is done directly with the connection SM */
721 status = conn_stop(pSmeSm->hConn, DISCONN_TYPE_DEAUTH, STATUS_UNSPECIFIED,
722 TRUE, smeSm_reportConnStatus,pSmeSm);
723 if (status != OK)
724 {
725 WLAN_REPORT_ERROR(pSmeSm->hReport, SME_SM_MODULE_LOG, ("SME status=%d, have to return (%d)\n",status,__LINE__));
726 return status;
727 }
728 }
729
730
731 return OK;
732 }
733
734 /* RESET_ATTEMPTS_NUMBER, START_SITE_AGING, START_DATA_ALGO */
735 /* CONNECTING -> CONNECTED due to event CONN_SUCC */
connecting_to_connected(void * pData)736 static TI_STATUS connecting_to_connected(void *pData)
737 {
738 TI_STATUS status;
739 paramInfo_t param;
740
741 smeSm_t *pSmeSm = (smeSm_t *)pData;
742
743 /* Reset the DisAssociation reason since the SME saves that last reason, and if a new connection was made and than aborted by
744 unspecified reason - no one will clear this value */
745 pSmeSm->DisAssoc.mgmtStatus = STATUS_UNSPECIFIED;
746 pSmeSm->DisAssoc.uStatusCode = 0;
747
748 status = siteMgr_resetPrevPrimarySiteRssi(pSmeSm->hSiteMgr);
749 if (status != OK)
750 {
751 WLAN_REPORT_ERROR(pSmeSm->hReport, SME_SM_MODULE_LOG, ("SME status=%d, have to return (%d)\n",status,__LINE__));
752 return status;
753 }
754
755 status = siteMgr_resetPrimarySiteAttemptsNumber(pSmeSm->hSiteMgr);
756 if (status != OK)
757 {
758 WLAN_REPORT_ERROR(pSmeSm->hReport, SME_SM_MODULE_LOG, ("SME status=%d, have to return (%d)\n",status,__LINE__));
759 return status;
760 }
761
762 status = siteMgr_resetEventStatisticsHistory(pSmeSm->hSiteMgr);
763 if (status != OK)
764 {
765 WLAN_REPORT_ERROR(pSmeSm->hReport, SME_SM_MODULE_LOG, ("SME status=%d, have to return (%d)\n",status,__LINE__));
766 return status;
767 }
768
769
770 param.paramType = SITE_MGR_CURRENT_BSS_TYPE_PARAM;
771 siteMgr_getParam(pSmeSm->hSiteMgr, ¶m);
772 if (param.content.siteMgrDesiredBSSType == BSS_INFRASTRUCTURE)
773 {
774 /* Start the AP connection */
775 apConn_start(pSmeSm->hApConn, siteMgr_isThereValidSSID(pSmeSm->hSiteMgr));
776 }
777
778 /* Set SCR group to connected */
779 scr_setGroup( pSmeSm->hScr, SCR_GID_CONNECTED );
780
781 #ifdef TI_DBG
782 /* update statistics - scan attempts for connection histogran */
783 if ( SCAN_ATTAMEPTS_HISTOGRAM_SIZE < pSmeSm->smeStats.currentNumberOfScanAttempts )
784 {
785 pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ SCAN_ATTAMEPTS_HISTOGRAM_SIZE - 1 ]++;
786 }
787 else
788 {
789 pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ pSmeSm->smeStats.currentNumberOfScanAttempts - 1 ]++;
790 }
791 pSmeSm->smeStats.currentNumberOfScanAttempts = 0;
792 #endif
793 return OK;
794 }
795
796
797
798 /* STOP_RX, STOP_TX, UPDATE_PRIMARY_SITE_FAIL_STATUS, */
connecting_to_selecting(void * pData)799 static TI_STATUS connecting_to_selecting(void *pData)
800 {
801 TI_STATUS status;
802 paramInfo_t param;
803 smeSm_t *pSmeSm = (smeSm_t *)pData;
804
805 conn_stop(pSmeSm->hConn, DISCONN_TYPE_IMMEDIATE, STATUS_UNSPECIFIED,
806 TRUE, smeSm_reportConnStatus,pSmeSm);
807
808 /* Remove primary site */
809 status = siteMgr_updatePrimarySiteFailStatus(pSmeSm->hSiteMgr, TRUE);
810 if (status != OK)
811 {
812 WLAN_REPORT_ERROR(pSmeSm->hReport, SME_SM_MODULE_LOG, ("SME status=%d, have to return (%d)\n",status,__LINE__));
813 return status;
814 }
815
816 status = siteMgr_disSelectSite(pSmeSm->hSiteMgr);
817 if (status != OK)
818 {
819 WLAN_REPORT_ERROR(pSmeSm->hReport, SME_SM_MODULE_LOG, ("SME status=%d, have to return (%d)\n",status,__LINE__));
820 return status;
821 }
822
823 /* If we are in IBSS mode we don't try to select another site */
824 param.paramType = SITE_MGR_DESIRED_BSS_TYPE_PARAM;
825 siteMgr_getParam(pSmeSm->hSiteMgr, ¶m);
826
827 if(param.content.siteMgrDesiredBSSType == BSS_INDEPENDENT)
828 return smeSm_reportSelectStatus(pSmeSm, (mgmtStatus_e)SELECT_STATUS_FAILURE);
829 else
830 return siteMgr_selectSite(pSmeSm->hSiteMgr);
831 }
832
833
834
835
chooseScanBand(smeSm_t * pSmeSm,radioBand_e * band)836 static TI_STATUS chooseScanBand(smeSm_t* pSmeSm, radioBand_e *band)
837 {
838 paramInfo_t param;
839
840 param.paramType = SITE_MGR_DESIRED_DOT11_MODE_PARAM;
841 siteMgr_getParam( pSmeSm->hSiteMgr, ¶m );
842
843 /* if working in dual band, select band according to dualBandReScanFlag */
844 if ( param.content.siteMgrDot11Mode == DOT11_DUAL_MODE )
845 {
846 *band = ( TRUE == pSmeSm->dualBandReScanFlag ? RADIO_BAND_5_0_GHZ : RADIO_BAND_2_4_GHZ);
847 }
848 /* if not working in dual band, return site manager current band */
849 else
850 {
851 param.paramType = SITE_MGR_RADIO_BAND_PARAM;
852 siteMgr_getParam(pSmeSm->hSiteMgr, ¶m);
853 *band = pSmeSm->currBand = param.content.siteMgrRadioBand;
854 }
855 return OK;
856 }
857
858
859
smeCallScan(void * pData)860 static TI_STATUS smeCallScan(void *pData)
861 {
862 smeSm_t *pSmeSm = (smeSm_t *)pData;
863 paramInfo_t param;
864 scan_Params_t* pScanParams = &(pSmeSm->scanParams);
865 sme_scan_Params_t *pSmeScanParams;
866 scan_normalChannelEntry_t *pChanEntry;
867 int chan, k;
868
869 /*
870 * Check in which band we are in and prepare the scan command.
871 */
872 pScanParams->scanType = SCAN_TYPE_NORMAL_ACTIVE;
873 pScanParams->Tid = 0;
874
875
876 param.paramType = SITE_MGR_OPERATIONAL_MODE_PARAM;
877 siteMgr_getParam( pSmeSm->hSiteMgr, ¶m );
878
879 if ( DOT11_A_MODE == param.content.siteMgrDot11OperationalMode )
880 {
881 pScanParams->band = RADIO_BAND_5_0_GHZ;
882 pSmeScanParams = &(pSmeSm->scanParamsA);
883 }
884 else
885 {
886 pScanParams->band = RADIO_BAND_2_4_GHZ;
887 pSmeScanParams = &(pSmeSm->scanParamsBG);
888 }
889
890 pScanParams->probeRequestRate = pSmeScanParams->probeRequestRate;
891 pScanParams->numOfChannels = pSmeScanParams->numOfChannels;
892 pScanParams->probeReqNumber = pSmeScanParams->probeReqNumber;
893
894 WLAN_REPORT_INFORMATION(pSmeSm->hReport, SME_SM_MODULE_LOG,
895 ("Global Scan Params: Rate=0x%x, Prob#=%d, Channels#=%d\n",
896 pScanParams->probeRequestRate, pScanParams->probeReqNumber,
897 pScanParams->numOfChannels));
898
899 for( chan=0; chan < pScanParams->numOfChannels; chan++ )
900 {
901 pChanEntry = &(pScanParams->channelEntry[chan].normalChannelEntry);
902
903 /* Fill channel ID */
904 pChanEntry->channel = pSmeScanParams->channelsList[chan];
905
906 /* Set broadcast BSSID */
907 for ( k = 0; k < 6; k++ ) pChanEntry->bssId.addr[ k ] = 0xff;
908
909 /* Set min & max dwell time */
910 pChanEntry->minChannelDwellTime = pSmeScanParams->minDwellTime;
911 pChanEntry->maxChannelDwellTime = pSmeScanParams->maxDwellTime;
912
913 /* Set up early termination params. */
914 pChanEntry->earlyTerminationEvent = SCAN_DEFAULT_EARLY_TERMINATION_EVENT;
915 pChanEntry->ETMaxNumOfAPframes = SCAN_DEFAULT_EARLY_TERMINATION_NUM_OF_FRAMES;
916
917 /* Set desired tx power */
918 pChanEntry->txPowerDbm = pSmeScanParams->txPowerDbm;
919
920 WLAN_REPORT_INFORMATION(pSmeSm->hReport, SME_SM_MODULE_LOG,
921 ("Chan %d: CH=%d , DwellTime Min=%d Max=%d, ET=%d, TxPowr=%d, \n",
922 chan,
923 pScanParams->channelEntry[chan].normalChannelEntry.channel,
924 pScanParams->channelEntry[chan].normalChannelEntry.minChannelDwellTime,
925 pScanParams->channelEntry[chan].normalChannelEntry.maxChannelDwellTime,
926 pScanParams->channelEntry[chan].normalChannelEntry.earlyTerminationEvent,
927 pScanParams->channelEntry[chan].normalChannelEntry.txPowerDbm));
928 } /* Channel list setting */
929
930
931 /*
932 * Set the desired SSID (if any)
933 */
934 param.paramType = SITE_MGR_DESIRED_SSID_PARAM;
935 siteMgr_getParam( pSmeSm->hSiteMgr, ¶m );
936
937 if ( utils_isAnySSID( &(param.content.siteMgrDesiredSSID) ) )
938 {
939 pScanParams->desiredSsid.len = 0;
940 }
941 else
942 {
943 pScanParams->desiredSsid.len = param.content.siteMgrDesiredSSID.len;
944 os_memoryCopy( pSmeSm->hOs, (void *)pScanParams->desiredSsid.ssidString,
945 (void *)param.content.siteMgrDesiredSSID.ssidString,
946 param.content.siteMgrDesiredSSID.len );
947 }
948
949
950
951 /*
952 * Prepare scan complete's aging, by increasing the scanned sites
953 * scan attemps counter. The counter will be checked upon scan complete,
954 * and the sites with no update scan results will be dropped.
955 */
956 siteMgr_setNotReceivedParameter(pSmeSm->hSiteMgr, &(pScanParams->desiredSsid), pScanParams->band );
957
958 #ifdef TI_DBG
959 /* scan results count statistics - nullify the count before starting scan */
960 pSmeSm->smeStats.currentNumberOfScanResults = 0;
961 #endif
962
963 /*
964 * Set and send the scan command.
965 */
966 if (scanConcentrator_scan( pSmeSm->hScanCncn, SCAN_SCC_DRIVER, pScanParams ) !=
967 SCAN_CRS_SCAN_RUNNING)
968 {
969 /* imitate scan complete event if scan could not be performed.*/
970 smeSm_SMEvent(&pSmeSm->state, SME_SM_EVENT_SCAN_COMPLETE, pSmeSm);
971 }
972
973 return OK;
974 }
975
976
actionUnexpected(void * pData)977 static TI_STATUS actionUnexpected(void *pData)
978 {
979 smeSm_t *pSmeSm = (smeSm_t *)pData;
980
981 WLAN_REPORT_SM(pSmeSm->hReport, SME_SM_MODULE_LOG, ("State machine error, unexpected Event\n\n"));
982 return OK;
983 }
984
985
986
actionNop(void * pData)987 static TI_STATUS actionNop(void *pData)
988 {
989 return OK;
990 }
991
992
993
smeSm_changeBandParams(TI_HANDLE hSmeSm,radioBand_e radioBand)994 static TI_STATUS smeSm_changeBandParams(TI_HANDLE hSmeSm, radioBand_e radioBand)
995 {
996 paramInfo_t param;
997 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm;
998
999 /* change dot11 mode */
1000 param.paramType = SITE_MGR_OPERATIONAL_MODE_PARAM;
1001 if(radioBand == RADIO_BAND_2_4_GHZ)
1002 param.content.siteMgrDot11OperationalMode = DOT11_G_MODE;
1003 else
1004 param.content.siteMgrDot11OperationalMode = DOT11_A_MODE;
1005
1006 siteMgr_setParam(pSmeSm->hSiteMgr, ¶m);
1007
1008 param.paramType = SITE_MGR_RADIO_BAND_PARAM;
1009 param.content.siteMgrRadioBand = radioBand;
1010 siteMgr_setParam(pSmeSm->hSiteMgr, ¶m);
1011
1012 siteMgr_setCurrentTable(pSmeSm->hSiteMgr, radioBand);
1013
1014 /* configure hal with common core-hal parameters */
1015 whalCtrl_SetRadioBand(pSmeSm->hHalCtrl, radioBand);
1016
1017 return OK;
1018 }
1019
1020 /***********************************************************************
1021 * smeSm_startInterScanTimeout
1022 ***********************************************************************
1023 DESCRIPTION: Starts interscan timeout
1024
1025 INPUT: hSmeSm - SME SM handle.
1026
1027 OUTPUT:
1028
1029 RETURN: OK on success, NOK otherwise
1030
1031 ************************************************************************/
smeSm_startInterScanTimeout(TI_HANDLE hSmeSm)1032 static TI_STATUS smeSm_startInterScanTimeout(TI_HANDLE hSmeSm)
1033 {
1034 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm;
1035 paramInfo_t param;
1036
1037 /* If the SME scan is disabled, (scan is performed by the application)
1038 * don't start the inter scan timeout
1039 */
1040 if (pSmeSm->scanEnabled == SCAN_DISABLED)
1041 {
1042 return OK;
1043 }
1044
1045 if (pSmeSm->scanEnabled == SKIP_NEXT_SCAN)
1046 {
1047 pSmeSm->scanEnabled = SCAN_ENABLED;
1048 }
1049
1050 param.paramType = SITE_MGR_DESIRED_BSS_TYPE_PARAM;
1051 siteMgr_getParam(pSmeSm->hSiteMgr, ¶m);
1052
1053 if (param.content.siteMgrDesiredBSSType == BSS_INDEPENDENT)
1054 {
1055 os_timerStart(pSmeSm->hOs, pSmeSm->interScanTimeoutTimer, IBSS_INTER_SCAN_PERIOD, FALSE);
1056 }
1057 else
1058 {
1059 os_timerStart(pSmeSm->hOs, pSmeSm->interScanTimeoutTimer, pSmeSm->interScanTimeout, FALSE);
1060 }
1061
1062 return OK;
1063 }
1064
1065 /***********************************************************************
1066 * smeSm_stopInterScanTimeout
1067 ***********************************************************************
1068 DESCRIPTION: Stops scan timeout
1069
1070 INPUT: hSmeSm - SME SM handle.
1071
1072 OUTPUT:
1073
1074 RETURN: OK on success, NOK otherwise
1075
1076 ************************************************************************/
smeSm_stopInterScanTimeout(TI_HANDLE hSmeSm)1077 static TI_STATUS smeSm_stopInterScanTimeout(TI_HANDLE hSmeSm)
1078 {
1079 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm;
1080
1081 os_timerStop(pSmeSm->hOs, pSmeSm->interScanTimeoutTimer);
1082 return OK;
1083 }
1084
1085 /***********************************************************************
1086 * smeSm_sendDisassociateEvent
1087 ***********************************************************************
1088 DESCRIPTION: Send disassociate event with the reason
1089
1090 INPUT: pSmeSm - SME SM handle.
1091
1092 OUTPUT:
1093
1094 RETURN:
1095
1096 ************************************************************************/
smeSm_sendDisassociateEvent(smeSm_t * pSmeSm)1097 static void smeSm_sendDisassociateEvent(smeSm_t* pSmeSm)
1098 {
1099 OS_802_11_DISASSOCIATE_REASON_T eventReason;
1100
1101 WLAN_REPORT_INFORMATION(pSmeSm->hReport, SME_SM_MODULE_LOG,
1102 ("%s uDissconnectType = %d, uStatusCode = %d\n",__FUNCTION__, pSmeSm->DisAssoc.mgmtStatus, pSmeSm->DisAssoc.uStatusCode));
1103
1104 /* Convert reason to OS layer */
1105 switch(pSmeSm->DisAssoc.mgmtStatus)
1106 {
1107 case STATUS_UNSPECIFIED:
1108 eventReason.eDisAssocType = OS_DISASSOC_STATUS_UNSPECIFIED;
1109 break;
1110 case STATUS_AUTH_REJECT:
1111 eventReason.eDisAssocType = OS_DISASSOC_STATUS_AUTH_REJECT;
1112 break;
1113 case STATUS_ASSOC_REJECT:
1114 eventReason.eDisAssocType = OS_DISASSOC_STATUS_ASSOC_REJECT;
1115 break;
1116 case STATUS_SECURITY_FAILURE:
1117 eventReason.eDisAssocType = OS_DISASSOC_STATUS_SECURITY_FAILURE;
1118 break;
1119 case STATUS_AP_DEAUTHENTICATE:
1120 eventReason.eDisAssocType = OS_DISASSOC_STATUS_AP_DEAUTHENTICATE;
1121 break;
1122 case STATUS_AP_DISASSOCIATE:
1123 eventReason.eDisAssocType = OS_DISASSOC_STATUS_AP_DISASSOCIATE;
1124 break;
1125 case STATUS_ROAMING_TRIGGER:
1126 eventReason.eDisAssocType = OS_DISASSOC_STATUS_ROAMING_TRIGGER;
1127 break;
1128 default:
1129 eventReason.eDisAssocType = OS_DISASSOC_STATUS_UNSPECIFIED;
1130 break;
1131 }
1132 /* Use the same status code for OS */
1133 eventReason.uStatusCode = pSmeSm->DisAssoc.uStatusCode;
1134
1135 EvHandlerSendEvent(pSmeSm->hEvHandler, IPC_EVENT_DISASSOCIATED, (UINT8*)&eventReason, sizeof(OS_802_11_DISASSOCIATE_REASON_T));
1136
1137 /* Reset status after sending the event */
1138 pSmeSm->DisAssoc.mgmtStatus = STATUS_UNSPECIFIED;
1139 pSmeSm->DisAssoc.uStatusCode = 0;
1140 }
1141
1142 #ifdef TI_DBG
1143 /***********************************************************************
1144 * smeSm_resetStats
1145 ***********************************************************************
1146 DESCRIPTION: Reset SME statistics
1147
1148 INPUT: hSmeSm - SME SM handle.
1149
1150 OUTPUT:
1151
1152 RETURN:
1153
1154 ************************************************************************/
smeSm_resetStats(TI_HANDLE hSmeSm)1155 void smeSm_resetStats( TI_HANDLE hSmeSm )
1156 {
1157 smeSm_t* pSmeSm = (smeSm_t*)hSmeSm;
1158
1159 os_memoryZero( pSmeSm->hOs, &(pSmeSm->smeStats), sizeof(smeSmStats_t) );
1160 }
1161
1162 /***********************************************************************
1163 * smeSm_printStats
1164 ***********************************************************************
1165 DESCRIPTION: Print SME statistics
1166
1167 INPUT: hSmeSm - SME SM handle.
1168
1169 OUTPUT:
1170
1171 RETURN:
1172
1173 ************************************************************************/
smeSm_printStats(TI_HANDLE hSmeSm)1174 void smeSm_printStats( TI_HANDLE hSmeSm )
1175 {
1176 smeSm_t* pSmeSm = (smeSm_t*)hSmeSm;
1177
1178 WLAN_OS_REPORT(("----------------------- SME statistics -----------------------\n\n"));
1179 WLAN_OS_REPORT(("Scan attempts histogram:\n"));
1180 WLAN_OS_REPORT(("------------------------\n\n"));
1181 WLAN_OS_REPORT(("Attempts: %6d %6d %6d %6d %6d %6d %6d %6d\n", 1, 2, 3, 4, 5, 6, 7, 8));
1182 WLAN_OS_REPORT(("Count: %6d %6d %6d %6d %6d %6d %6d %6d\n\n", pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ 0 ],
1183 pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ 1 ], pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ 2 ],
1184 pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ 3 ], pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ 4 ],
1185 pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ 5 ], pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ 6 ],
1186 pSmeSm->smeStats.scanAttemptsForConnectionHistogram[ 7 ]));
1187 WLAN_OS_REPORT(("Scan result count histogram:\n"));
1188 WLAN_OS_REPORT(("----------------------------\n\n"));
1189 WLAN_OS_REPORT(("Results: %6d %6d %6d %6d %6d %6d %6d %6d\n", 0, 1, 2, 3, 4, 5, 6, 7));
1190 WLAN_OS_REPORT(("Scans: %6d %6d %6d %6d %6d %6d %6d %6d\n\n", pSmeSm->smeStats.scanResulCountHistogram[ 0 ],
1191 pSmeSm->smeStats.scanResulCountHistogram[ 1 ], pSmeSm->smeStats.scanResulCountHistogram[ 2 ],
1192 pSmeSm->smeStats.scanResulCountHistogram[ 3 ], pSmeSm->smeStats.scanResulCountHistogram[ 4 ],
1193 pSmeSm->smeStats.scanResulCountHistogram[ 5 ], pSmeSm->smeStats.scanResulCountHistogram[ 6 ],
1194 pSmeSm->smeStats.scanResulCountHistogram[ 7 ]));
1195 WLAN_OS_REPORT(("Results: %6d %6d %6d %6d %6d %6d %6d %6d\n", 8, 9, 10, 11, 12, 13, 14, 15));
1196 WLAN_OS_REPORT(("Scans: %6d %6d %6d %6d %6d %6d %6d %6d\n", pSmeSm->smeStats.scanResulCountHistogram[ 8 ],
1197 pSmeSm->smeStats.scanResulCountHistogram[ 9 ], pSmeSm->smeStats.scanResulCountHistogram[ 10 ],
1198 pSmeSm->smeStats.scanResulCountHistogram[ 11 ], pSmeSm->smeStats.scanResulCountHistogram[ 12 ],
1199 pSmeSm->smeStats.scanResulCountHistogram[ 13 ], pSmeSm->smeStats.scanResulCountHistogram[ 14 ],
1200 pSmeSm->smeStats.scanResulCountHistogram[ 15 ]));
1201 }
1202
1203 /***********************************************************************
1204 * smeSm_dbgPrintObject
1205 ***********************************************************************
1206 DESCRIPTION: Print the SME object
1207
1208 INPUT: hSmeSm - SME SM handle.
1209
1210 OUTPUT:
1211
1212 RETURN:
1213
1214 ************************************************************************/
smeSm_dbgPrintObject(TI_HANDLE hSmeSm)1215 void smeSm_dbgPrintObject( TI_HANDLE hSmeSm )
1216 {
1217 smeSm_t *pSmeSm = (smeSm_t *)hSmeSm;
1218
1219 WLAN_OS_REPORT(("Current SME State is <%s>\n",stateDesc[pSmeSm->state]));
1220 }
1221
1222 #endif
1223
1224