1 /*
2 * ScanCncnOsSm.c
3 *
4 * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 *
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
16 * distribution.
17 * * Neither the name Texas Instruments nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34 /** \file ScanCncnOsSm.c
35 * \brief Scan concentrator OS scan state machine implementation
36 *
37 * \see ScanCncnApp.c
38 */
39
40
41 #define __FILE_ID__ FILE_ID_78
42 #include "osTIType.h"
43 #include "GenSM.h"
44 #include "ScanCncnOsSm.h"
45 #include "ScanCncn.h"
46 #include "ScanCncnPrivate.h"
47 #include "report.h"
48 #include "osApi.h"
49 #include "siteMgrApi.h"
50 #include "regulatoryDomainApi.h"
51 #include "scanResultTable.h"
52
53 #define SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_G RATE_MASK_UNSPECIFIED /* Let the FW select */
54 #define SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_A RATE_MASK_UNSPECIFIED /* Let the FW select */
55 #define SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_G 3
56 #define SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_A 3
57 #define SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_G 100000
58 #define SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_A 100000
59 #define SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_G 30000
60 #define SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_A 30000
61 #define SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_G 100000
62 #define SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_A 100000
63 #define SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_G 15000
64 #define SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_A 15000
65 #define SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_G SCAN_ET_COND_BEACON
66 #define SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_A SCAN_ET_COND_BEACON
67 #define SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_G SCAN_ET_COND_ANY_FRAME
68 #define SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_A SCAN_ET_COND_ANY_FRAME
69
70 /* For WiFi WPA OOB scenario, 4 APs need to be configure on the same channel */
71 #define SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_G 4
72 #define SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_A 4
73 #define SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_G 4
74 #define SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_A 4
75
76 static void scanCncnOsSm_ActionStartGScan (TI_HANDLE hScanCncn);
77 static void scanCncnOsSm_ActionStartAScan (TI_HANDLE hScanCncn);
78 static void scanCncnOsSm_ActionCompleteScan (TI_HANDLE hScanCncn);
79 static void scanCncnOsSm_ActionUnexpected (TI_HANDLE hScanCncn);
80 TI_UINT32 scanCncnOsSm_FillAllAvailableChannels (TI_HANDLE hScanCncn, ERadioBand eBand, EScanType eScanType,
81 TScanChannelEntry *pChannelArray, TI_UINT32 uMaxDwellTime,
82 TI_UINT32 uMinChannelTime, EScanEtCondition eETCondition,
83 TI_UINT8 uETFrameNumber);
84
85
86 static TGenSM_actionCell tSmMatrix[ SCAN_CNCN_OS_SM_NUMBER_OF_STATES ][ SCAN_CNCN_OS_SM_NUMBER_OF_EVENTS ] =
87 {
88 { /* SCAN_CNCN_OS_SM_STATE_IDLE */
89 { SCAN_CNCN_OS_SM_STATE_SCAN_ON_G, scanCncnOsSm_ActionStartGScan }, /* SCAN_CNCN_OS_SM_EVENT_START_SCAN */
90 { SCAN_CNCN_OS_SM_STATE_IDLE, scanCncnOsSm_ActionUnexpected }, /* SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE */
91 },
92 { /* SCAN_CNCN_OS_SM_STATE_SCAN_ON_G */
93 { SCAN_CNCN_OS_SM_STATE_SCAN_ON_G, scanCncnOsSm_ActionUnexpected }, /* SCAN_CNCN_OS_SM_EVENT_START_SCAN */
94 { SCAN_CNCN_OS_SM_STATE_SCAN_ON_A, scanCncnOsSm_ActionStartAScan }, /* SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE */
95 },
96 { /* SCAN_CNCN_OS_SM_STATE_SCAN_ON_A */
97 { SCAN_CNCN_OS_SM_STATE_SCAN_ON_A, scanCncnOsSm_ActionUnexpected }, /* SCAN_CNCN_OS_SM_EVENT_START_SCAN */
98 { SCAN_CNCN_OS_SM_STATE_IDLE, scanCncnOsSm_ActionCompleteScan }, /* SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE */
99 }
100 };
101
102 static TI_INT8 *uStateDescription[] =
103 {
104 "IDLE",
105 "SCAN_ON_G",
106 "SCAN_ON_A"
107 };
108
109 static TI_INT8 *uEventDescription[] =
110 {
111 "START",
112 "SCAN_COMPLETE"
113 };
114
115 /**
116 * \fn scanCncnOsSm_Create
117 * \brief Creates the OS scan state-machine
118 *
119 * creates the OS scan state-machine
120 *
121 * \param hScanCncn - handle to the scan concentrator object
122 * \return Handle to the newly created OS san SM, NULL if an error occured
123 * \sa scanCncnOsSm_Create, scanCncnOsSm_Destroy
124 */
scanCncnOsSm_Create(TI_HANDLE hScanCncn)125 TI_HANDLE scanCncnOsSm_Create (TI_HANDLE hScanCncn)
126 {
127 TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
128
129 return genSM_Create (pScanCncn->hOS);
130 }
131
132 /**
133 * \fn scanCncnOsSm_Init
134 * \brief Initialize the OS scan state-machine
135 *
136 * Initialize the OS scan state-machine
137 *
138 * \param hScanCncn - handle to the scan concentrator object
139 * \return None
140 * \sa scanCncnOsSm_Create
141 */
scanCncnOsSm_Init(TI_HANDLE hScanCncn)142 void scanCncnOsSm_Init (TI_HANDLE hScanCncn)
143 {
144 TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
145
146 /* initialize the state-machine */
147 genSM_Init (pScanCncn->hOSScanSm, pScanCncn->hReport);
148 genSM_SetDefaults (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_NUMBER_OF_STATES, SCAN_CNCN_OS_SM_NUMBER_OF_EVENTS,
149 (TGenSM_matrix)tSmMatrix, SCAN_CNCN_OS_SM_STATE_IDLE, "OS scan SM", uStateDescription,
150 uEventDescription, __FILE_ID__);
151 }
152
153 /**
154 * \fn scanCncnOsSm_Destroy
155 * \brief Destroys the OS scan state-machine
156 *
157 * Destroys the OS scan state-machine
158 *
159 * \param hScanCncn - handle to the scan concentrator object
160 * \return None
161 * \sa scanCncnOsSm_Create
162 */
scanCncnOsSm_Destroy(TI_HANDLE hScanCncn)163 void scanCncnOsSm_Destroy (TI_HANDLE hScanCncn)
164 {
165 TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
166
167 genSM_Unload (pScanCncn->hOSScanSm);
168 }
169
170 /**
171 * \fn scanCncnOsSm_ActionStartGScan
172 * \brief Scan concentartor OS state machine start scan on G action function
173 *
174 * Scan concentartor OS state machine start scan on G action function.
175 * Starts a sacn on G using all allowed channels
176 *
177 * \param hScanCncn - handle to the scan concentartor object
178 * \return None
179 */
scanCncnOsSm_ActionStartGScan(TI_HANDLE hScanCncn)180 void scanCncnOsSm_ActionStartGScan (TI_HANDLE hScanCncn)
181 {
182 TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
183 paramInfo_t tParam;
184 TI_UINT32 uValidChannelsCount;
185 TI_BOOL bRegulatoryDomainEnabled;
186
187 /* if the STA is not configured for G band or dual band, send a scan complete event to the SM */
188 tParam.paramType = SITE_MGR_DESIRED_DOT11_MODE_PARAM;
189 siteMgr_getParam (pScanCncn->hSiteManager, &tParam);
190 if ((DOT11_G_MODE != tParam.content.siteMgrDot11Mode) && (DOT11_DUAL_MODE != tParam.content.siteMgrDot11Mode))
191 {
192 TRACE0(pScanCncn->hReport , REPORT_SEVERITY_INFORMATION , "scanCncnOsSm_ActionStartGScan: STA does not work on 2.4 GHz, continuing to 5.0 GHz scan\n");
193 genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
194 return;
195 }
196
197 /* build scan command header */
198 pScanCncn->tOsScanParams.band = RADIO_BAND_2_4_GHZ;
199 pScanCncn->tOsScanParams.Tid = 255;
200
201 /* query the regulatory domain if 802.11d is in use */
202 tParam.paramType = REGULATORY_DOMAIN_ENABLED_PARAM;
203 regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam );
204 bRegulatoryDomainEnabled = tParam.content.regulatoryDomainEnabled;
205
206 /* Get country code status */
207 tParam.paramType = REGULATORY_DOMAIN_IS_COUNTRY_FOUND;
208 tParam.content.eRadioBand = RADIO_BAND_2_4_GHZ;
209 regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam);
210
211 /* scan type is passive if 802.11d is enabled and country IE was not yet found, active otherwise */
212 if (((TI_TRUE == bRegulatoryDomainEnabled) && (TI_FALSE == tParam.content.bIsCountryFound)) || SCAN_TYPE_TRIGGERED_PASSIVE == pScanCncn->tOsScanParams.scanType)
213 {
214 pScanCncn->tOsScanParams.scanType = SCAN_TYPE_TRIGGERED_PASSIVE;
215 }
216 /* All paramters in the func are hard coded, due to that we set to active if not passive */
217 else
218 {
219 pScanCncn->tOsScanParams.scanType = SCAN_TYPE_TRIGGERED_ACTIVE;
220 /* also set number and rate of probe requests */
221 pScanCncn->tOsScanParams.probeReqNumber = SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_G;
222 pScanCncn->tOsScanParams.probeRequestRate = (ERateMask)SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_G;
223 }
224
225 /* add supported channels on G */
226 if (SCAN_TYPE_NORMAL_PASSIVE == pScanCncn->tOsScanParams.scanType )
227 {
228 uValidChannelsCount = scanCncnOsSm_FillAllAvailableChannels (hScanCncn, RADIO_BAND_2_4_GHZ,
229 SCAN_TYPE_NORMAL_PASSIVE, &(pScanCncn->tOsScanParams.channelEntry[0]),
230 SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_G,
231 SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_G,
232 SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_G,
233 SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_G);
234 }
235 else
236 {
237 uValidChannelsCount = scanCncnOsSm_FillAllAvailableChannels (hScanCncn, RADIO_BAND_2_4_GHZ,
238 SCAN_TYPE_NORMAL_ACTIVE, &(pScanCncn->tOsScanParams.channelEntry[0]),
239 SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_G,
240 SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_G,
241 SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_G,
242 SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_G);
243 }
244 pScanCncn->tOsScanParams.numOfChannels = uValidChannelsCount;
245
246 /* check that some channels are available */
247 if ( uValidChannelsCount > 0 )
248 {
249 EScanCncnResultStatus eResult;
250
251 /* send command to scan concentrator APP SM */
252 eResult = scanCncn_Start1ShotScan (hScanCncn, SCAN_SCC_APP_ONE_SHOT, &(pScanCncn->tOsScanParams));
253
254 /* if scan failed, send scan complete event to the SM */
255 if (SCAN_CRS_SCAN_RUNNING != eResult)
256 {
257 TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionStartGScan: scan failed on 2.4 GHz, continuing to 5.0 GHz scan\n");
258 genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
259 }
260 }
261 else
262 {
263 TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionStartGScan: no valid cahnnels on 2.4 GHz, continuing to 5.0 GHz scan\n");
264 /* no channels to scan, send a scan complete event */
265 genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
266 }
267 }
268
269 /**
270 * \fn scanCncnOsSm_ActionStartAScan
271 * \brief Scan concentartor OS state machine start scan on A action function
272 *
273 * Scan concentartor OS state machine start scan on A action function.
274 * Starts a sacn on A using all allowed channels
275 *
276 * \param hScanCncn - handle to the scan concentartor object
277 * \return None
278 */
scanCncnOsSm_ActionStartAScan(TI_HANDLE hScanCncn)279 void scanCncnOsSm_ActionStartAScan (TI_HANDLE hScanCncn)
280 {
281 TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
282 paramInfo_t tParam;
283 TI_UINT32 uValidChannelsCount;
284 TI_BOOL bRegulatoryDomainEnabled;
285
286 /* if the STA is not configured for G band or dual band, send a scan complete event to the SM */
287 tParam.paramType = SITE_MGR_DESIRED_DOT11_MODE_PARAM;
288 siteMgr_getParam (pScanCncn->hSiteManager, &tParam);
289 if ((DOT11_A_MODE != tParam.content.siteMgrDot11Mode) && (DOT11_DUAL_MODE != tParam.content.siteMgrDot11Mode))
290 {
291 TRACE0(pScanCncn->hReport, REPORT_SEVERITY_INFORMATION , "scanCncnOsSm_ActionStartAScan: STA does not work on 5.0 GHz, quitting\n");
292 genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
293 return;
294 }
295
296 /* build scan command header */
297 pScanCncn->tOsScanParams.band = RADIO_BAND_5_0_GHZ;
298 pScanCncn->tOsScanParams.Tid = 0;
299
300 /* query the regulatory domain if 802.11d is in use */
301 tParam.paramType = REGULATORY_DOMAIN_ENABLED_PARAM;
302 regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam );
303 bRegulatoryDomainEnabled = tParam.content.regulatoryDomainEnabled;
304
305 /* Get country code status */
306 tParam.paramType = REGULATORY_DOMAIN_IS_COUNTRY_FOUND;
307 tParam.content.eRadioBand = RADIO_BAND_5_0_GHZ;
308 regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam);
309
310 /* scan type is passive if 802.11d is enabled and country IE was not yet found, active otherwise */
311 if (((TI_TRUE == bRegulatoryDomainEnabled) && (TI_FALSE == tParam.content.bIsCountryFound)) || SCAN_TYPE_TRIGGERED_PASSIVE == pScanCncn->tOsScanParams.scanType)
312 {
313 pScanCncn->tOsScanParams.scanType = SCAN_TYPE_TRIGGERED_PASSIVE;
314 }
315 /* All paramters in the func are hard coded, due to that we set to active if not passive */
316 else
317 {
318 pScanCncn->tOsScanParams.scanType = SCAN_TYPE_TRIGGERED_ACTIVE;
319 /* also set number and rate of probe requests */
320 pScanCncn->tOsScanParams.probeReqNumber = SCAN_OID_DEFAULT_PROBE_REQUEST_NUMBER_A;
321 pScanCncn->tOsScanParams.probeRequestRate = (ERateMask)SCAN_OID_DEFAULT_PROBE_REQUEST_RATE_A;
322 }
323
324 /* add supported channels on G */
325 if (SCAN_TYPE_NORMAL_PASSIVE == pScanCncn->tOsScanParams.scanType )
326 {
327 uValidChannelsCount = scanCncnOsSm_FillAllAvailableChannels (hScanCncn, RADIO_BAND_5_0_GHZ,
328 SCAN_TYPE_NORMAL_PASSIVE, &(pScanCncn->tOsScanParams.channelEntry[0]),
329 SCAN_OID_DEFAULT_MAX_DWELL_TIME_PASSIVE_A,
330 SCAN_OID_DEFAULT_MIN_DWELL_TIME_PASSIVE_A,
331 SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_PASSIVE_A,
332 SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_PASSIVE_A );
333 }
334 else
335 {
336 uValidChannelsCount = scanCncnOsSm_FillAllAvailableChannels (hScanCncn, RADIO_BAND_5_0_GHZ,
337 SCAN_TYPE_NORMAL_ACTIVE, &(pScanCncn->tOsScanParams.channelEntry[0]),
338 SCAN_OID_DEFAULT_MAX_DWELL_TIME_ACTIVE_A,
339 SCAN_OID_DEFAULT_MIN_DWELL_TIME_ACTIVE_A,
340 SCAN_OID_DEFAULT_EARLY_TERMINATION_EVENT_ACTIVE_A,
341 SCAN_OID_DEFAULT_EARLY_TERMINATION_COUNT_ACTIVE_A );
342 }
343 pScanCncn->tOsScanParams.numOfChannels = uValidChannelsCount;
344
345 /* check that some channels are available */
346 if ( uValidChannelsCount > 0 )
347 {
348 EScanCncnResultStatus eResult;
349
350 /* send command to scan concentrator APP SM */
351 eResult = scanCncn_Start1ShotScan (hScanCncn, SCAN_SCC_APP_ONE_SHOT, &(pScanCncn->tOsScanParams));
352
353 /* if scan failed, send scan complete event to the SM */
354 if (SCAN_CRS_SCAN_RUNNING != eResult)
355 {
356 TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionStartAScan: scan failed on 5.0 GHz, quitting\n");
357 genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
358 }
359 }
360 else
361 {
362 TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionStartGScan: no valid cahnnels on 5.0 GHz, quitting\n");
363 /* no channels to scan, send a scan complete event */
364 genSM_Event (pScanCncn->hOSScanSm, SCAN_CNCN_OS_SM_EVENT_SCAN_COMPLETE, hScanCncn);
365 }
366 }
367
368 /**
369 * \fn scanCncnOsSm_ActionCompleteScan
370 * \brief Scan concentartor OS state machine complete scan action function
371 *
372 * Scan concentartor OS state machine complete scan action function.
373 * Cleans up after an OS scan cycle - stabilize the scan result table
374 *
375 * \param hScanCncn - handle to the scan concentartor object
376 * \return None
377 */
scanCncnOsSm_ActionCompleteScan(TI_HANDLE hScanCncn)378 void scanCncnOsSm_ActionCompleteScan (TI_HANDLE hScanCncn)
379 {
380 TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
381
382
383 /*Update the table only if scan was not rejected*/
384 if ( !pScanCncn->pScanClients[ pScanCncn->eCurrentRunningAppScanClient ]->bScanRejectedOn2_4)
385 {
386 /*
387 * set the result table to stable state. Note: OID scans are always done for the application, so the
388 * results will always be sent to the scan concentartor app scan result table, regardless of the
389 * SME connection mode. However, it is expected that the SME will NOT attempt to connect when an OID
390 * scan request will be received
391 */
392 scanResultTable_SetStableState (pScanCncn->hScanResultTable);
393 }
394 else
395 {
396 pScanCncn->pScanClients[ pScanCncn->eCurrentRunningAppScanClient ]->bScanRejectedOn2_4 = TI_FALSE;
397 }
398
399 /* mark that OID scan process is no longer running */
400 pScanCncn->bOSScanRunning = TI_FALSE;
401 /* also mark that no app scan client is running */
402 pScanCncn->eCurrentRunningAppScanClient = SCAN_SCC_NO_CLIENT;
403
404
405 /* no need to send scan complete event - WZC (or equivalent other OS apps) will query for the results */
406 }
407
408 /**
409 * \fn scanCncnOsSm_FillAllAvailableChannels
410 * \brief Fills a chhanel array with valid channels (and their params) according to band and scan type
411 *
412 * Fills a chhanel array with valid channels (and their params) according to band and scan type
413 *
414 * \param hScanCncn - handle to the scan concentrator object
415 * \param eBand - band to extract channels for
416 * \param eScanType - scan type tp ectract channels for
417 * \param pChannelArray - where to store allowed channels information
418 * \param uMaxDwellTime - maximum dwell time value to be used for each channel
419 * \param uMinDwellTime - minimum dwell time value to be used for each channel
420 * \param eETCondition - early termination condition value to be used for each channel
421 * \param uETFrameNumber - early termination frame number value to be used for each channel
422 * \return Number of allowed channels (that were placed in the given channels array)
423 */
scanCncnOsSm_FillAllAvailableChannels(TI_HANDLE hScanCncn,ERadioBand eBand,EScanType eScanType,TScanChannelEntry * pChannelArray,TI_UINT32 uMaxDwellTime,TI_UINT32 uMinChannelTime,EScanEtCondition eETCondition,TI_UINT8 uETFrameNumber)424 TI_UINT32 scanCncnOsSm_FillAllAvailableChannels (TI_HANDLE hScanCncn, ERadioBand eBand, EScanType eScanType,
425 TScanChannelEntry *pChannelArray, TI_UINT32 uMaxDwellTime,
426 TI_UINT32 uMinChannelTime, EScanEtCondition eETCondition,
427 TI_UINT8 uETFrameNumber)
428 {
429 TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
430 TI_UINT32 i, j, uAllowedChannelsCount, uValidChannelsCnt = 0;
431 paramInfo_t tParam;
432 TI_UINT8 uTempChannelList[ SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND ];
433
434 /* get the numnber of supported channels for this band */
435 tParam.paramType = REGULATORY_DOMAIN_ALL_SUPPORTED_CHANNELS;
436 tParam.content.siteMgrRadioBand = eBand;
437 regulatoryDomain_getParam (pScanCncn->hRegulatoryDomain, &tParam);
438 uAllowedChannelsCount = tParam.content.supportedChannels.sizeOfList;
439
440 /* for the time being don't scan more channels than fit in one command */
441 if (uAllowedChannelsCount > SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND)
442 {
443 uAllowedChannelsCount = SCAN_MAX_NUM_OF_NORMAL_CHANNELS_PER_COMMAND;
444 }
445
446 /* Copy allowed channels to reuse param var */
447 os_memoryCopy (pScanCncn->hOS, uTempChannelList,
448 tParam.content.supportedChannels.listOfChannels, uAllowedChannelsCount );
449
450 /* preapre the param var to request channel allowance for the requested scan type */
451 tParam.paramType = REGULATORY_DOMAIN_GET_SCAN_CAPABILITIES;
452 tParam.content.channelCapabilityReq.band = eBand;
453
454 /* add default values to channels allowed for the requested scan type and band */
455 for (i = 0; i < uAllowedChannelsCount; i++)
456 {
457 /* get specific channel allowance for scan type */
458 if ((eScanType == SCAN_TYPE_NORMAL_PASSIVE) ||
459 (eScanType == SCAN_TYPE_TRIGGERED_PASSIVE) ||
460 (eScanType == SCAN_TYPE_SPS))
461 {
462 tParam.content.channelCapabilityReq.scanOption = PASSIVE_SCANNING;
463 }
464 else
465 {
466 tParam.content.channelCapabilityReq.scanOption = ACTIVE_SCANNING;
467 }
468 tParam.content.channelCapabilityReq.channelNum = uTempChannelList[ i ];
469
470 regulatoryDomain_getParam( pScanCncn->hRegulatoryDomain, &tParam );
471 if (TI_TRUE == tParam.content.channelCapabilityRet.channelValidity)
472 {
473 /* add the channel ID */
474 pChannelArray[ uValidChannelsCnt ].normalChannelEntry.channel = uTempChannelList[ i ];
475
476 /* add other default parameters */
477 pChannelArray[ uValidChannelsCnt ].normalChannelEntry.minChannelDwellTime = uMinChannelTime;
478 pChannelArray[ uValidChannelsCnt ].normalChannelEntry.maxChannelDwellTime = uMaxDwellTime;
479 pChannelArray[ uValidChannelsCnt ].normalChannelEntry.earlyTerminationEvent = eETCondition;
480 pChannelArray[ uValidChannelsCnt ].normalChannelEntry.ETMaxNumOfAPframes = uETFrameNumber;
481 pChannelArray[ uValidChannelsCnt ].normalChannelEntry.txPowerDbm =
482 tParam.content.channelCapabilityRet.maxTxPowerDbm;
483
484 /* Fill broadcast BSSID */
485 for (j = 0; j < 6; j++)
486 {
487 pChannelArray[ uValidChannelsCnt ].normalChannelEntry.bssId[ j ] = 0xff;
488 }
489 uValidChannelsCnt++;
490 }
491 }
492
493 /* return the number of channels that are actually allowed for the requested scan type on the requested band */
494 return uValidChannelsCnt;
495 }
496
497 /**
498 * \fn Function declaration
499 * \brief Function brief description goes here
500 *
501 * Function detailed description goes here
502 *
503 * \note Note is indicated here
504 * \param Parameter name - parameter description
505 * \param �
506 * \return Return code is detailed here
507 * \sa Reference to other relevant functions
508 */
509 /**
510 * \\n
511 * \date 11-Jan-2005\n
512 * \brief Handles an unexpected event.\n
513
514 *
515 * Function Scope \e Private.\n
516 * \param hScanCncn - handle to the scan concentrator object.\n
517 * \return always OK.\n
518 */
scanCncnOsSm_ActionUnexpected(TI_HANDLE hScanCncn)519 void scanCncnOsSm_ActionUnexpected (TI_HANDLE hScanCncn)
520 {
521 TScanCncn *pScanCncn = (TScanCncn*)hScanCncn;
522
523 TRACE0(pScanCncn->hReport, REPORT_SEVERITY_ERROR , "scanCncnOsSm_ActionUnexpected: Unexpeted action for current state\n");
524 }
525
526