1 /** \file ScanCncn.c
2 * \brief This file include the scan concentrator module implementation
3 * \author Ronen Kalish
4 * \date 03-Jan-2005
5 */
6 /****************************************************************************
7 **+-----------------------------------------------------------------------+**
8 **| |**
9 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |**
10 **| All rights reserved. |**
11 **| |**
12 **| Redistribution and use in source and binary forms, with or without |**
13 **| modification, are permitted provided that the following conditions |**
14 **| are met: |**
15 **| |**
16 **| * Redistributions of source code must retain the above copyright |**
17 **| notice, this list of conditions and the following disclaimer. |**
18 **| * Redistributions in binary form must reproduce the above copyright |**
19 **| notice, this list of conditions and the following disclaimer in |**
20 **| the documentation and/or other materials provided with the |**
21 **| distribution. |**
22 **| * Neither the name Texas Instruments nor the names of its |**
23 **| contributors may be used to endorse or promote products derived |**
24 **| from this software without specific prior written permission. |**
25 **| |**
26 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |**
27 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |**
28 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |**
29 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |**
30 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |**
31 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |**
32 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |**
33 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |**
34 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |**
35 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |**
36 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |**
37 **| |**
38 **+-----------------------------------------------------------------------+**
39 ****************************************************************************/
40
41 #include "ScanCncn.h"
42 #include "ScanCncnAppSM.h"
43 #include "ScanCncnDrvSM.h"
44 #include "ScanCncnRoamingContSM.h"
45 #include "ScanCncnRoamingImmedSM.h"
46 #include "ScanCncnAppApi.h"
47 #include "ScanCncnOidSM.h"
48 #include "report.h"
49 #include "fsm.h"
50 #include "scrApi.h"
51 #include "paramIn.h"
52 #include "regulatoryDomainApi.h"
53 #include "siteMgrApi.h"
54 #include "siteHash.h"
55 #include "utils.h"
56 #include "healthMonitor.h"
57
58 /* static functions */
59 static void scanConcentrator_SGupdateScanParams( TI_HANDLE hScanCncn, scan_Params_t* pScanParams );
60
61 /**
62 * \author Ronen Kalish\n
63 * \date 02-Jan-2005\n
64 * \brief Creates the scan concentrator object
65 *
66 * Function Scope \e Public.\n
67 * \param hOS - handle to the OS object.\n
68 * \return a handle to the scan SRV object, NULL if an error occurred.\n
69 */
scanConcentrator_create(TI_HANDLE hOS)70 TI_HANDLE scanConcentrator_create( TI_HANDLE hOS )
71 {
72 UINT16 initVector = 0;
73
74 /* allocate the scan concentrator object */
75 scanConcentrator_t *pScanConcentrator = os_memoryAlloc( hOS, sizeof(scanConcentrator_t) );
76 if ( NULL == pScanConcentrator )
77 {
78 WLAN_OS_REPORT( ("ERROR: Failed to create scan concnetrator module\n") );
79 return NULL;
80 }
81 initVector |= (1 << SCAN_ALLOC_OBJECT);
82
83 /* store the OS handle */
84 pScanConcentrator->hOS = hOS;
85
86 /* create state machines */
87 if ( OK != fsm_Create( hOS, &(pScanConcentrator->clientSM[ SCAN_SCC_APP ]),
88 APP_SCAN_NUM_OF_STATES, APP_SCAN_NUM_OF_EVENTS ) )
89 {
90 WLAN_OS_REPORT( ("ERROR: Failed to allocate application scan state machine\n") );
91 scanConcentrator_freeMem( pScanConcentrator, initVector );
92 return NULL;
93 }
94 initVector |= (1 << SCAN_ALLOC_APP_SM);
95
96 if ( OK != fsm_Create( hOS, &(pScanConcentrator->clientSM[ SCAN_SCC_DRIVER ]),
97 DRV_SCAN_NUM_OF_STATES, DRV_SCAN_NUM_OF_EVENTS ) )
98 {
99 WLAN_OS_REPORT( ("ERROR: Failed to allocate driver scan state machine\n") );
100 scanConcentrator_freeMem( pScanConcentrator, initVector );
101 return NULL;
102 }
103 initVector |= (1 << SCAN_ALLOC_DRV_SM);
104
105 if ( OK != fsm_Create( hOS, &(pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_CONT ]),
106 CONT_SCAN_NUM_OF_STATES, CONT_SCAN_NUM_OF_EVENTS ) )
107 {
108 WLAN_OS_REPORT( ("ERROR: Failed to allocate continuous scan for roaming state machine\n") );
109 scanConcentrator_freeMem( pScanConcentrator, initVector );
110 return NULL;
111 }
112 initVector |= (1 << SCAN_ALLOC_CONT_SM);
113
114 if ( OK != fsm_Create( hOS, &(pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_IMMED ]),
115 IMMED_SCAN_NUM_OF_STATES, IMMED_SCAN_NUM_OF_EVENTS ) )
116 {
117 WLAN_OS_REPORT( ("ERROR: Failed to allocate immediate scan for roaming state machine\n") );
118 scanConcentrator_freeMem( pScanConcentrator, initVector );
119 return NULL;
120 }
121 initVector |= (1 << SCAN_ALLOC_IMMED_SM);
122 if ( OK != fsm_Create( hOS, &(pScanConcentrator->hOidSM), OID_SCAN_NUM_OF_STATES, OID_SCAN_NUM_OF_EVENTS) )
123 {
124 WLAN_OS_REPORT( ("ERROR: Failed to allocate OID scan state machine\n") );
125 scanConcentrator_freeMem( pScanConcentrator, initVector );
126 return NULL;
127 }
128 return pScanConcentrator;
129 }
130
131 /**
132 * \author Ronen Kalish\n
133 * \date 02-Jan-2005\n
134 * \brief Finalizes the scan concentrator object (freeing system resources)
135 *
136 * Function Scope \e Public.\n
137 * \param hScanCncn - handle to the scan concentrator object.\n
138 */
scanConcentrator_release(TI_HANDLE hScanCncn)139 void scanConcentrator_release( TI_HANDLE hScanCncn )
140 {
141 scanConcentrator_freeMem( hScanCncn, 0xffff );
142 }
143
144 /**
145 * \author Ronen Kalish\n
146 * \date 05-Jan-2005\n
147 * \brief Frees the scan concentrator memory, according to the init vector.
148 *
149 * Function Scope \e Public.\n
150 * \param hScanCncn - handle to the scan concentrator object.\n
151 * \param initVec - a vector holding on bits for allocated components and off bits for non allocated components
152 */
scanConcentrator_freeMem(TI_HANDLE hScanCncn,UINT16 initVec)153 void scanConcentrator_freeMem( TI_HANDLE hScanCncn, UINT16 initVec )
154 {
155 scanConcentrator_t *pScanConcentrator= (scanConcentrator_t*)hScanCncn;
156
157 /* free state machines */
158 if ( initVec & (1<<SCAN_ALLOC_APP_SM) )
159 {
160 fsm_Unload( pScanConcentrator->hOS, pScanConcentrator->clientSM[ SCAN_SCC_APP ] );
161 }
162 if ( initVec & (1 << SCAN_ALLOC_DRV_SM) )
163 {
164 fsm_Unload( pScanConcentrator->hOS, pScanConcentrator->clientSM[ SCAN_SCC_DRIVER ] );
165 }
166 if ( initVec & (1 << SCAN_ALLOC_CONT_SM) )
167 {
168 fsm_Unload( pScanConcentrator->hOS, pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_CONT ] );
169 }
170 if ( initVec & (1 << SCAN_ALLOC_IMMED_SM) )
171 {
172 fsm_Unload( pScanConcentrator->hOS, pScanConcentrator->clientSM[ SCAN_SCC_ROAMING_IMMED ] );
173 }
174 if ( initVec & (1 << SCAN_ALLOC_OID_SM) )
175 {
176 fsm_Unload( pScanConcentrator->hOS, pScanConcentrator->hOidSM );
177 }
178 /* free scan concentrator object */
179 if ( initVec & (1 << SCAN_ALLOC_OBJECT) )
180 {
181 os_memoryFree( pScanConcentrator->hOS, pScanConcentrator, sizeof(scanConcentrator_t) );
182 }
183 }
184
185 /**
186 * \author Ronen Kalish\n
187 * \date 02-Jan-2005\n
188 * \brief Initialize the scan concentrator object.
189 *
190 * Function Scope \e Public.\n
191 * \param hScanCncn - handle to the scan concentrator object.\n
192 * \param hHalCtrl - handle to the Hal Ctrl object.\n
193 * \param hReport - handle to the Report object.\n
194 * \param hRegDomain - handle to the regulatory domain object.\n
195 * \param hSiteMngr - handle to the site manager object.\n
196 * \param hSCR - handle to the SCR object.\n
197 * \param hMacServices - handle to the MacServices object.\n
198 * \param hAPConn - handle to the AP connection object.\n
199 * \param hEventSRV - handle to the event SRV object.\n
200 * \param hMlme - handle to the MLME object.\n
201 * \param hHealthMonitor - handle to the health monitor object.\n
202 * \param pScanConcentratorInitParams - pointer to the init parameters structure.\n
203 */
scanConcentrator_init(TI_HANDLE hScanCncn,TI_HANDLE hHalCtrl,TI_HANDLE hReport,TI_HANDLE hRegDomain,TI_HANDLE hSiteMngr,TI_HANDLE hSCR,TI_HANDLE hMacServices,TI_HANDLE hAPConn,TI_HANDLE hEventSRV,TI_HANDLE hMlme,TI_HANDLE hCtrlData,TI_HANDLE hHealthMonitor,scanConcentratorInitParams_t * pScanConcentratorInitParams)204 void scanConcentrator_init( TI_HANDLE hScanCncn,
205 TI_HANDLE hHalCtrl,
206 TI_HANDLE hReport,
207 TI_HANDLE hRegDomain,
208 TI_HANDLE hSiteMngr,
209 TI_HANDLE hSCR,
210 TI_HANDLE hMacServices,
211 TI_HANDLE hAPConn,
212 TI_HANDLE hEventSRV,
213 TI_HANDLE hMlme,
214 TI_HANDLE hCtrlData,
215 TI_HANDLE hHealthMonitor,
216 scanConcentratorInitParams_t* pScanConcentratorInitParams )
217 {
218 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
219
220 /* copy handles */
221 pScanConcentrator->hReport = hReport;
222 pScanConcentrator->hHalCtrl = hHalCtrl;
223 pScanConcentrator->hRegulatoryDomain = hRegDomain;
224 pScanConcentrator->hSiteManager = hSiteMngr;
225 pScanConcentrator->hSCR = hSCR;
226 pScanConcentrator->hMacServices = hMacServices;
227 pScanConcentrator->hAPConn = hAPConn;
228 pScanConcentrator->hEventSrv = hEventSRV;
229 pScanConcentrator->hMlme = hMlme;
230 pScanConcentrator->hCtrlData = hCtrlData;
231 pScanConcentrator->hHealthMonitor = hHealthMonitor;
232
233 /* copy registry values */
234 os_memoryCopy( pScanConcentrator->hOS, &(pScanConcentrator->initParams), pScanConcentratorInitParams,
235 sizeof( scanConcentratorInitParams_t ) );
236
237 /* initialize state machines */
238 if ( OK != scanConcentratorAppSM_init( hScanCncn ) )
239 {
240 WLAN_REPORT_ERROR( hReport, SCAN_CNCN_MODULE_LOG, ("Error: application SM initialization failed.\n") );
241 return;
242 }
243
244 if ( OK != scanConcentratorDrvSM_init( hScanCncn ) )
245 {
246 WLAN_REPORT_ERROR( hReport, SCAN_CNCN_MODULE_LOG, ("Error: driver SM initialization failed.\n") );
247 return;
248 }
249
250 if ( OK != scanConcentratorRoamingContSM_init( hScanCncn ) )
251 {
252 WLAN_REPORT_ERROR( hReport, SCAN_CNCN_MODULE_LOG, ("Error: continuous scan for roaming SM initialization failed.\n") );
253 return;
254 }
255
256 if ( OK != scanConcentratorRoamingImmedSM_init( hScanCncn ) )
257 {
258 WLAN_REPORT_ERROR( hReport, SCAN_CNCN_MODULE_LOG, ("Error: immediate scan for roaming SM initialization failed.\n") );
259 return;
260 }
261 if ( OK != scanConcentratorOidSM_init( hScanCncn ) )
262 {
263 WLAN_REPORT_ERROR( hReport, SCAN_CNCN_MODULE_LOG, ("Error: OID scan SM initialization failed.\n") );
264 return;
265 }
266 /* register SCR callbacks */
267 scr_registerClientCB( pScanConcentrator->hSCR, SCR_CID_APP_SCAN, scanConcentrator_scrAppCB, hScanCncn );
268 scr_registerClientCB( pScanConcentrator->hSCR, SCR_CID_DRIVER_FG_SCAN, scanConcentrator_scrDriverCB, hScanCncn );
269 scr_registerClientCB( pScanConcentrator->hSCR, SCR_CID_CONT_SCAN, scanConcentrator_scrRoamingContCB, hScanCncn );
270 scr_registerClientCB( pScanConcentrator->hSCR, SCR_CID_IMMED_SCAN, scanConcentrator_scrRoamingImmedCB, hScanCncn );
271
272 /* register scan SRV scan complete CB */
273 MacServices_scanSRV_registerScanCompleteCB( hMacServices, scanConcentrator_scanCompleteNotificationCB, hScanCncn );
274
275 /* nullify other parameters */
276 pScanConcentrator->currentRunningScanClient = SCAN_SCC_NO_CLIENT;
277 pScanConcentrator->connectionStatus = STA_NOT_CONNECTED;
278
279 /* bUseSGParams is TRUE only when SG module is enabled */
280 pScanConcentrator->bUseSGParams = FALSE;
281
282 /* "register" the application scan result callback */
283 scanConcentrator_registerScanResultCB( hScanCncn, SCAN_SCC_APP, scanConcentrator_appScanResultCB, hScanCncn );
284
285 WLAN_REPORT_INIT( hReport, SCAN_CNCN_MODULE_LOG, (".....Scan concentrator configured successfully.\n"));
286 }
287
288 /**
289 * \author Ronen Kalish\n
290 * \date 02-Jan-2005\n
291 * \brief switch the connection mode to connected (infrastructure BSS)
292 *
293 * Function Scope \e Public.\n
294 * \param hScanCncn - handle to the scan concentrator object.\n
295 */
scanConcentrator_switchToConnected(TI_HANDLE hScanCncn)296 void scanConcentrator_switchToConnected( TI_HANDLE hScanCncn )
297 {
298 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
299
300 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, ("Switching to connected state.\n") );
301
302 /* change connection status to connected */
303 pScanConcentrator->connectionStatus = STA_CONNECTED;
304
305 /* Any running scans in other modes will be aborted (if needed) by the SCR (or have already been) */
306 }
307
308 /**
309 * \author Ronen Kalish\n
310 * \date 02-Jan-2005\n
311 * \brief switch the connection mode to not connected
312 *
313 * Function Scope \e Public.\n
314 * \param hScanCncn - handle to the scan concentrator object.\n
315 */
scanConcentrator_switchToNotConnected(TI_HANDLE hScanCncn)316 void scanConcentrator_switchToNotConnected( TI_HANDLE hScanCncn )
317 {
318 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
319
320 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, ("Switching to not connected state.\n") );
321
322 /* change connection status to connected */
323 pScanConcentrator->connectionStatus = STA_NOT_CONNECTED;
324
325 /* Any running scans in other modes will be aborted (if needed) by the SCR (or have already been) */
326 }
327
328 /**
329 * \author Ronen Kalish\n
330 * \date 02-Jan-2005\n
331 * \brief switch the connection mode to IBSS participation
332 *
333 * Function Scope \e Public.\n
334 * \param hScanCncn - handle to the scan concentrator object.\n
335 */
scanConcentrator_switchToIBSS(TI_HANDLE hScanCncn)336 void scanConcentrator_switchToIBSS( TI_HANDLE hScanCncn )
337 {
338 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
339
340 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG, ("Switching to IBSS state.\n") );
341
342 /* change connection status to connected */
343 pScanConcentrator->connectionStatus = STA_IBSS;
344
345 /* Any running scans in other modes will be aborted (if needed) by the SCR (or have already been) */
346 }
347
348 /**
349 * \author Ronen Kalish\n
350 * \date 02-Jan-2005\n
351 * \brief Called by a client to request a scan.
352 *
353 * Function Scope \e Public.\n
354 * \param hScanCncn - handle to the scan concentrator object.\n
355 * \param client - the client ID.\n
356 * \return scan operation detailed result status.\n
357 * \retval SCAN_CRS_SCAN_RUNNING - scan started successfully and is now running.\n
358 * \retval SCAN_CRS_SCAN_FAILED - scan failed to start due to an unexpected error.\n
359 */
scanConcentrator_scan(TI_HANDLE hScanCncn,scan_CncnClient_e client,scan_Params_t * pScanParams)360 scan_cncnResultStatus_e scanConcentrator_scan( TI_HANDLE hScanCncn,
361 scan_CncnClient_e client,
362 scan_Params_t* pScanParams )
363 {
364 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
365 whalCtrl_setTemplate_t templateStruct;
366 probeReqTemplate_t probeReqTemplate;
367 paramInfo_t param;
368
369 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
370 ("Received scan request from client %d\n", client) );
371
372 /* sanity check verify that this is a known client */
373 if ( client >= SCAN_SCC_NUM_OF_CLIENTS)
374 {
375 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
376 ("Scan request with illegal client %d, aborting request.\n", client) );
377 return SCAN_CRS_SCAN_FAILED;
378 }
379
380 /* scan requests with junk SSID (other than application scans) are rejected */
381 if ( (client == SCAN_SCC_DRIVER) &&
382 utils_isJunkSSID( &(pScanParams->desiredSsid) ) )
383 {
384 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
385 ("Scan request with junk SSID from client %d.\n", client) );
386 return SCAN_CRS_SCAN_FAILED;
387 }
388
389 #ifndef TI_DBG
390 /* in release mode, no channel expansion is done */
391 if ( 0 == pScanParams->numOfChannels )
392 {
393 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
394 ("Scan request with 0 channels from client:%d\n", client) );
395 return SCAN_CRS_SCAN_FAILED;
396 }
397 #endif
398
399 /* Validate dwell times */
400 if ( pScanParams->scanType != SCAN_TYPE_SPS )
401 {
402 int channel;
403
404 for (channel = 0; channel < pScanParams->numOfChannels; ++channel)
405 {
406 if (pScanParams->channelEntry[channel].normalChannelEntry.maxChannelDwellTime <
407 pScanParams->channelEntry[channel].normalChannelEntry.minChannelDwellTime)
408 {
409 WLAN_REPORT_ERROR( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
410 ("%s: MaxChannelDwellTime must not be smaller than MinChannelDwellTime on channel %d!\n", __FUNCTION__, channel));
411
412 return SCAN_CRS_SCAN_FAILED;
413 }
414 }
415 }
416
417 /* Check if country code should be reset in RegDomain. This is done here in order to detect if country should be updated
418 before the next scan. RegDomain will decide if country code should be deleted or remain the same. */
419 param.paramType = REGULATORY_DOMAIN_CHECK_COUNTRY_PARAM;
420 regulatoryDomain_setParam(pScanConcentrator->hRegulatoryDomain,¶m);
421
422 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,("SG=%d, scan band = %d \n",
423 pScanConcentrator->bUseSGParams,
424 pScanParams->band));
425 /* act according to client */
426 switch ( client )
427 {
428 case SCAN_SCC_APP:
429 /* check that the application state machine is in IDLE state
430 (no more than one scan at a time per client is allowed). */
431 if ( APP_SCAN_STATE_IDLE != pScanConcentrator->clientSMState[ SCAN_SCC_APP ] )
432 {
433 return SCAN_CRS_SCAN_FAILED;
434 }
435 else
436 {
437 /* copy scan parameters to local buffer */
438 os_memoryCopy( pScanConcentrator->hOS, &(pScanConcentrator->clientScanParams[ SCAN_SCC_APP ]),
439 pScanParams, sizeof(scan_Params_t) );
440
441 /* ask the reg domain which channels are allowed for the requested scan type */
442 scanConcentrator_verifyChannelsWithRegDomain( hScanCncn, &(pScanConcentrator->clientScanParams[ SCAN_SCC_APP ]) );
443
444 /* if no channels are available for scan, return negative result */
445 if ( 0 == pScanConcentrator->clientScanParams[ SCAN_SCC_APP ].numOfChannels )
446 {
447 return SCAN_CRS_SCAN_FAILED;
448 }
449
450 if ((pScanConcentrator->bUseSGParams) && (pScanConcentrator->clientScanParams[ SCAN_SCC_APP ].band == RADIO_BAND_2_4_GHZ))
451 {
452 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,("SG is pn && RADIO_BAND_2_4_GHZ \n"));
453 scanConcentrator_SGupdateScanParams(hScanCncn,&(pScanConcentrator->clientScanParams[ SCAN_SCC_APP ]));
454 }
455
456 /* mark that a scan request is in progress (to avoid client re-entrance if the scan fail) */
457 pScanConcentrator->bInRequest = TRUE;
458
459 /* mark the scan result as OK (until other status will replace it) */
460 pScanConcentrator->scanResult[ SCAN_SCC_APP ] = SCAN_CRS_SCAN_COMPLETE_OK;
461
462 /* send probe request template */
463 if ( (SCAN_TYPE_NORMAL_ACTIVE == pScanParams->scanType) ||
464 (SCAN_TYPE_TRIGGERED_ACTIVE == pScanParams->scanType) )
465 {
466
467 templateStruct.pTemplate = (UINT8 *)&probeReqTemplate;
468 templateStruct.templateType = PROBE_REQUEST_TEMPLATE;
469 buildProbeReqTemplate( pScanConcentrator->hSiteManager, &templateStruct,
470 &(pScanConcentrator->clientScanParams[ SCAN_SCC_APP ].desiredSsid),
471 pScanConcentrator->clientScanParams[ SCAN_SCC_APP ].band);
472 whalCtrl_SetTemplate( pScanConcentrator->hHalCtrl, &templateStruct);
473 }
474
475 /* send a start scan event to the SM */
476 scanConcentratorAppSM_SMEvent( hScanCncn,
477 (scan_appSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_APP ]),
478 APP_SCAN_EVENT_START_SCAN );
479
480 /* mark that the scan request is no longer in progress */
481 pScanConcentrator->bInRequest = FALSE;
482
483 /* return scan result */
484 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_APP ] )
485 {
486 return SCAN_CRS_SCAN_RUNNING;
487 }
488 else
489 {
490 return pScanConcentrator->scanResult[ SCAN_SCC_APP ];
491 }
492 }
493 /* break; - unreachable */
494
495 case SCAN_SCC_DRIVER:
496 /* check that the driver state machine is in IDLE state
497 (no more than one scan at a time per client is allowed)*/
498 if ( DRV_SCAN_STATE_IDLE != pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ] )
499 {
500 return SCAN_CRS_SCAN_FAILED;
501 }
502 else
503 {
504 /* copy scan parameters to local buffer */
505 os_memoryCopy( pScanConcentrator->hOS, &(pScanConcentrator->clientScanParams[ SCAN_SCC_DRIVER ]),
506 pScanParams, sizeof(scan_Params_t) );
507
508 if ((pScanConcentrator->bUseSGParams) && (pScanConcentrator->clientScanParams[ SCAN_SCC_DRIVER ].band == RADIO_BAND_2_4_GHZ))
509 {
510 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,("SG is pn && RADIO_BAND_2_4_GHZ \n"));
511 scanConcentrator_SGupdateScanParams(hScanCncn,&(pScanConcentrator->clientScanParams[ SCAN_SCC_DRIVER ]));
512 }
513
514 /* mark that a scan request is in progress (to avoid client re-entrance if the scan fail) */
515 pScanConcentrator->bInRequest = TRUE;
516
517 /* mark the scan result as OK (until other status will replace it) */
518 pScanConcentrator->scanResult[ SCAN_SCC_DRIVER ] = SCAN_CRS_SCAN_COMPLETE_OK;
519
520 /* send probe request template */
521 if ( (SCAN_TYPE_NORMAL_ACTIVE == pScanParams->scanType) ||
522 (SCAN_TYPE_TRIGGERED_ACTIVE == pScanParams->scanType) )
523 {
524
525 templateStruct.pTemplate = (UINT8 *)&probeReqTemplate;
526 templateStruct.templateType = PROBE_REQUEST_TEMPLATE;
527 buildProbeReqTemplate( pScanConcentrator->hSiteManager, &templateStruct,
528 &(pScanConcentrator->clientScanParams[ SCAN_SCC_DRIVER ].desiredSsid),
529 pScanConcentrator->clientScanParams[ SCAN_SCC_DRIVER ].band);
530 whalCtrl_SetTemplate( pScanConcentrator->hHalCtrl, &templateStruct);
531 }
532 /* send a start scan event to the SM */
533 scanConcentratorDrvSM_SMEvent( hScanCncn,
534 (scan_drvSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ]),
535 DRV_SCAN_EVENT_START_SCAN );
536
537 /* mark that the scan request is no longer in progress */
538 pScanConcentrator->bInRequest = FALSE;
539
540 /* return scan result */
541 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_DRIVER ] )
542 {
543 return SCAN_CRS_SCAN_RUNNING;
544 }
545 else
546 {
547 return pScanConcentrator->scanResult[ SCAN_SCC_DRIVER ];
548 }
549 }
550 /* break; - unreachable */
551
552 case SCAN_SCC_ROAMING_CONT:
553 /* check that the continuous roaming state machine is in IDLE state
554 (no more than one scan at a time per client is allowed)*/
555 if ( CONT_SCAN_STATE_IDLE != pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ] )
556 {
557 return SCAN_CRS_SCAN_FAILED;
558 }
559 else
560 {
561 /* copy scan parameters to local buffer */
562 os_memoryCopy( pScanConcentrator->hOS, &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ]),
563 pScanParams, sizeof(scan_Params_t) );
564
565 if ((pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].desiredSsid.len!=0) &&
566 ((pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].scanType == SCAN_TYPE_NORMAL_ACTIVE) ||
567 (pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].scanType == SCAN_TYPE_TRIGGERED_ACTIVE)))
568 {
569 /* set the SSID of the current AP */
570 param.paramType = SITE_MGR_DESIRED_SSID_PARAM;
571 siteMgr_getParam( pScanConcentrator->hSiteManager, ¶m );
572 os_memoryCopy( pScanConcentrator->hOS,
573 &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].desiredSsid),
574 &(param.content.siteMgrDesiredSSID),
575 sizeof(ssid_t) );
576
577 }
578 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
579 ("CONT Scan: The scan SSID is %s\n", pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].desiredSsid.ssidString) );
580
581 /* ask the reg domain which channels are allowed for the requested scan type */
582 scanConcentrator_verifyChannelsWithRegDomain( hScanCncn, &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ]) );
583
584 /* if no channels are available for scan, return negative result */
585 if ( 0 == pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].numOfChannels )
586 {
587 return SCAN_CRS_SCAN_FAILED;
588 }
589
590 if ((pScanConcentrator->bUseSGParams) && (pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].band == RADIO_BAND_2_4_GHZ))
591 {
592 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,("SG is pn && RADIO_BAND_2_4_GHZ \n"));
593 scanConcentrator_SGupdateScanParams(hScanCncn,&(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ]));
594 }
595
596 /* mark that a scan request is in progress (to avoid client re-entrance if the scan fail) */
597 pScanConcentrator->bInRequest = TRUE;
598
599 /* mark the scan result as OK (until other status will replace it) */
600 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_COMPLETE_OK;
601
602 /* send probe request template */
603 if ( (SCAN_TYPE_NORMAL_ACTIVE == pScanParams->scanType) ||
604 (SCAN_TYPE_TRIGGERED_ACTIVE == pScanParams->scanType) )
605 {
606
607 templateStruct.pTemplate = (UINT8 *)&probeReqTemplate;
608 templateStruct.templateType = PROBE_REQUEST_TEMPLATE;
609 buildProbeReqTemplate( pScanConcentrator->hSiteManager, &templateStruct,
610 &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].desiredSsid),
611 pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].band);
612 whalCtrl_SetTemplate( pScanConcentrator->hHalCtrl, &templateStruct);
613 }
614
615 /* send a start scan event to the SM */
616 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
617 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
618 CONT_SCAN_EVENT_START_SCAN );
619
620 /* mark that the scan request is no longer in progress */
621 pScanConcentrator->bInRequest = FALSE;
622
623 /* return scan result */
624 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] )
625 {
626 return SCAN_CRS_SCAN_RUNNING;
627 }
628 else
629 {
630 return pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ];
631 }
632 }
633 /* break; - unreachable */
634
635 case SCAN_SCC_ROAMING_IMMED:
636 /* check that the immediate roaming state machine is in IDLE state
637 (no more than one scan at a time per client is allowed)*/
638 if ( IMMED_SCAN_STATE_IDLE != pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ] )
639 {
640 return SCAN_CRS_SCAN_FAILED;
641 }
642 else
643 {
644
645 /* copy scan parameters to local buffer */
646 os_memoryCopy( pScanConcentrator->hOS, &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ]),
647 pScanParams, sizeof(scan_Params_t) );
648
649 /* set the SSID of the current AP */
650 param.paramType = SITE_MGR_DESIRED_SSID_PARAM;
651 siteMgr_getParam( pScanConcentrator->hSiteManager, ¶m );
652 os_memoryCopy( pScanConcentrator->hOS,
653 &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].desiredSsid),
654 &(param.content.siteMgrDesiredSSID),
655 sizeof(ssid_t) );
656
657 /* ask the reg domain which channels are allowed for the requested scan type */
658 scanConcentrator_verifyChannelsWithRegDomain( hScanCncn, &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ]) );
659
660 /* if no channels are available for scan, return negative result */
661 if ( 0 == pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].numOfChannels )
662 {
663 return SCAN_CRS_SCAN_FAILED;
664 }
665
666 if ((pScanConcentrator->bUseSGParams) && (pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].band == RADIO_BAND_2_4_GHZ))
667 {
668 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,("SG is pn && RADIO_BAND_2_4_GHZ \n"));
669 scanConcentrator_SGupdateScanParams(hScanCncn,&(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ]));
670 }
671
672 /* mark that a scan request is in progress (to avoid client re-entrance if the scan fail) */
673 pScanConcentrator->bInRequest = TRUE;
674
675 /* mark the scan result as OK (until other status will replace it) */
676 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] = SCAN_CRS_SCAN_COMPLETE_OK;
677
678 /* send probe request template */
679 if ( (SCAN_TYPE_NORMAL_ACTIVE == pScanParams->scanType) ||
680 (SCAN_TYPE_TRIGGERED_ACTIVE == pScanParams->scanType) )
681 {
682
683 templateStruct.pTemplate = (UINT8 *)&probeReqTemplate;
684 templateStruct.templateType = PROBE_REQUEST_TEMPLATE;
685 buildProbeReqTemplate( pScanConcentrator->hSiteManager, &templateStruct,
686 &(pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].desiredSsid),
687 pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].band);
688 whalCtrl_SetTemplate( pScanConcentrator->hHalCtrl, &templateStruct);
689 }
690
691 /* send a start scan event to the SM */
692 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn,
693 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]),
694 IMMED_SCAN_EVENT_START_SCAN );
695
696 /* mark that the scan request is no longer in progress */
697 pScanConcentrator->bInRequest = FALSE;
698
699 /* return scan result */
700 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] )
701 {
702 return SCAN_CRS_SCAN_RUNNING;
703 }
704 else
705 {
706 return pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ];
707 }
708 }
709 /* break; - unreachable */
710
711 default:
712 WLAN_REPORT_ERROR( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
713 ("Scan request from unknown client:%d\n", client) );
714 return SCAN_CRS_SCAN_FAILED;
715 /* break; - unreachable */
716
717 }
718
719 /* return SCAN_CRS_SCAN_RUNNING; - unreachable */
720 }
721
722 /**
723 * \author Ronen Kalish\n
724 * \date 02-Jan-2005\n
725 * \brief Called by a client to stop a scan request in process. A client should ONLY stop its own request!
726 *
727 * Function Scope \e Public.\n
728 * \param hScanCncn - handle to the scan concentrator object.\n
729 * \param client - the client ID.\n
730 */
scanConcentrator_stopScan(TI_HANDLE hScanCncn,scan_CncnClient_e client)731 void scanConcentrator_stopScan( TI_HANDLE hScanCncn, scan_CncnClient_e client )
732 {
733 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
734
735 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
736 ("Received stop scan request from client %d\n", client) );
737
738 /* act according to client */
739 switch ( client )
740 {
741 case SCAN_SCC_APP:
742 /* if no previous error has occurred, change the state to stopped */
743 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_APP ] )
744 {
745 pScanConcentrator->scanResult[ SCAN_SCC_APP ] = SCAN_CRS_SCAN_STOPPED;
746 /* set the abort or stop flag (to identify when to exit driver mode (stop) and
747 when not (abort due to higher priority client) */
748 pScanConcentrator->bAbortOrStop = SCAN_CNCN_STOP;
749 }
750 else if (SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY != pScanConcentrator->scanResult[ SCAN_SCC_APP ])
751 { /* In all scan failures, besides abort, indicate the flag as STOP */
752 /* set the abort or stop flag (to identify when to exit driver mode (stop) and
753 when not (abort due to higher priority client) */
754 pScanConcentrator->bAbortOrStop = SCAN_CNCN_STOP;
755 }
756
757 /* send a stop scan event to the SM */
758 scanConcentratorAppSM_SMEvent( hScanCncn,
759 (scan_appSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_APP ]),
760 APP_SCAN_EVENT_STOP_SCAN );
761 break;
762
763 case SCAN_SCC_DRIVER:
764 /* if no previous error has occurred, change the state to stopped */
765 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_DRIVER ] )
766 {
767 pScanConcentrator->scanResult[ SCAN_SCC_DRIVER ] = SCAN_CRS_SCAN_STOPPED;
768 }
769
770 /* send a stop scan event to the SM */
771 scanConcentratorDrvSM_SMEvent( hScanCncn,
772 (scan_drvSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ]),
773 DRV_SCAN_EVENT_STOP_SCAN );
774 break;
775
776 case SCAN_SCC_ROAMING_CONT:
777 /* if no previous error has occurred, change the state to stopped */
778 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] )
779 {
780 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_STOPPED;
781
782 /* set the abort or stop flag (to identify when to exit driver mode (stop) and
783 when not (abort due to higher priority client) */
784 pScanConcentrator->bAbortOrStop = SCAN_CNCN_STOP;
785 }
786 else if (SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY != pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ])
787 { /* In all scan failures, besides abort, indicate the flag as STOP */
788 /* set the abort or stop flag (to identify when to exit driver mode (stop) and
789 when not (abort due to higher priority client) */
790 pScanConcentrator->bAbortOrStop = SCAN_CNCN_STOP;
791 }
792
793 /* send a stop scan event to the SM */
794 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
795 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
796 CONT_SCAN_EVENT_STOP_SCAN );
797 break;
798
799 case SCAN_SCC_ROAMING_IMMED:
800 /* if no previous error has occurred, change the state to stopped */
801 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] )
802 {
803 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] = SCAN_CRS_SCAN_STOPPED;
804
805 /* set the abort or stop flag (to identify when to exit driver mode (stop) and
806 when not (abort due to higher priority client) */
807 pScanConcentrator->bAbortOrStop = SCAN_CNCN_STOP;
808 }
809 else if (SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY != pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ])
810 { /* In all scan failures, besides abort, indicate the flag as STOP */
811 /* set the abort or stop flag (to identify when to exit driver mode (stop) and
812 when not (abort due to higher priority client) */
813 pScanConcentrator->bAbortOrStop = SCAN_CNCN_STOP;
814 }
815
816 /* send a stop scan event to the SM */
817 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn,
818 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]),
819 IMMED_SCAN_EVENT_STOP_SCAN );
820 break;
821
822 default:
823 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
824 ("Stop scan request with illegal client %d, aborting request.\n", client) );
825 break;
826 }
827 }
828
829 /**
830 * \author Ronen Kalish\n
831 * \date 02-Jan-2005\n
832 * \brief Registers a scan result function for a specific client.
833 *
834 * Function Scope \e Public.\n
835 * \param hScanCncn - handle to the scan concentrator object.\n
836 * \param client - the client ID.\n
837 * \param scanResultCBFunc - the function to use.\n
838 * \param scanresultCBObj - the object to pass to the scan result CB function.\n
839 */
scanConcentrator_registerScanResultCB(TI_HANDLE hScanCncn,scan_CncnClient_e client,scan_resultCB_t scanResultCBFunc,TI_HANDLE scanResultCBObj)840 void scanConcentrator_registerScanResultCB( TI_HANDLE hScanCncn, scan_CncnClient_e client,
841 scan_resultCB_t scanResultCBFunc, TI_HANDLE scanResultCBObj )
842 {
843 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
844
845 /* save the function and object pointers */
846 pScanConcentrator->scanResultCB[ client ] = scanResultCBFunc;
847 pScanConcentrator->scanResultCBObj[ client ] = scanResultCBObj;
848 }
849
850 /**
851 * \author Ronen Kalish\n
852 * \date 02-Jan-2005\n
853 * \brief Called by the scan SRV (after registration) to notify of a scan complete event.
854 *
855 * Function Scope \e Public.\n
856 * \param hScanCncn - handle to the scan concentrator object.\n
857 * \param SPSStatus - which channels were attempted (if SPS scan).\n
858 * \param bTSFError - whether a TSF error occurred (if SPS scan).\n
859 * \param ScanStatus - return the status of the scan . \n
860 */
scanConcentrator_scanCompleteNotificationCB(TI_HANDLE hScanCncn,UINT16 SPSStatus,BOOLEAN bTSFError,TI_STATUS ScanStatus,TI_STATUS PSMode)861 void scanConcentrator_scanCompleteNotificationCB( TI_HANDLE hScanCncn, UINT16 SPSStatus, BOOLEAN bTSFError , TI_STATUS ScanStatus , TI_STATUS PSMode )
862 {
863 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
864
865 /* start built-in test timer */
866 healthMonitor_resumePeriodicTest( pScanConcentrator->hHealthMonitor );
867
868 #ifdef TI_DBG
869 /* check that current running client is valid */
870 if ( SCAN_SCC_NO_CLIENT == pScanConcentrator->currentRunningScanClient )
871 {
872 WLAN_REPORT_ERROR( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
873 ("Scan complete called when current running client is invalid: %d\n",
874 pScanConcentrator->currentRunningScanClient) );
875 return;
876 }
877 #endif
878 /* send a scan complete event to the running client (according to its type) */
879 switch ( pScanConcentrator->currentRunningScanClient )
880 {
881 case SCAN_SCC_APP:
882 scanConcentratorAppSM_SMEvent( hScanCncn,
883 (scan_appSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_APP ]),
884 APP_SCAN_EVENT_SCAN_COMPLETE );
885 break;
886
887 case SCAN_SCC_DRIVER:
888 scanConcentratorDrvSM_SMEvent( hScanCncn,
889 (scan_drvSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ]),
890 scanConcentrator_getNextDriverEvent( hScanCncn ) );
891 break;
892
893 case SCAN_SCC_ROAMING_CONT:
894 /* copy the SPS scan result (in case this was an SPS scan) */
895 pScanConcentrator->SPSScanResult = SPSStatus;
896
897 /* if A TSF error occurred (for non-SPS scans this value is always FALSE!), and no previous error occurred,
898 mark this error */
899 if ( (SCAN_CRS_SCAN_COMPLETE_OK ==
900 pScanConcentrator->scanResult[ pScanConcentrator->currentRunningScanClient ]) &&
901 (TRUE == bTSFError) )
902 {
903 pScanConcentrator->scanResult[ pScanConcentrator->currentRunningScanClient ] = SCAN_CRS_TSF_ERROR;
904 }
905 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
906 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
907 CONT_SCAN_EVENT_SCAN_COMPLETE );
908 break;
909
910 case SCAN_SCC_ROAMING_IMMED:
911 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn,
912 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]),
913 IMMED_SCAN_EVENT_SCAN_COMPLETE );
914 break;
915
916 default:
917 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
918 ("Scan complete notification with illegal client %d, aborting request.\n", pScanConcentrator->currentRunningScanClient) );
919 break;
920 }
921 }
922
923 /**
924 * \author Ronen Kalish\n
925 * \date 02-Jan-2005\n
926 * \brief Called by the MLME parser to pass information received on a beacon or probe response.
927 *
928 * Function Scope \e Public.\n
929 * \param hScanCncn - handle to the scan concentrator object.\n
930 * \param bssid - a pointer to the address of the AP sending this frame.\n
931 * \param frameInfo - the IE in the frame.\n
932 * \param pRxAttr - a pointer to TNET RX attributes struct.\n
933 * \param buffer - a pointer to the frame body.\n
934 * \param byfferLength - the frame body length.\n
935 */
scanConcentrator_mlmeResultCB(TI_HANDLE hScanCncn,macAddress_t * bssid,mlmeFrameInfo_t * frameInfo,Rx_attr_t * pRxAttr,UINT8 * buffer,UINT16 bufferLength)936 void scanConcentrator_mlmeResultCB( TI_HANDLE hScanCncn, macAddress_t* bssid, mlmeFrameInfo_t* frameInfo,
937 Rx_attr_t* pRxAttr, UINT8* buffer, UINT16 bufferLength )
938 {
939 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
940 paramInfo_t param;
941 scan_frameInfo_t scanFrameInfo;
942
943 /* verify that there is a running client (in case the result arrived after the scan complete event) */
944 switch (pScanConcentrator->currentRunningScanClient)
945 {
946 case SCAN_SCC_APP:
947 if ( APP_SCAN_STATE_IDLE == pScanConcentrator->clientSMState[ SCAN_SCC_APP ] )
948 {
949 return;
950 }
951 break;
952
953 case SCAN_SCC_DRIVER:
954 if ( DRV_SCAN_STATE_IDLE == pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ] )
955 {
956 return;
957 }
958 break;
959
960 case SCAN_SCC_ROAMING_CONT:
961 if ( CONT_SCAN_STATE_IDLE == pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ] )
962 {
963 return;
964 }
965 /* check that the SSID IE exists in the frame received */
966 if (frameInfo->content.iePacket.pSsid==NULL)
967 {
968 /* Discard sites with no SID IE */
969 return;
970 }
971 /* check that scan results are not from current BSS */
972 param.paramType = CTRL_DATA_CURRENT_BSSID_PARAM;
973 ctrlData_getParam( pScanConcentrator->hCtrlData, ¶m );
974 if (( 0 == os_memoryCompare( pScanConcentrator->hOS,
975 (void *)&(bssid->addr[ 0 ]),
976 (void *)&(param.content.ctrlDataCurrentBSSID.addr[ 0 ]),
977 MAC_ADDR_LEN ) ) ||
978 (( os_memoryCompare( pScanConcentrator->hOS,
979 (PUINT8)frameInfo->content.iePacket.pSsid->serviceSetId,
980 (PUINT8)pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].desiredSsid.ssidString,
981 pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].desiredSsid.len )) &&
982 pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_CONT ].scanType != SCAN_TYPE_SPS) )
983 {
984 /* reply from current site - discard it (by returning w/o notifying the scan manager */
985 /* Also discard sites with different SSID than the desired */
986 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
987 ("Cont scan: discarding frame from SSID: %s, BSSID: %2x:%2x:%2x:%2x:%2x:%2x, because SSID different from desired or from current AP!\n",
988 frameInfo->content.iePacket.pSsid->serviceSetId, bssid->addr[ 0 ],
989 bssid->addr[ 1 ], bssid->addr[ 2 ], bssid->addr[ 3 ],
990 bssid->addr[ 4 ], bssid->addr[ 5 ]) );
991 return;
992 }
993
994 break;
995
996 case SCAN_SCC_ROAMING_IMMED:
997 if ( IMMED_SCAN_STATE_IDLE == pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ] )
998 {
999 return;
1000 }
1001 /* check that the SSID IE exists in the frame received */
1002 if (frameInfo->content.iePacket.pSsid==NULL)
1003 {
1004 /* Discard sites with no SID IE */
1005 return;
1006 }
1007 /* check that scan results are not from current BSS */
1008 param.paramType = CTRL_DATA_CURRENT_BSSID_PARAM;
1009 ctrlData_getParam( pScanConcentrator->hCtrlData, ¶m );
1010 if (( 0 == os_memoryCompare( pScanConcentrator->hOS,
1011 (PUINT8)&(bssid->addr[ 0 ]),
1012 (PUINT8)&(param.content.ctrlDataCurrentBSSID.addr[ 0 ]),
1013 MAC_ADDR_LEN ) ) ||
1014 ( os_memoryCompare( pScanConcentrator->hOS,
1015 (PUINT8)frameInfo->content.iePacket.pSsid->serviceSetId,
1016 (PUINT8)pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].desiredSsid.ssidString,
1017 pScanConcentrator->clientScanParams[ SCAN_SCC_ROAMING_IMMED ].desiredSsid.len )))
1018
1019 {
1020 /* reply from current site - discard it (by returning w/o notifying the scan manager */
1021 /* Also discard sites with different SSID than the desired */
1022 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1023 ("Immed scan: discarding frame from SSID: %s, BSSID: %2x:%2x:%2x:%2x:%2x:%2x, because SSID different from desired or from current AP!\n",
1024 frameInfo->content.iePacket.pSsid->serviceSetId, bssid->addr[ 0 ],
1025 bssid->addr[ 1 ], bssid->addr[ 2 ], bssid->addr[ 3 ],
1026 bssid->addr[ 4 ], bssid->addr[ 5 ]) );
1027 return;
1028 }
1029 break;
1030
1031 default:
1032 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1033 ("Scan result with illegal client %d, aborting request.\n", pScanConcentrator->currentRunningScanClient) );
1034 return;
1035 /* break; - unreachable */
1036 }
1037
1038 /* build the scan frame info object */
1039 scanFrameInfo.bssId = bssid;
1040 scanFrameInfo.band = (radioBand_e)pRxAttr->band;
1041 scanFrameInfo.channel = pRxAttr->channel;
1042 scanFrameInfo.parsedIEs = frameInfo;
1043 scanFrameInfo.rate = pRxAttr->Rate;
1044 scanFrameInfo.rssi = pRxAttr->Rssi;
1045 scanFrameInfo.staTSF = pRxAttr->TimeStamp;
1046 scanFrameInfo.buffer = buffer;
1047 scanFrameInfo.bufferLength = bufferLength;
1048
1049 /* call the client result CB, according to the running client type */
1050 if ( NULL != pScanConcentrator->scanResultCB[ pScanConcentrator->currentRunningScanClient ] )
1051 {
1052 pScanConcentrator->scanResultCB[ pScanConcentrator->currentRunningScanClient ](
1053 pScanConcentrator->scanResultCBObj[ pScanConcentrator->currentRunningScanClient ],
1054 SCAN_CRS_RECEIVED_FRAME,
1055 &scanFrameInfo,
1056 0xffff ); /* SPS status is only valid on SPS scan complete */
1057 }
1058 }
1059
1060 /**
1061 * \author Ronen Kalish\n
1062 * \date 02-Jan-2005\n
1063 * \brief Called by the SCR (after registration) to notify the scan concentrator of a status change
1064 * \brief for the immediate scan for roaming client.
1065 *
1066 * Function Scope \e Public.\n
1067 * \param hScanCncn - handle to the scan concentrator object.\n
1068 * \param requestStatus - the continuous scan for roaming client status.\n
1069 */
scanConcentrator_scrRoamingImmedCB(TI_HANDLE hScanCncn,scr_clientRequestStatus_e requestStatus,scr_pendReason_e pendReason)1070 void scanConcentrator_scrRoamingImmedCB( TI_HANDLE hScanCncn, scr_clientRequestStatus_e requestStatus,
1071 scr_pendReason_e pendReason )
1072 {
1073 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
1074
1075 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1076 ("Immed. romaing CB called by SCR. Status is: %d, pend reason: %d.\n",
1077 requestStatus, pendReason) );
1078
1079 /* act according to the request staus */
1080 switch ( requestStatus )
1081 {
1082 case SCR_CRS_RUN:
1083 /* send an SCR run event to the SM */
1084 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn,
1085 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]),
1086 IMMED_SCAN_EVENT_SCR_RUN );
1087 break;
1088
1089 case SCR_CRS_PEND:
1090 /* if pending reason has changed to different group - send a reject event
1091 (should only happen when pending) */
1092 if ( SCR_PR_DIFFERENT_GROUP_RUNNING == pendReason )
1093 {
1094 /* send an SCR reject event to the SM - would not scan when not performing roaming */
1095 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] = SCAN_CRS_SCAN_FAILED;
1096 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn,
1097 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]),
1098 IMMED_SCAN_EVENT_SCR_REJECT );
1099 }
1100 else
1101 {
1102 /* send an SCR pend event to the SM */
1103 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn,
1104 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]),
1105 IMMED_SCAN_EVENT_SCR_PEND );
1106 }
1107 break;
1108
1109 case SCR_CRS_FW_RESET:
1110 /* if no previous error has occurred, change the state to FW reset */
1111 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] )
1112 {
1113 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_IMMED ] = SCAN_CRS_SCAN_ABORTED_FW_RESET;
1114 }
1115
1116 /* start built-in test timer */
1117 healthMonitor_resumePeriodicTest( pScanConcentrator->hHealthMonitor );
1118
1119 /* send a FW reset event to the SM */
1120 scanConcentratorRoamingImmedSM_SMEvent( hScanCncn,
1121 (scan_immedSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_IMMED ]),
1122 IMMED_SCAN_EVENT_FW_RESET );
1123 break;
1124
1125 case SCR_CRS_ABORT:
1126 /* This should never happen, report error */
1127 default:
1128 WLAN_REPORT_ERROR( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1129 ("Illegal SCR request status: %d.\n", requestStatus) );
1130 break;
1131 }
1132 }
1133
1134 /**
1135 * \author Ronen Kalish\n
1136 * \date 02-Jan-2005\n
1137 * \brief Called by the SCR (after registration) to notify the scan concentrator of a status change
1138 * \brief for the continuous scan for roaming client.
1139 *
1140 * Function Scope \e Public.\n
1141 * \param hScanCncn - handle to the scan concentrator object.\n
1142 * \param requestStatus - the continuous scan for roaming client status.\n
1143 */
scanConcentrator_scrRoamingContCB(TI_HANDLE hScanCncn,scr_clientRequestStatus_e requestStatus,scr_pendReason_e pendReason)1144 void scanConcentrator_scrRoamingContCB( TI_HANDLE hScanCncn, scr_clientRequestStatus_e requestStatus,
1145 scr_pendReason_e pendReason )
1146 {
1147 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
1148
1149 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1150 ("Cont. romaing CB called by SCR. Status is: %d, pend reason: %d.\n",
1151 requestStatus, pendReason) );
1152
1153 /* act according to the request staus */
1154 switch ( requestStatus )
1155 {
1156 case SCR_CRS_RUN:
1157 /* send an SCR run event to the SM */
1158 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
1159 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
1160 CONT_SCAN_EVENT_SCR_RUN );
1161 break;
1162
1163 case SCR_CRS_PEND:
1164 /* if pending reason has changed to different group - send a reject event
1165 (should only happen when pending) */
1166 if ( SCR_PR_DIFFERENT_GROUP_RUNNING == pendReason )
1167 {
1168 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_FAILED;
1169 /* send an SCR reject event to the SM - would not scan when not connected */
1170 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
1171 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
1172 CONT_SCAN_EVENT_SCR_REJECT );
1173 }
1174 else
1175 {
1176 /* send an SCR pend event to the SM */
1177 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
1178 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
1179 CONT_SCAN_EVENT_SCR_PEND );
1180 }
1181 break;
1182
1183 case SCR_CRS_FW_RESET:
1184 /* if no previous error has occurred, change the state to FW reset */
1185 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] )
1186 {
1187 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_ABORTED_FW_RESET;
1188 }
1189
1190 /* start built-in test timer */
1191 healthMonitor_resumePeriodicTest( pScanConcentrator->hHealthMonitor );
1192
1193 /* send a FW reset event to the SM */
1194 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
1195 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
1196 CONT_SCAN_EVENT_FW_RESET );
1197 break;
1198
1199 case SCR_CRS_ABORT:
1200 /* set the abort or stop flag (to identify when to exit driver mode (stop) and
1201 when not (abort due to higher priority client) */
1202
1203 pScanConcentrator->bAbortOrStop = SCAN_CNCN_ABORT;
1204
1205 /* if no previous error has occurred, change the state to abort (according to reason) */
1206 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] )
1207 {
1208 pScanConcentrator->scanResult[ SCAN_SCC_ROAMING_CONT ] = SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY;
1209 }
1210
1211 /* send an abort scan event to the SM */
1212 scanConcentratorRoamingContSM_SMEvent( hScanCncn,
1213 (scan_contSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_ROAMING_CONT ]),
1214 CONT_SCAN_EVENT_ABORT_SCAN );
1215 break;
1216
1217 default:
1218 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1219 ("Illegal SCR request status: %d.\n", requestStatus) );
1220 break;
1221 }
1222 }
1223
1224 /**
1225 * \author Ronen Kalish\n
1226 * \date 02-Jan-2005\n
1227 * \brief Called by the SCR (after registration) to notify the scan concentrator of a status change
1228 * \brief for the Application scan client.
1229 *
1230 * Function Scope \e Public.\n
1231 * \param hScanCncn - handle to the scan concentrator object.\n
1232 * \param requestStatus - the application scan status.\n
1233 * \param pendReason - the reason for pend status, if the status is pend.\n
1234 */
scanConcentrator_scrAppCB(TI_HANDLE hScanCncn,scr_clientRequestStatus_e requestStatus,scr_pendReason_e pendReason)1235 void scanConcentrator_scrAppCB( TI_HANDLE hScanCncn, scr_clientRequestStatus_e requestStatus,
1236 scr_pendReason_e pendReason )
1237 {
1238 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
1239
1240 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1241 ("App. CB called by SCR. Status is: %d, pend reason: %d.\n",
1242 requestStatus, pendReason) );
1243
1244 /* act according to the request staus */
1245 switch ( requestStatus )
1246 {
1247 /* Note: pend is not handled because application scan cancel its scan request when it receives pend
1248 as the SCR request result, and thus it is assumed that the application scan request will never be
1249 pending */
1250
1251 case SCR_CRS_RUN:
1252 /* send an SCR run event to the SM */
1253 scanConcentratorAppSM_SMEvent( hScanCncn,
1254 (scan_appSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_APP ]),
1255 APP_SCAN_EVENT_SCR_RUN );
1256 break;
1257
1258 case SCR_CRS_FW_RESET:
1259 /* if no previous error has occurred, change the state to FW reset */
1260 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_APP ] )
1261 {
1262 pScanConcentrator->scanResult[ SCAN_SCC_APP ] = SCAN_CRS_SCAN_ABORTED_FW_RESET;
1263 }
1264
1265 /* start built-in test timer */
1266 healthMonitor_resumePeriodicTest( pScanConcentrator->hHealthMonitor );
1267
1268 /* send a FW reset event to the SM */
1269 scanConcentratorAppSM_SMEvent( hScanCncn,
1270 (scan_appSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_APP ]),
1271 APP_SCAN_EVENT_FW_RESET );
1272 break;
1273
1274 case SCR_CRS_ABORT:
1275 /* set the abort or stop flag (to identify when to exit driver mode (stop) and
1276 when not (abort due to higher priority client) */
1277
1278 pScanConcentrator->bAbortOrStop = SCAN_CNCN_ABORT;
1279
1280 /* if no previous error has occurred, change the state to abort (according to reason) */
1281 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_APP ] )
1282 {
1283 pScanConcentrator->scanResult[ SCAN_SCC_APP ] = SCAN_CRS_SCAN_ABORTED_HIGHER_PRIORITY;
1284 }
1285
1286 /* send an abort scan event to the SM */
1287 scanConcentratorAppSM_SMEvent( hScanCncn,
1288 (scan_appSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_APP ]),
1289 APP_SCAN_EVENT_ABORT_SCAN );
1290 break;
1291
1292 default:
1293 WLAN_REPORT_WARNING( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1294 ("Illegal SCR request status: %d.\n", requestStatus) );
1295 break;
1296 }
1297 }
1298
1299 /**
1300 * \author Ronen Kalish\n
1301 * \date 02-Jan-2005\n
1302 * \brief Called by the SCR (after registration) to notify the scan concentrator of a status change
1303 * \brief for the driver scan client.
1304 *
1305 * Function Scope \e Public.\n
1306 * \param hScanCncn - handle to the scan concentrator object.\n
1307 * \param requestStatus - the driver scan status.\n
1308 * \param pendReason - the reason for pend status, if the status is pend.\n
1309 */
scanConcentrator_scrDriverCB(TI_HANDLE hScanCncn,scr_clientRequestStatus_e requestStatus,scr_pendReason_e pendReason)1310 void scanConcentrator_scrDriverCB( TI_HANDLE hScanCncn, scr_clientRequestStatus_e requestStatus,
1311 scr_pendReason_e pendReason )
1312 {
1313 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
1314
1315 WLAN_REPORT_INFORMATION( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1316 ("Driver CB called by SCR. Status is: %d, pend reason: %d.\n",
1317 requestStatus, pendReason) );
1318
1319 /* act according to the request staus */
1320 switch ( requestStatus )
1321 {
1322 case SCR_CRS_RUN:
1323 /* send the next event to the SM */
1324 scanConcentratorDrvSM_SMEvent( hScanCncn,
1325 (scan_drvSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ]),
1326 scanConcentrator_getNextDriverEvent( hScanCncn ) );
1327 break;
1328
1329 case SCR_CRS_PEND:
1330 /* a pend event should only be sent when the SM is waiting for the SCR */
1331 if ( pendReason == SCR_PR_DIFFERENT_GROUP_RUNNING )
1332 {
1333 /* send a reject event - should not perform scan if not in connecting mode */
1334 pScanConcentrator->scanResult[ SCAN_SCC_DRIVER ] = SCAN_CRS_SCAN_FAILED;
1335 scanConcentratorDrvSM_SMEvent( hScanCncn,
1336 (scan_drvSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ]),
1337 DRV_SCAN_EVENT_SCR_REJECT );
1338 }
1339 else
1340 {
1341 /* send a pend event */
1342 scanConcentratorDrvSM_SMEvent( hScanCncn,
1343 (scan_drvSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ]),
1344 DRV_SCAN_EVENT_SCR_PEND );
1345 }
1346 break;
1347
1348 case SCR_CRS_FW_RESET:
1349 /* if no previous error has occurred, change the state to FW reset */
1350 if ( SCAN_CRS_SCAN_COMPLETE_OK == pScanConcentrator->scanResult[ SCAN_SCC_DRIVER ] )
1351 {
1352 pScanConcentrator->scanResult[ SCAN_SCC_DRIVER ] = SCAN_CRS_SCAN_ABORTED_FW_RESET;
1353 }
1354
1355 /* start built-in test timer */
1356 healthMonitor_resumePeriodicTest( pScanConcentrator->hHealthMonitor );
1357
1358 /* send a FW reset event to the SM */
1359 scanConcentratorDrvSM_SMEvent( hScanCncn,
1360 (scan_drvSMStates_e*)&(pScanConcentrator->clientSMState[ SCAN_SCC_DRIVER ]),
1361 DRV_SCAN_EVENT_FW_RESET );
1362 break;
1363
1364 case SCR_CRS_ABORT:
1365 /* This should never happen, report error */
1366 default:
1367 WLAN_REPORT_ERROR( pScanConcentrator->hReport, SCAN_CNCN_MODULE_LOG,
1368 ("Illegal SCR request status: %d.\n", requestStatus) );
1369 break;
1370 }
1371 }
1372
1373 /**
1374 * \author Ronen Kalish\n
1375 * \date 09-Jan-2005\n
1376 * \brief Verifies that specified channels are allowed for the specified scan type, and removes those that are not.\n
1377 *
1378 * Function Scope \e Private.\n
1379 * \param hScanCncn - handle to the scan concentrator object.\n
1380 * \param pScanParams - a pointer to the structure holding the scan params (inc. channels and scan type).\n
1381 */
scanConcentrator_verifyChannelsWithRegDomain(TI_HANDLE hScanCncn,scan_Params_t * pScanParams)1382 void scanConcentrator_verifyChannelsWithRegDomain( TI_HANDLE hScanCncn, scan_Params_t* pScanParams )
1383 {
1384 paramInfo_t param;
1385 UINT8 i,j,k;
1386 UINT8 tempChannelList[ SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND ];
1387 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
1388
1389 /* if no channels were given by the user, get all channels from reg domain */
1390 if ( 0 == pScanParams->numOfChannels )
1391 {
1392 /* SPS cannot be performed when the user does not define the channels! */
1393 if ( SCAN_TYPE_SPS != pScanParams->scanType )
1394 {
1395 UINT validChannelsCnt=0;
1396
1397 /* extract the channel list (channel numbers) from the bitmap */
1398 i = SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND;
1399 /*scanConcentrator_ExtractBitmapToList( pScanParams->band, &(tmpChannelBitmap[0]), &(tempChannelList[0]), &i );*/
1400
1401 param.paramType = REGULATORY_DOMAIN_ALL_SUPPORTED_CHANNELS;
1402 param.content.siteMgrRadioBand = pScanParams->band;
1403 /*param.content.supportedChannels.listOfChannels = tempChannelList;*/
1404 regulatoryDomain_getParam( pScanConcentrator->hRegulatoryDomain, ¶m );
1405 i = param.content.supportedChannels.sizeOfList;
1406 if (i > SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND)
1407 {
1408 i = SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND;
1409 }
1410 os_memoryCopy(pScanConcentrator->hOS, tempChannelList, param.content.supportedChannels.listOfChannels, i);
1411 /* add default values to channels extracted from the bitmap */
1412 for ( j = 0; j < i; j++ )
1413 {
1414
1415 param.paramType = REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES;
1416 param.content.channelCapabilityReq.band = pScanParams->band;
1417 if ( (pScanParams->scanType == SCAN_TYPE_NORMAL_PASSIVE) ||
1418 (pScanParams->scanType == SCAN_TYPE_TRIGGERED_PASSIVE) ||
1419 (pScanParams->scanType == SCAN_TYPE_SPS) )
1420 {
1421 param.content.channelCapabilityReq.scanOption = PASSIVE_SCANNING;
1422 }
1423 else
1424 {
1425 param.content.channelCapabilityReq.scanOption = ACTIVE_SCANNING;
1426 }
1427 param.content.channelCapabilityReq.channelNum = tempChannelList[ j ];
1428 regulatoryDomain_getParam( pScanConcentrator->hRegulatoryDomain, ¶m );
1429 if (param.content.channelCapabilityRet.channelValidity == TRUE)
1430 {
1431 /* add the channel ID */
1432 pScanParams->channelEntry[ j ].normalChannelEntry.channel = tempChannelList[ j ];
1433 /* add other default parameters */
1434 pScanParams->channelEntry[ j ].normalChannelEntry.minChannelDwellTime =
1435 SCAN_DEFAULT_MIN_CHANNEL_DWELL_TIME;
1436 pScanParams->channelEntry[ j ].normalChannelEntry.maxChannelDwellTime =
1437 SCAN_DEFAULT_MAX_CHANNEL_DWELL_TIME;
1438 pScanParams->channelEntry[ j ].normalChannelEntry.earlyTerminationEvent =
1439 SCAN_DEFAULT_EARLY_TERMINATION_EVENT;
1440 pScanParams->channelEntry[ j ].normalChannelEntry.ETMaxNumOfAPframes =
1441 SCAN_DEFAULT_EARLY_TERMINATION_NUM_OF_FRAMES;
1442 pScanParams->channelEntry[ j ].normalChannelEntry.txPowerDbm = param.content.channelCapabilityRet.maxTxPowerDbm;
1443
1444 /* Fill broadcast BSSID */
1445 for ( k = 0; k < 6; k++ )
1446 {
1447 pScanParams->channelEntry[ j ].normalChannelEntry.bssId.addr[ k ] = 0xff;
1448 }
1449
1450 validChannelsCnt++;
1451 }
1452 }
1453 pScanParams->numOfChannels = validChannelsCnt;
1454 }
1455 }
1456 /* channels were supplied by user - must verify that all of them are allowed */
1457 else
1458 {
1459 /* check channels */
1460 for ( i = 0; i < pScanParams->numOfChannels; )
1461 { /* Note that i is only increased when channel is valid - if channel is invalid, another
1462 channel is copied in its place, and thus the same index should be checked again. However,
1463 since the number of channels is decreased, the loop end condition is getting nearer! */
1464
1465 param.paramType = REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES;
1466 param.content.channelCapabilityReq.band = pScanParams->band;
1467 if ( (pScanParams->scanType == SCAN_TYPE_NORMAL_PASSIVE) ||
1468 (pScanParams->scanType == SCAN_TYPE_TRIGGERED_PASSIVE) ||
1469 (pScanParams->scanType == SCAN_TYPE_SPS) )
1470 {
1471 param.content.channelCapabilityReq.scanOption = PASSIVE_SCANNING;
1472 }
1473 else
1474 {
1475 param.content.channelCapabilityReq.scanOption = ACTIVE_SCANNING;
1476 }
1477
1478 /* SPS scan */
1479 if ( SCAN_TYPE_SPS == pScanParams->scanType )
1480 {
1481 param.content.channelCapabilityReq.channelNum = pScanParams->channelEntry[ i ].SPSChannelEntry.channel;
1482 regulatoryDomain_getParam( pScanConcentrator->hRegulatoryDomain, ¶m );
1483 if (!param.content.channelCapabilityRet.channelValidity)
1484 { /* channel not allowed - copy the rest of the channel in its place */
1485 os_memoryCopy( pScanConcentrator->hOS, &(pScanParams->channelEntry[ i ]),
1486 &(pScanParams->channelEntry[ i + 1 ]), sizeof(scan_SPSChannelEntry_t) *
1487 (pScanParams->numOfChannels - i - 1) );
1488 pScanParams->numOfChannels--;
1489 }
1490 else
1491 {
1492 i += 1;
1493 }
1494
1495 }
1496 /* all other scan types */
1497 else
1498 {
1499 param.content.channelCapabilityReq.channelNum = pScanParams->channelEntry[ i ].normalChannelEntry.channel;
1500 regulatoryDomain_getParam( pScanConcentrator->hRegulatoryDomain, ¶m );
1501 if (!param.content.channelCapabilityRet.channelValidity)
1502 { /* channel not allowed - copy the rest of the channel in its place */
1503 os_memoryCopy( pScanConcentrator->hOS, &(pScanParams->channelEntry[ i ]),
1504 &(pScanParams->channelEntry[ i + 1 ]), sizeof(scan_normalChannelEntry_t) *
1505 (pScanParams->numOfChannels - i - 1) );
1506 pScanParams->numOfChannels--;
1507 }
1508 else
1509 {
1510 pScanParams->channelEntry[i].normalChannelEntry.txPowerDbm =
1511 MIN( param.content.channelCapabilityRet.maxTxPowerDbm,
1512 pScanParams->channelEntry[i].normalChannelEntry.txPowerDbm );
1513
1514 i += 1;
1515 }
1516 }
1517 }
1518 }
1519 }
1520
1521 /**
1522 * \author Yuval Adler\n
1523 * \date 26-Jan-2006\n
1524 * \brief enable/disable the use of SG parameters , and update parameters of next scans
1525 * requests for minDwellTime,MaxDwellTime,numProbeReq .\n
1526 * this function is called when SG is enabled or disabled from the SoftGemini module
1527 * The compensation is needed since BT Activity holds the antenna and over-ride Scan activity
1528 *
1529 * Function Scope \e Private.\n
1530 * \param hScanCncn - handle to the scan concentrator object.\n
1531 * \param bUseSGParams - whether to use the new parameters (TRUE when SG is enabled)
1532 * \param probeReqNumber -
1533 * \param SGcompensationMaxTime - max value from which we won't increase dwelling time
1534 * \param SGcompensationPercent - increasing dwell time in that percentage
1535 */
scanConcentrator_SGconfigureScanParams(TI_HANDLE hScanCncn,BOOL bUseSGParams,UINT8 probeReqNumber,UINT32 SGcompensationMaxTime,UINT32 SGcompensationPercent)1536 void scanConcentrator_SGconfigureScanParams( TI_HANDLE hScanCncn, BOOL bUseSGParams ,
1537 UINT8 probeReqNumber , UINT32 SGcompensationMaxTime,
1538 UINT32 SGcompensationPercent)
1539 {
1540 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
1541
1542 pScanConcentrator->bUseSGParams = bUseSGParams;
1543 pScanConcentrator->SGnumOfProbeRequest = probeReqNumber;
1544 pScanConcentrator->SGcompensationMaxTime = SGcompensationMaxTime;
1545 pScanConcentrator->SGcompensationPercent = SGcompensationPercent;
1546
1547 WLAN_REPORT_INFORMATION(pScanConcentrator->hReport,SCAN_CNCN_MODULE_LOG,
1548 ("%s: bUseSGParams = %d, numOfProbeRequest = %d, compensationMaxTime = %d, SGcompensationPercent = %d\n "
1549 ,__FUNCTION__,pScanConcentrator->bUseSGParams,pScanConcentrator->SGnumOfProbeRequest,
1550 pScanConcentrator->SGcompensationMaxTime,pScanConcentrator->SGcompensationPercent));
1551 }
1552
1553 /**
1554 * \author Yuval Adler\n
1555 * \date 26-Jan-2006\n
1556 * \brief update minDwellTime,MaxDwellTime,numProbeReq according to SG module request .\n
1557 * this function is called when SG is enabled.
1558 * Function Scope \e Private.\n
1559 * \param hScanCncn - handle to the scan concentrator object.\n
1560 * \param pScanParams - a pointer to the structure holding the scan params .\n
1561 */
scanConcentrator_SGupdateScanParams(TI_HANDLE hScanCncn,scan_Params_t * pScanParams)1562 void scanConcentrator_SGupdateScanParams( TI_HANDLE hScanCncn, scan_Params_t* pScanParams )
1563 {
1564 scanConcentrator_t* pScanConcentrator = (scanConcentrator_t*)hScanCncn;
1565 UINT8 i;
1566 UINT32 tempTime;
1567
1568 /* for each channel increase the min and max dwell time */
1569 for ( i = 0 ; i < pScanParams->numOfChannels ; i++)
1570 {
1571 if (pScanConcentrator->SGcompensationMaxTime >
1572 pScanParams->channelEntry[i].normalChannelEntry.minChannelDwellTime)
1573 {
1574 tempTime = ((pScanParams->channelEntry[i].normalChannelEntry.minChannelDwellTime) *
1575 ( 100 + pScanConcentrator->SGcompensationPercent)) / 100 ;
1576
1577 if (tempTime > pScanConcentrator->SGcompensationMaxTime)
1578 {
1579 tempTime = pScanConcentrator->SGcompensationMaxTime;
1580 }
1581 pScanParams->channelEntry[i].normalChannelEntry.minChannelDwellTime = tempTime;
1582 }
1583
1584 if (pScanConcentrator->SGcompensationMaxTime >
1585 pScanParams->channelEntry[i].normalChannelEntry.maxChannelDwellTime)
1586 {
1587 tempTime = ((pScanParams->channelEntry[i].normalChannelEntry.maxChannelDwellTime) *
1588 ( 100 + pScanConcentrator->SGcompensationPercent)) / 100 ;
1589
1590 if (tempTime > pScanConcentrator->SGcompensationMaxTime)
1591 {
1592 tempTime = pScanConcentrator->SGcompensationMaxTime;
1593 }
1594 pScanParams->channelEntry[i].normalChannelEntry.maxChannelDwellTime = tempTime;
1595 }
1596 WLAN_REPORT_INFORMATION(pScanConcentrator->hReport,SCAN_CNCN_MODULE_LOG,
1597 ("%s new parmas : channel = %d MaxDwellTime = %d MinDwellTime = %d\n"
1598 ,__FUNCTION__,i,pScanParams->channelEntry[i].normalChannelEntry.maxChannelDwellTime,
1599 pScanParams->channelEntry[i].normalChannelEntry.minChannelDwellTime));
1600 }
1601
1602 /* update ProbeReqNumber only if it is larger than 0 and smaller than the new value */
1603 if ((pScanParams->probeReqNumber > 0) &&
1604 (pScanConcentrator->SGnumOfProbeRequest > pScanParams->probeReqNumber))
1605 {
1606 pScanParams->probeReqNumber = pScanConcentrator->SGnumOfProbeRequest;
1607 }
1608
1609 WLAN_REPORT_INFORMATION(pScanConcentrator->hReport,SCAN_CNCN_MODULE_LOG,
1610 ("%s number of Probe requests = %d\n",__FUNCTION__,pScanParams->probeReqNumber));
1611 }
1612
1613
1614