|
1 /* |
|
2 * CmdBldCmd.c |
|
3 * |
|
4 * Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved. |
|
5 * All rights reserved. |
|
6 * |
|
7 * This program and the accompanying materials are made available under the |
|
8 * terms of the Eclipse Public License v1.0 or BSD License which accompanies |
|
9 * this distribution. The Eclipse Public License is available at |
|
10 * http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below. |
|
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 /** \file CmdBldCmd.c |
|
41 * \brief Command builder. Commands |
|
42 * |
|
43 * \see CmdBld.h |
|
44 */ |
|
45 |
|
46 #define __FILE_ID__ FILE_ID_93 |
|
47 #include "tidef.h" |
|
48 #include "report.h" |
|
49 #include "TWDriverInternal.h" |
|
50 #include "CmdBld.h" |
|
51 #include "CmdBldCmdIE.h" |
|
52 #include "CmdBldCfgIE.h" |
|
53 #include "CmdQueue_api.h" |
|
54 #include "eventMbox_api.h" |
|
55 |
|
56 |
|
57 /* |
|
58 Rx filter field is mostly hard-coded. |
|
59 This filter value basically pass only valid beacons / probe responses. For exact bit description, |
|
60 consult either the DPG or the FPG (or both, and Yoel...) |
|
61 */ |
|
62 #define RX_FILTER_CFG_ (CFG_RX_PRSP_EN | CFG_RX_MGMT_EN | CFG_RX_BCN_EN | CFG_RX_RCTS_ACK | CFG_RX_CTL_EN) |
|
63 |
|
64 |
|
65 TI_STATUS cmdBld_CmdAddWepKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb); |
|
66 TI_STATUS cmdBld_CmdRemoveWepKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb); |
|
67 TI_STATUS cmdBld_CmdAddWepMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb); |
|
68 TI_STATUS cmdBld_CmdRemoveWepMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb); |
|
69 TI_UINT32 cmdBld_BuildPeriodicScanChannles (TPeriodicScanParams *pPeriodicScanParams, ConnScanChannelInfo_t *pChannelList, EScanType eScanType, ERadioBand eRadioBand, TI_UINT32 uPassiveScanDfsDwellTime); |
|
70 |
|
71 |
|
72 /** |
|
73 * \fn cmdBld_CmdStartScan |
|
74 * \brief Build a start scan command and send it to the FW |
|
75 * |
|
76 * Build a start scan command and send it to the FW |
|
77 * |
|
78 * \param hCmdBld - handle to the command builder object |
|
79 * \param pScanVals - scan parameters |
|
80 * \param eScanTag - scan tag used for scan complete and result tracking |
|
81 * \param fScanCommandResponseCB - command complete CB |
|
82 * \param hCb - command complete CB |
|
83 * \return command status (OK / NOK) |
|
84 * \sa cmdBld_CmdStopScan |
|
85 */ |
|
86 TI_STATUS cmdBld_CmdStartScan (TI_HANDLE hCmdBld, TScanParams *pScanVals, EScanResultTag eScanTag, |
|
87 TI_BOOL bHighPriority, void* ScanCommandResponseCB, TI_HANDLE hCb) |
|
88 { |
|
89 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
90 BasicScanChannelParameters_t* chanPtr; |
|
91 ScanParameters_t tnetScanParams; |
|
92 TI_UINT8* pBSSID; |
|
93 TI_INT32 i; |
|
94 |
|
95 /* Convert general scan data to tnet structure */ |
|
96 tnetScanParams.basicScanParameters.tidTrigger = pScanVals->Tid; |
|
97 tnetScanParams.basicScanParameters.numOfProbRqst = pScanVals->probeReqNumber; |
|
98 tnetScanParams.basicScanParameters.ssidLength = pScanVals->desiredSsid.len; |
|
99 os_memoryCopy (pCmdBld->hOs, |
|
100 (void *)tnetScanParams.basicScanParameters.ssidStr, |
|
101 (void *)pScanVals->desiredSsid.str, |
|
102 tnetScanParams.basicScanParameters.ssidLength); |
|
103 |
|
104 /* |
|
105 scan options field is composed of scan type and band selection. |
|
106 First, use the lookup table to convert the scan type |
|
107 */ |
|
108 |
|
109 tnetScanParams.basicScanParameters.scanOptions = 0; |
|
110 |
|
111 switch ( pScanVals->scanType ) |
|
112 { |
|
113 case SCAN_TYPE_NORMAL_ACTIVE : |
|
114 tnetScanParams.basicScanParameters.scanOptions = SCAN_ACTIVE; |
|
115 break; |
|
116 |
|
117 case SCAN_TYPE_NORMAL_PASSIVE : |
|
118 tnetScanParams.basicScanParameters.scanOptions = SCAN_PASSIVE; |
|
119 break; |
|
120 |
|
121 case SCAN_TYPE_TRIGGERED_ACTIVE : |
|
122 tnetScanParams.basicScanParameters.scanOptions = SCAN_ACTIVE | TRIGGERED_SCAN; |
|
123 break; |
|
124 |
|
125 case SCAN_TYPE_TRIGGERED_PASSIVE : |
|
126 tnetScanParams.basicScanParameters.scanOptions = SCAN_PASSIVE | TRIGGERED_SCAN; |
|
127 break; |
|
128 |
|
129 default: |
|
130 TRACE1( pCmdBld->hReport, REPORT_SEVERITY_ERROR, "Invalid scan type:%d\n", pScanVals->scanType); |
|
131 return TI_NOK; |
|
132 } |
|
133 |
|
134 /* Add the band selection */ |
|
135 if ( RADIO_BAND_5_0_GHZ == pScanVals->band ) |
|
136 { |
|
137 tnetScanParams.basicScanParameters.band = RADIO_BAND_5GHZ; |
|
138 } |
|
139 else |
|
140 { |
|
141 tnetScanParams.basicScanParameters.band = RADIO_BAND_2_4_GHZ; |
|
142 } |
|
143 |
|
144 /* Add high priority bit */ |
|
145 if ( bHighPriority ) |
|
146 { |
|
147 tnetScanParams.basicScanParameters.scanOptions |= SCAN_PRIORITY_HIGH; |
|
148 } |
|
149 |
|
150 tnetScanParams.basicScanParameters.scanOptions = ENDIAN_HANDLE_WORD( tnetScanParams.basicScanParameters.scanOptions ); |
|
151 |
|
152 /* important note: BSSID filter (0x0010) is DISABLED, because the FW sets it according |
|
153 to BSSID value (broadcast does not filter, any other value will */ |
|
154 tnetScanParams.basicScanParameters.rxCfg.ConfigOptions = 0x12802 ; |
|
155 tnetScanParams.basicScanParameters.rxCfg.FilterOptions = ENDIAN_HANDLE_LONG( RX_FILTER_CFG_ ); |
|
156 |
|
157 /* If the SSID is not broadcast SSID, also filter according to SSID */ |
|
158 if (pScanVals->desiredSsid.len != 0) |
|
159 { |
|
160 tnetScanParams.basicScanParameters.rxCfg.ConfigOptions |= BIT_4 | BIT_10; |
|
161 } |
|
162 tnetScanParams.basicScanParameters.rxCfg.ConfigOptions = ENDIAN_HANDLE_LONG( tnetScanParams.basicScanParameters.rxCfg.ConfigOptions ); |
|
163 |
|
164 /* Rate conversion is done in the HAL */ |
|
165 cmdBld_ConvertAppRatesBitmap (pScanVals->probeRequestRate, |
|
166 0, |
|
167 &tnetScanParams.basicScanParameters.txdRateSet); |
|
168 |
|
169 tnetScanParams.basicScanParameters.txdRateSet = ENDIAN_HANDLE_LONG( tnetScanParams.basicScanParameters.txdRateSet ); |
|
170 tnetScanParams.basicScanParameters.numChannels = ENDIAN_HANDLE_WORD( pScanVals->numOfChannels ); |
|
171 |
|
172 /* scan result tag */ |
|
173 tnetScanParams.basicScanParameters.scanTag = eScanTag; |
|
174 |
|
175 /* copy channel specific scan data to HAL structure */ |
|
176 for ( i = 0; i < pScanVals->numOfChannels; i++ ) |
|
177 { |
|
178 TI_INT32 j; |
|
179 TI_UINT8* macAddr; |
|
180 |
|
181 macAddr = (TI_UINT8*)&tnetScanParams.basicScanChannelParameters[ i ].bssIdL; |
|
182 |
|
183 /* copy the MAC address, upside down (CHIP structure) */ |
|
184 for ( j = 0; j < MAC_ADDR_LEN; j++ ) |
|
185 { |
|
186 macAddr[ j ] = pScanVals->channelEntry[ i ].normalChannelEntry.bssId[ MAC_ADDR_LEN - 1 - j ]; |
|
187 } |
|
188 tnetScanParams.basicScanChannelParameters[ i ].scanMinDuration = |
|
189 ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].normalChannelEntry.minChannelDwellTime ); |
|
190 tnetScanParams.basicScanChannelParameters[ i ].scanMaxDuration = |
|
191 ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].normalChannelEntry.maxChannelDwellTime ); |
|
192 tnetScanParams.basicScanChannelParameters[ i ].ETCondCount = |
|
193 pScanVals->channelEntry[ i ].normalChannelEntry.ETMaxNumOfAPframes | |
|
194 pScanVals->channelEntry[ i ].normalChannelEntry.earlyTerminationEvent; |
|
195 tnetScanParams.basicScanChannelParameters[ i ].txPowerAttenuation = |
|
196 pScanVals->channelEntry[ i ].normalChannelEntry.txPowerDbm; |
|
197 tnetScanParams.basicScanChannelParameters[ i ].channel = |
|
198 pScanVals->channelEntry[ i ].normalChannelEntry.channel; |
|
199 } |
|
200 |
|
201 TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "RxCfg = 0x%x\n RxFilterCfg = 0x%x\n scanOptions = 0x%x\n numChannels = %d\n probeNumber = %d\n probeRateModulation = 0x%x\n tidTrigger = %d\n" , tnetScanParams.basicScanParameters.rxCfg.ConfigOptions, tnetScanParams.basicScanParameters.rxCfg.FilterOptions, tnetScanParams.basicScanParameters.scanOptions, tnetScanParams.basicScanParameters.numChannels, tnetScanParams.basicScanParameters.numOfProbRqst, tnetScanParams.basicScanParameters.txdRateSet, tnetScanParams.basicScanParameters.tidTrigger); |
|
202 |
|
203 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Channel BSSID MinTime MaxTime ET TxPower probChan\n"); |
|
204 |
|
205 for( i=0; i < pScanVals->numOfChannels; i++) |
|
206 { |
|
207 chanPtr = &tnetScanParams.basicScanChannelParameters[i]; |
|
208 pBSSID = (TI_UINT8*)&chanPtr->bssIdL; |
|
209 |
|
210 TRACE12(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "%06d %02x:%02x:%02x:%02x:%02x:%02x %05d %05d %02d %05d %05d\n",i, pBSSID[5],pBSSID[4],pBSSID[3],pBSSID[2],pBSSID[1],pBSSID[0], chanPtr->scanMinDuration, chanPtr->scanMaxDuration, chanPtr->ETCondCount, chanPtr->txPowerAttenuation, chanPtr->channel); |
|
211 } |
|
212 |
|
213 return cmdBld_CmdIeStartScan (hCmdBld, &tnetScanParams, ScanCommandResponseCB, hCb); |
|
214 } |
|
215 |
|
216 /** |
|
217 * \fn cmdBld_CmdStartSPSScan |
|
218 * \brief Build a start SPS scan command and send it to the FW |
|
219 * |
|
220 * Build a start SPS scan command and send it to the FW |
|
221 * |
|
222 * \param hCmdBld - handle to the command builder object |
|
223 * \param pScanVals - scan parameters |
|
224 * \param eScanTag - scan tag used for scan complete and result tracking |
|
225 * \param fScanCommandResponseCB - command complete CB |
|
226 * \param hCb - command complete CB |
|
227 * \return command status (OK / NOK) |
|
228 * \sa cmdBld_CmdStopSPSScan |
|
229 */ |
|
230 TI_STATUS cmdBld_CmdStartSPSScan (TI_HANDLE hCmdBld, TScanParams *pScanVals, EScanResultTag eScanTag, |
|
231 void* fScanCommandResponseCB, TI_HANDLE hCb) |
|
232 { |
|
233 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
234 ScheduledScanParameters_t tnetSPSScanParams; |
|
235 TI_INT32 i; |
|
236 |
|
237 /* Convert general scan data to TNET structure */ |
|
238 tnetSPSScanParams.scheduledGeneralParameters.scanOptions = SCAN_PASSIVE; |
|
239 /* Add the band selection */ |
|
240 if ( RADIO_BAND_5_0_GHZ == pScanVals->band ) |
|
241 { |
|
242 tnetSPSScanParams.scheduledGeneralParameters.band = RADIO_BAND_5GHZ; |
|
243 } |
|
244 else |
|
245 { |
|
246 tnetSPSScanParams.scheduledGeneralParameters.band = RADIO_BAND_2_4_GHZ; |
|
247 } |
|
248 |
|
249 |
|
250 tnetSPSScanParams.scheduledGeneralParameters.scanOptions = ENDIAN_HANDLE_WORD( tnetSPSScanParams.scheduledGeneralParameters.scanOptions ); |
|
251 |
|
252 /* important note: BSSID filter (0x0010) is DISABLED, because the FW sets it according |
|
253 to BSSID value (broadcast does not filter, any other value will */ |
|
254 /* If the SSID is not broadcast SSID, also filter according to SSID */ |
|
255 tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions = 0x12812; |
|
256 tnetSPSScanParams.scheduledGeneralParameters.rxCfg.FilterOptions = ENDIAN_HANDLE_LONG( RX_FILTER_CFG_ ); |
|
257 tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions = ENDIAN_HANDLE_LONG( tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions ); |
|
258 |
|
259 /* latest TSF value - used to discover TSF error (AP recovery) */ |
|
260 tnetSPSScanParams.scheduledGeneralParameters.scanCmdTime_h = ENDIAN_HANDLE_LONG( INT64_HIGHER(pScanVals->latestTSFValue) ); |
|
261 tnetSPSScanParams.scheduledGeneralParameters.scanCmdTime_l = ENDIAN_HANDLE_LONG( INT64_LOWER(pScanVals->latestTSFValue) ); |
|
262 |
|
263 /* add scan tag */ |
|
264 tnetSPSScanParams.scheduledGeneralParameters.scanTag = eScanTag; |
|
265 |
|
266 tnetSPSScanParams.scheduledGeneralParameters.numChannels = pScanVals->numOfChannels; |
|
267 |
|
268 /* copy channel specific scan data to HAL structure */ |
|
269 for ( i = 0; i < pScanVals->numOfChannels; i++ ) |
|
270 { |
|
271 TI_INT32 j; |
|
272 TI_UINT8* macAddr; |
|
273 |
|
274 macAddr = (TI_UINT8*)&tnetSPSScanParams.scheduledChannelParameters[ i ].bssIdL; |
|
275 |
|
276 /* copy the MAC address, upside down (CHIP structure) */ |
|
277 for ( j = 0; j < MAC_ADDR_LEN; j++ ) |
|
278 { |
|
279 macAddr[ j ] = pScanVals->channelEntry[ i ].normalChannelEntry.bssId[ MAC_ADDR_LEN - 1 - j ]; |
|
280 } |
|
281 tnetSPSScanParams.scheduledChannelParameters[ i ].scanMaxDuration = |
|
282 ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].SPSChannelEntry.scanDuration ); |
|
283 tnetSPSScanParams.scheduledChannelParameters[ i ].scanStartTime = |
|
284 ENDIAN_HANDLE_LONG( pScanVals->channelEntry[ i ].SPSChannelEntry.scanStartTime ); |
|
285 tnetSPSScanParams.scheduledChannelParameters[ i ].ETCondCount = |
|
286 pScanVals->channelEntry[ i ].SPSChannelEntry.ETMaxNumOfAPframes | |
|
287 pScanVals->channelEntry[ i ].SPSChannelEntry.earlyTerminationEvent; |
|
288 tnetSPSScanParams.scheduledChannelParameters[ i ].channel = |
|
289 pScanVals->channelEntry[ i ].SPSChannelEntry.channel; |
|
290 } |
|
291 |
|
292 TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "RxCfg = 0x%x\n RxFilterCfg = 0x%x\n scanOptions = 0x%x\n numChannels = %d\n", tnetSPSScanParams.scheduledGeneralParameters.rxCfg.ConfigOptions, tnetSPSScanParams.scheduledGeneralParameters.rxCfg.FilterOptions, tnetSPSScanParams.scheduledGeneralParameters.scanOptions, tnetSPSScanParams.scheduledGeneralParameters.numChannels); |
|
293 |
|
294 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Channel BSSID StartTime Duration ET probChan\n"); |
|
295 |
|
296 #ifdef TI_DBG |
|
297 for( i=0; i < tnetSPSScanParams.scheduledGeneralParameters.numChannels; i++) |
|
298 { |
|
299 ScheduledChannelParameters_t* chanPtr = &tnetSPSScanParams.scheduledChannelParameters[ i ]; |
|
300 TI_UINT8* pBSSID = (TI_UINT8*)&chanPtr->bssIdL; |
|
301 |
|
302 TRACE11(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "%6d %02x:%02x:%02x:%02x:%02x:%02x %5d %5d %2d %5d\n",i, pBSSID[5],pBSSID[4],pBSSID[3],pBSSID[2],pBSSID[1],pBSSID[0], chanPtr->scanStartTime, chanPtr->scanMaxDuration, chanPtr->ETCondCount, chanPtr->channel); |
|
303 } |
|
304 #endif /* TI_DBG */ |
|
305 |
|
306 return cmdBld_CmdIeStartSPSScan (hCmdBld, &tnetSPSScanParams, fScanCommandResponseCB, hCb); |
|
307 } |
|
308 |
|
309 /** |
|
310 * \fn cmdBld_CmdStopScan |
|
311 * \brief Build a stop scan command and send it to FW |
|
312 * |
|
313 * Build a stop scan command and send it to FW |
|
314 * |
|
315 * \param hCmdBld - handle to the command builder object |
|
316 * \param eScanTag - scan tag, used for scan complete and result tracking |
|
317 * \return command status (OK / NOK) |
|
318 * \sa cmdBld_CmdStartSPSScan |
|
319 */ |
|
320 TI_STATUS cmdBld_CmdStopScan (TI_HANDLE hCmdBld, EScanResultTag eScanTag, |
|
321 void *fScanCommandResponseCB, TI_HANDLE hCb) |
|
322 { |
|
323 return cmdBld_CmdIeStopScan (hCmdBld, fScanCommandResponseCB, hCb); |
|
324 } |
|
325 |
|
326 |
|
327 /** |
|
328 * \fn cmdBld_CmdStopSPSScan |
|
329 * \brief Build a stop SPS scan command and send it to FW |
|
330 * |
|
331 * Build a stop SPS scan command and send it to FW |
|
332 * |
|
333 * \param hCmdBld - handle to the command builder object |
|
334 * \param eScanTag - scan tag, used for scan complete and result tracking |
|
335 * \return command status (OK / NOK) |
|
336 * \sa cmdBld_CmdStartScan |
|
337 */ TI_STATUS cmdBld_CmdStopSPSScan (TI_HANDLE hCmdBld, EScanResultTag eScanTag, |
|
338 void* fScanCommandResponseCB, TI_HANDLE hCb) |
|
339 { |
|
340 return cmdBld_CmdIeStopSPSScan (hCmdBld, fScanCommandResponseCB, hCb); |
|
341 } |
|
342 |
|
343 TI_STATUS cmdBld_CmdSetSplitScanTimeOut (TI_HANDLE hCmdBld, TI_UINT32 uTimeOut) |
|
344 { |
|
345 DB_WLAN(hCmdBld).uSlicedScanTimeOut = uTimeOut; |
|
346 |
|
347 return cmdBld_CmdIeSetSplitScanTimeOut (hCmdBld, uTimeOut, NULL, NULL); |
|
348 } |
|
349 |
|
350 /** |
|
351 * \fn cmdBld_debugPrintPeriodicScanChannles |
|
352 * \brief Print periodic scan channel list for debug purposes |
|
353 * |
|
354 * Print periodic scan channel list for debug purposes |
|
355 * |
|
356 * \param hCmdBld - handle to the command builder object |
|
357 * \param pChannel - pointer to the channel list to print |
|
358 * \param uChannelCount - number of channles to print |
|
359 * \return None |
|
360 * \sa cmdBld_debugPrintPeriodicScanParams |
|
361 */ |
|
362 void cmdBld_debugPrintPeriodicScanChannles (TI_HANDLE hCmdBld, ConnScanChannelInfo_t* pChannel, |
|
363 TI_UINT32 uChannelCount) |
|
364 { |
|
365 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
366 TI_UINT32 uIndex; |
|
367 |
|
368 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Index Channel MinTime MaxTime DFStime PowerLevel\n"); |
|
369 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "-------------------------------------------------------------------\n"); |
|
370 for (uIndex = 0; uIndex < uChannelCount; uIndex++) |
|
371 { |
|
372 TRACE6(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "%-10d %-10d %-10d %-10d %-10d %-11d\n", uIndex, pChannel[ uIndex ].channel, pChannel[ uIndex ].scanMinDuration, pChannel[ uIndex ].scanMaxDuration, pChannel[ uIndex ].passiveScanDuration, pChannel[ uIndex ].txPowerLevelDbm); |
|
373 } |
|
374 } |
|
375 |
|
376 /** |
|
377 * \fn cmdBld_debugPrintPeriodicScanParams |
|
378 * \brief Print periodic scan parameters for debug purposes |
|
379 * |
|
380 * Print periodic scan parameters for debug purposes |
|
381 * |
|
382 * \param hCmdBld - handle to the command builder object |
|
383 * \param pCommand - pointer to the periodic scan command to print |
|
384 * \return None |
|
385 * \sa cmdBld_debugPrintPeriodicScanChannles |
|
386 */ |
|
387 void cmdBld_debugPrintPeriodicScanParams (TI_HANDLE hCmdBld, ConnScanParameters_t* pCommand) |
|
388 { |
|
389 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
390 |
|
391 /* print periodic scan params command */ |
|
392 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Cycle intervals:\n"); |
|
393 TRACE8(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "0: %-6d %-6d %-6d %-6d %-6d %-6d %-6d %-6d\n", pCommand->cycleIntervals[ 0 ], pCommand->cycleIntervals[ 1 ], pCommand->cycleIntervals[ 2 ], pCommand->cycleIntervals[ 3 ], pCommand->cycleIntervals[ 4 ], pCommand->cycleIntervals[ 5 ], pCommand->cycleIntervals[ 6 ], pCommand->cycleIntervals[ 7 ]); |
|
394 TRACE8(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "8: %-6d %-6d %-6d %-6d %-6d %-6d %-6d %-6d\n", pCommand->cycleIntervals[ 8 ], pCommand->cycleIntervals[ 9 ], pCommand->cycleIntervals[ 10 ], pCommand->cycleIntervals[ 11 ], pCommand->cycleIntervals[ 12 ], pCommand->cycleIntervals[ 13 ], pCommand->cycleIntervals[ 14 ], pCommand->cycleIntervals[ 15 ]); |
|
395 TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "RSSI threshold: %d, SNR threshold: %d, number of cycles: %d, reporth threshold: %d\n", pCommand->rssiThreshold, pCommand->snrThreshold, pCommand->maxNumOfCycles, pCommand->reportThreshold); |
|
396 TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Terminate on report: %d, result tag: %d, BSS type: %d, number of probe requests: %d\n", pCommand->terminateOnReport, pCommand->resultsTag, pCommand->bssType, pCommand->numProbe); |
|
397 TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "SSID filter type: %d, SSID length: %d, SSID: \n", pCommand->ssidFilterType, pCommand->ssidLength); |
|
398 /* print channel info */ |
|
399 |
|
400 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "2.4 GHz Channels:\n"); |
|
401 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "-----------------\n"); |
|
402 TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Number of passive channels: %d, number of active channels: %d\n", pCommand->numOfPassive[ 0 ], pCommand->numOfActive[ 0 ]); |
|
403 cmdBld_debugPrintPeriodicScanChannles (hCmdBld, &(pCommand->channelList[ 0 ]), |
|
404 pCommand->numOfPassive[ 0 ] + |
|
405 pCommand->numOfActive[ 0 ]); |
|
406 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "5.0 GHz Channels:\n"); |
|
407 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "-----------------\n"); |
|
408 TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Number of passive channels: %d, number of DFS channels: %d, number of active channels: %d\n", pCommand->numOfPassive[ 1 ], pCommand->numOfDfs, pCommand->numOfActive[ 2 ]); |
|
409 cmdBld_debugPrintPeriodicScanChannles (hCmdBld, &(pCommand->channelList[ CONN_SCAN_MAX_CHANNELS_BG ]), |
|
410 pCommand->numOfPassive[ 1 ] + |
|
411 pCommand->numOfActive[ 1 ] + |
|
412 pCommand->numOfDfs); |
|
413 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "4.9 GHz channles:\n"); |
|
414 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "-----------------\n"); |
|
415 TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Number of passive channels: %d, number of active channels: %d\n", pCommand->numOfPassive[ 2 ], pCommand->numOfActive[ 2 ]); |
|
416 cmdBld_debugPrintPeriodicScanChannles (hCmdBld, &(pCommand->channelList[ CONN_SCAN_MAX_CHANNELS_BG + CONN_SCAN_MAX_CHANNELS_A ]), |
|
417 pCommand->numOfPassive[ 2 ] + |
|
418 pCommand->numOfActive[ 2 ]); |
|
419 } |
|
420 |
|
421 /** |
|
422 * \fn cmdBld_debugPrintPeriodicScanSsidList |
|
423 * \brief Print periodic scan SSID list for debug purposes |
|
424 * |
|
425 * Print periodic scan SSID list for debug purposes |
|
426 * |
|
427 * \param hCmdBld - handle to the command builder object |
|
428 * \param pCommand - pointer to the periodic scan SSID list command to print |
|
429 * \return None |
|
430 * \sa cmdBld_debugPrintPeriodicScanParams |
|
431 */ |
|
432 void cmdBld_debugPrintPeriodicScanSsidList (TI_HANDLE hCmdBld, ConnScanSSIDList_t* pCommand) |
|
433 { |
|
434 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
435 TI_UINT32 uIndex; |
|
436 |
|
437 /* print SSID list command */ |
|
438 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "SSID list:\n"); |
|
439 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "---------\n"); |
|
440 TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Num of entries: %d\n", pCommand->numOfSSIDEntries); |
|
441 for (uIndex = 0; uIndex < pCommand->numOfSSIDEntries; uIndex++) |
|
442 { |
|
443 TRACE3(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "index: %d, SSID type: %d, SSID length:% d, SSID string:\n", uIndex, pCommand->SSIDList[ uIndex ].ssidType, pCommand->SSIDList[ uIndex ].ssidLength); |
|
444 } |
|
445 |
|
446 } |
|
447 |
|
448 /** |
|
449 * \fn cmdBld_BuildPeriodicScanChannlesn |
|
450 * \brief Copy channels info for periodic scan to FW structure for a specific band and scan type |
|
451 * |
|
452 * Copy channels info, from driver structure, to FW structure, for periodic scan, for a specific |
|
453 * band and scan type. |
|
454 * |
|
455 * \param pPeriodicScanParams - driver priodic scan parameters (source) |
|
456 * \param pChannelList - FW scan channel list (destination) |
|
457 * \param eScanType - scan type (passive or active) |
|
458 * \param eRadioBand - band (G, A or J) |
|
459 * \param uPassiveScanDfsDwellTime - Dwell time for passive scan on DFS channels (in milli-secs) |
|
460 * \return Number of channels found for this scan type and band |
|
461 * \sa cmdBld_StartPeriodicScan |
|
462 */ |
|
463 TI_UINT32 cmdBld_BuildPeriodicScanChannles (TPeriodicScanParams *pPeriodicScanParams, |
|
464 ConnScanChannelInfo_t *pChannelList, |
|
465 EScanType eScanType, ERadioBand eRadioBand, |
|
466 TI_UINT32 uPassiveScanDfsDwellTime) |
|
467 { |
|
468 TI_UINT32 uIndex, uNumChannels = 0; |
|
469 |
|
470 /* check all channels */ |
|
471 for (uIndex = 0; uIndex < pPeriodicScanParams->uChannelNum; uIndex++) |
|
472 { |
|
473 /* if this channel is on the required band and uses the required scan type */ |
|
474 if ((eRadioBand == pPeriodicScanParams->tChannels[ uIndex ].eBand) && |
|
475 (eScanType == pPeriodicScanParams->tChannels[ uIndex ].eScanType)) |
|
476 { |
|
477 /* update scan parameters */ |
|
478 pChannelList[ uNumChannels ].channel = (TI_UINT8)pPeriodicScanParams->tChannels[ uIndex ].uChannel; |
|
479 pChannelList[ uNumChannels ].passiveScanDuration = ENDIAN_HANDLE_WORD ((TI_UINT16)uPassiveScanDfsDwellTime); |
|
480 pChannelList[ uNumChannels ].scanMaxDuration = |
|
481 ENDIAN_HANDLE_WORD ((TI_UINT16)pPeriodicScanParams->tChannels[ uIndex ].uMaxDwellTimeMs); |
|
482 pChannelList[ uNumChannels ].scanMinDuration = |
|
483 ENDIAN_HANDLE_WORD ((TI_UINT16)pPeriodicScanParams->tChannels[ uIndex ].uMinDwellTimeMs); |
|
484 pChannelList[ uNumChannels ].txPowerLevelDbm = (TI_UINT8)pPeriodicScanParams->tChannels[ uIndex ].uTxPowerLevelDbm; |
|
485 if (SCAN_TYPE_PACTSIVE == eScanType) /* DFS channel */ |
|
486 { |
|
487 pChannelList[ uNumChannels ].passiveScanDuration = ENDIAN_HANDLE_WORD ((TI_UINT16)uPassiveScanDfsDwellTime); |
|
488 pChannelList[ uNumChannels ].channelFlags = 1; /* mark as DFS channel */ |
|
489 } |
|
490 else |
|
491 { |
|
492 pChannelList[ uNumChannels ].channelFlags = 0; /* mark as not DFS channel */ |
|
493 } |
|
494 |
|
495 /* advance mathcing channel counter */ |
|
496 uNumChannels++; |
|
497 } |
|
498 } |
|
499 |
|
500 /* return channel count */ |
|
501 return uNumChannels; |
|
502 } |
|
503 |
|
504 /** |
|
505 * \fn cmdBld_StartPeriodicScan |
|
506 * \brief Copy driver periodic scan parameters to FW structures and send all commands to FW |
|
507 * |
|
508 * Copy driver periodic scan parameters to FW structures (SSID list, parameters including channels |
|
509 * and start command) and send all commands to FW. |
|
510 * |
|
511 * \param hCmdBld - handle to the command builder object |
|
512 * \param pPeriodicScanParams - periodic scan driver parameters (source) |
|
513 * \param eScanTag - scan tag, used for scan complete and result tracking |
|
514 * \param uPassiveScanDfsDwellTimeUs - Passive dwell time for DFS channels |
|
515 * \param fScanCommandResponseCB - scan command complete CB |
|
516 * \param hCb - scan command response handle |
|
517 * \return TI_OK on success, other codes indicate failure |
|
518 * \sa cmdBld_BuildPeriodicScanChannles, cmdBld_StopPeriodicScan |
|
519 */ |
|
520 TI_STATUS cmdBld_StartPeriodicScan (TI_HANDLE hCmdBld, TPeriodicScanParams *pPeriodicScanParams, |
|
521 EScanResultTag eScanTag, TI_UINT32 uPassiveScanDfsDwellTimeMs, |
|
522 void* fScanCommandResponseCB, TI_HANDLE hCb) |
|
523 { |
|
524 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
525 ConnScanParameters_t tFWPeriodicScanParams; |
|
526 ConnScanSSIDList_t tFWSsidList; |
|
527 PeriodicScanTag tScanStart; |
|
528 TI_UINT32 uIndex; |
|
529 TI_STATUS tStatus; |
|
530 |
|
531 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Building start periodic scan commands:\n"); |
|
532 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "--------------------------------------\n"); |
|
533 /* copy parameters to FW structure */ |
|
534 tFWPeriodicScanParams.bssType = (ScanBssType_e)pPeriodicScanParams->eBssType; |
|
535 for (uIndex = 0; uIndex < PERIODIC_SCAN_MAX_INTERVAL_NUM; uIndex ++) |
|
536 { |
|
537 tFWPeriodicScanParams.cycleIntervals[ uIndex ] = |
|
538 ENDIAN_HANDLE_LONG (pPeriodicScanParams->uCycleIntervalMsec[ uIndex ]); |
|
539 } |
|
540 tFWPeriodicScanParams.maxNumOfCycles = (TI_UINT8)pPeriodicScanParams->uCycleNum; |
|
541 tFWPeriodicScanParams.numProbe = (TI_UINT8)pPeriodicScanParams->uProbeRequestNum; |
|
542 tFWPeriodicScanParams.reportThreshold = (TI_UINT8)pPeriodicScanParams->uFrameCountReportThreshold; |
|
543 tFWPeriodicScanParams.rssiThreshold = (TI_UINT8)pPeriodicScanParams->iRssiThreshold; |
|
544 tFWPeriodicScanParams.snrThreshold = (TI_INT8)pPeriodicScanParams->iSnrThreshold; |
|
545 tFWPeriodicScanParams.terminateOnReport = (TI_UINT8)pPeriodicScanParams->bTerminateOnReport; |
|
546 tFWPeriodicScanParams.resultsTag = (TI_UINT8)eScanTag; |
|
547 switch (pPeriodicScanParams->uSsidNum) |
|
548 { |
|
549 case 0: /* No SSIDs defined - no need to filter according to SSID */ |
|
550 tFWPeriodicScanParams.ssidFilterType = (ScanSsidFilterType_e)SCAN_SSID_FILTER_TYPE_ANY; |
|
551 tFWPeriodicScanParams.ssidLength = 0; |
|
552 break; |
|
553 |
|
554 case 1: /* Only one SSID defined - copy it to the scan command (no need to send SSID list as well) */ |
|
555 tFWPeriodicScanParams.ssidFilterType = (ScanSsidFilterType_e)SCAN_SSID_FILTER_TYPE_SPECIFIC; |
|
556 tFWPeriodicScanParams.ssidLength = (TI_UINT8)pPeriodicScanParams->tDesiredSsid[ 0 ].tSsid.len; |
|
557 os_memoryCopy (pCmdBld->hOs, (void*)&(tFWPeriodicScanParams.ssid[ 0 ]), |
|
558 (void*)&(pPeriodicScanParams->tDesiredSsid[ 0 ].tSsid.str[ 0 ]), |
|
559 pPeriodicScanParams->tDesiredSsid[ 0 ].tSsid.len); |
|
560 break; |
|
561 |
|
562 default: /* More than one SSID - copy SSIDs to SSID list command */ |
|
563 tFWPeriodicScanParams.ssidFilterType = (ScanSsidFilterType_e)SCAN_SSID_FILTER_TYPE_LIST; |
|
564 tFWPeriodicScanParams.ssidLength = 0; |
|
565 tFWSsidList.numOfSSIDEntries = (TI_UINT8)pPeriodicScanParams->uSsidNum; |
|
566 for (uIndex = 0; uIndex < pPeriodicScanParams->uSsidNum; uIndex++) |
|
567 { |
|
568 tFWSsidList.SSIDList[ uIndex ].ssidType = |
|
569 (TI_UINT8)pPeriodicScanParams->tDesiredSsid[ uIndex ].eVisability; |
|
570 tFWSsidList.SSIDList[ uIndex ].ssidLength = |
|
571 (TI_UINT8)pPeriodicScanParams->tDesiredSsid[ uIndex ].tSsid.len; |
|
572 os_memoryCopy (pCmdBld->hOs, (void*)&(tFWSsidList.SSIDList[ uIndex ].ssid[ 0 ]), |
|
573 (void*)&(pPeriodicScanParams->tDesiredSsid[ uIndex ].tSsid.str[ 0 ]), |
|
574 tFWSsidList.SSIDList[ uIndex ].ssidLength); |
|
575 } |
|
576 |
|
577 /* print the SSID list parameters */ |
|
578 cmdBld_debugPrintPeriodicScanSsidList (hCmdBld, &tFWSsidList); |
|
579 |
|
580 /* send the SSID list command */ |
|
581 tStatus = cmdBld_CmdIeScanSsidList (hCmdBld, &tFWSsidList, NULL, NULL); |
|
582 if (TI_OK != tStatus) |
|
583 { |
|
584 TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR , "cmdBld_StartPeriodicScan: status %d when configuring SSID list", tStatus); |
|
585 return tStatus; |
|
586 } |
|
587 break; |
|
588 } |
|
589 |
|
590 /* copy channels */ |
|
591 tFWPeriodicScanParams.numOfPassive[ 0 ] = /* build passive B/G channels */ |
|
592 cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ 0 ]), |
|
593 SCAN_TYPE_NORMAL_PASSIVE, RADIO_BAND_2_4_GHZ, uPassiveScanDfsDwellTimeMs); |
|
594 tFWPeriodicScanParams.numOfActive[ 0 ] = /* build active B/G channels */ |
|
595 cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ tFWPeriodicScanParams.numOfPassive[ 0 ] ]), |
|
596 SCAN_TYPE_NORMAL_ACTIVE, RADIO_BAND_2_4_GHZ, uPassiveScanDfsDwellTimeMs); |
|
597 tFWPeriodicScanParams.numOfPassive[ 1 ] = /* build passive A channels */ |
|
598 cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ CONN_SCAN_MAX_CHANNELS_BG ]), |
|
599 SCAN_TYPE_NORMAL_PASSIVE, RADIO_BAND_5_0_GHZ, uPassiveScanDfsDwellTimeMs); |
|
600 tFWPeriodicScanParams.numOfDfs = /* build DFS A channels */ |
|
601 cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ CONN_SCAN_MAX_CHANNELS_BG + tFWPeriodicScanParams.numOfPassive[ 1 ] ]), |
|
602 SCAN_TYPE_PACTSIVE, RADIO_BAND_5_0_GHZ, uPassiveScanDfsDwellTimeMs); |
|
603 tFWPeriodicScanParams.numOfActive[ 1 ] = /* build active A channels */ |
|
604 cmdBld_BuildPeriodicScanChannles (pPeriodicScanParams, &(tFWPeriodicScanParams.channelList[ CONN_SCAN_MAX_CHANNELS_BG + tFWPeriodicScanParams.numOfPassive[ 1 ] + tFWPeriodicScanParams.numOfDfs ]), |
|
605 SCAN_TYPE_NORMAL_ACTIVE, RADIO_BAND_5_0_GHZ, uPassiveScanDfsDwellTimeMs); |
|
606 |
|
607 /* until J is supported, mark zero channels for J passive and active */ |
|
608 tFWPeriodicScanParams.numOfPassive[ 2 ] = 0; |
|
609 tFWPeriodicScanParams.numOfActive[ 2 ] = 0; |
|
610 |
|
611 /* print the command */ |
|
612 cmdBld_debugPrintPeriodicScanParams (hCmdBld, &tFWPeriodicScanParams); |
|
613 |
|
614 /* Send the periodic scan parameters command */ |
|
615 tStatus = cmdBld_CmdIePeriodicScanParams (hCmdBld, &tFWPeriodicScanParams, NULL, NULL); |
|
616 if (TI_OK != tStatus) |
|
617 { |
|
618 TRACE1(pCmdBld->hReport, REPORT_SEVERITY_ERROR , "cmdBld_StartPeriodicScan: status %d when configuring periodic scan parameters", tStatus); |
|
619 return tStatus; |
|
620 } |
|
621 |
|
622 /* send the periodic scan start command */ |
|
623 tScanStart.scanTag = eScanTag; |
|
624 return cmdBld_CmdIeStartPeriodicScan (hCmdBld, &tScanStart, fScanCommandResponseCB, hCb); |
|
625 } |
|
626 |
|
627 /** |
|
628 * \fn cmdBld_StopPeriodicScan |
|
629 * \brief Stops an on-going periodic scan operation |
|
630 * |
|
631 * Stops an on-going periodic scan operation |
|
632 * |
|
633 * \param hCmdBld - handle to the command builder object |
|
634 * \param eScanTag - scan tag, used for scan complete and result tracking |
|
635 * \param fScanCommandResponseCB - scan command complete CB |
|
636 * \param hCb - scan command response handle |
|
637 * \return TI_OK on success, other codes indicate failure |
|
638 * \sa cmdBld_BuildPeriodicScanChannles, cmdBld_StartPeriodicScan |
|
639 */ |
|
640 TI_STATUS cmdBld_StopPeriodicScan (TI_HANDLE hCmdBld, EScanResultTag eScanTag, |
|
641 void* fScanCommandResponseCB, TI_HANDLE hCb) |
|
642 { |
|
643 PeriodicScanTag tScanStop; |
|
644 |
|
645 /* send the periodic scan stop command */ |
|
646 tScanStop.scanTag = eScanTag; |
|
647 return cmdBld_CmdIeStopPeriodicScan (hCmdBld, &tScanStop, fScanCommandResponseCB, hCb); |
|
648 } |
|
649 |
|
650 /**************************************************************************** |
|
651 * cmdBld_SetBssType() |
|
652 **************************************************************************** |
|
653 * DESCRIPTION: Set Bss type, set RxFilter |
|
654 * |
|
655 * INPUTS: None |
|
656 * |
|
657 * OUTPUT: None |
|
658 * |
|
659 * RETURNS: TI_OK or TI_NOK |
|
660 ****************************************************************************/ |
|
661 static TI_STATUS cmdBld_CmdSetBssType (TI_HANDLE hCmdBld, ScanBssType_e BssType, TI_UINT8 *HwBssType) |
|
662 { |
|
663 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
664 |
|
665 switch (BssType) |
|
666 { |
|
667 case BSS_INFRASTRUCTURE: |
|
668 DB_BSS(hCmdBld).BssType = BSS_TYPE_STA_BSS; |
|
669 cmdBld_SetRxFilter (hCmdBld, RX_CONFIG_OPTION_FOR_JOIN, RX_FILTER_OPTION_JOIN); |
|
670 break; |
|
671 |
|
672 case BSS_INDEPENDENT: |
|
673 DB_BSS(hCmdBld).BssType = BSS_TYPE_IBSS; |
|
674 cmdBld_SetRxFilter (hCmdBld, RX_CONFIG_OPTION_FOR_IBSS_JOIN, RX_FILTER_OPTION_DEF); |
|
675 break; |
|
676 |
|
677 default: |
|
678 TRACE1(pCmdBld->hReport, REPORT_SEVERITY_FATAL_ERROR, "cmdBld_SetBssType: FATAL_ERROR, unknown BssType %d\n", BssType); |
|
679 return TI_NOK; |
|
680 } |
|
681 |
|
682 *HwBssType = DB_BSS(hCmdBld).BssType; |
|
683 |
|
684 return TI_OK; |
|
685 } |
|
686 |
|
687 |
|
688 /**************************************************************************** |
|
689 * cmdBld_StartJoin() |
|
690 **************************************************************************** |
|
691 * DESCRIPTION: Enable Rx/Tx and send Start/Join command |
|
692 * |
|
693 * INPUTS: None |
|
694 * |
|
695 * OUTPUT: None |
|
696 * |
|
697 * RETURNS: TI_OK or TI_NOK |
|
698 ****************************************************************************/ |
|
699 TI_STATUS cmdBld_CmdStartJoin (TI_HANDLE hCmdBld, ScanBssType_e BssType, void *fJoinCompleteCB, TI_HANDLE hCb) |
|
700 { |
|
701 TI_UINT8 HwBssType = 0; |
|
702 #ifdef TI_DBG |
|
703 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
704 TI_UINT8 *pBssId = DB_BSS(hCmdBld).BssId; |
|
705 |
|
706 TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INIT, "cmdBld_StartJoin: Enable Tx, Rx and Start the Bss, type=%d\n", BssType); |
|
707 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INIT, "------------------------------------------------------------\n"); |
|
708 TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INIT, "START/JOIN, SSID=, BSSID=%02X-%02X-%02X-%02X-%02X-%02X, Chan=%d\n", pBssId[0], pBssId[1], pBssId[2], pBssId[3], pBssId[4], pBssId[5], DB_BSS(hCmdBld).RadioChannel); |
|
709 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INIT, "------------------------------------------------------------\n"); |
|
710 #endif /* TI_DBG */ |
|
711 |
|
712 /* |
|
713 * set RxFilter (but don't write it to the FW, this is done in the join command), |
|
714 * Configure templates content, ... |
|
715 */ |
|
716 cmdBld_CmdSetBssType (hCmdBld, BssType, &HwBssType); |
|
717 |
|
718 return cmdBld_CmdIeStartBss (hCmdBld, HwBssType, fJoinCompleteCB, hCb); |
|
719 } |
|
720 |
|
721 |
|
722 TI_STATUS cmdBld_CmdJoinBss (TI_HANDLE hCmdBld, TJoinBss *pJoinBssParams, void *fCb, TI_HANDLE hCb) |
|
723 { |
|
724 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
725 TWlanParams *pWlanParams = &DB_WLAN(hCmdBld); |
|
726 TBssInfoParams *pBssInfoParams = &DB_BSS(hCmdBld); |
|
727 #ifdef TI_DBG |
|
728 TI_UINT8 dbgSsidStr[33]; |
|
729 #endif /* TI_DBG */ |
|
730 |
|
731 /* for debug purpose, can be removed later*/ |
|
732 if (pJoinBssParams->ssidLength > 32) |
|
733 pJoinBssParams->ssidLength = 32; |
|
734 |
|
735 /* Update Tx-Session-Counter in the Ctrl field of the Join command. */ |
|
736 pBssInfoParams->Ctrl &= ~JOIN_CMD_CTRL_TX_SESSION; |
|
737 pBssInfoParams->Ctrl |= (TI_UINT8)(pJoinBssParams->txSessionCount << JOIN_CMD_CTRL_OFFSET_TX_SESSION); |
|
738 |
|
739 #ifdef TI_DBG |
|
740 os_memoryCopy (pCmdBld->hOs, (void *)dbgSsidStr, (void *)pJoinBssParams->pSSID, pJoinBssParams->ssidLength); |
|
741 dbgSsidStr[pJoinBssParams->ssidLength] = '\0'; |
|
742 |
|
743 TRACE14(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "TWD_JoinBss : bssType = %d, beaconInterval = %d, dtimInterval = %d, channel = %d, BSSID = %x-%x-%x-%x-%x-%x, ssidLength = %d, basicRateSet = 0x%x, RadioBand = %d, Ctrl = 0x%x", pJoinBssParams->bssType, pJoinBssParams->beaconInterval, pJoinBssParams->dtimInterval, pJoinBssParams->channel, pJoinBssParams->pBSSID[0], pJoinBssParams->pBSSID[1], pJoinBssParams->pBSSID[2], pJoinBssParams->pBSSID[3], pJoinBssParams->pBSSID[4], pJoinBssParams->pBSSID[5], pJoinBssParams->ssidLength, pJoinBssParams->basicRateSet, pJoinBssParams->radioBand, pBssInfoParams->Ctrl); |
|
744 #endif /* TI_DBG */ |
|
745 /* |
|
746 * save Bss info parameters |
|
747 */ |
|
748 DB_BSS(hCmdBld).ReqBssType = pJoinBssParams->bssType; |
|
749 MAC_COPY (DB_BSS(hCmdBld).BssId, pJoinBssParams->pBSSID); |
|
750 pBssInfoParams->tSsid.len = pJoinBssParams->ssidLength; |
|
751 os_memoryZero (pCmdBld->hOs, (void *)pBssInfoParams->tSsid.str, sizeof (pBssInfoParams->tSsid.str)); |
|
752 os_memoryCopy (pCmdBld->hOs, (void *)pBssInfoParams->tSsid.str, (void *)pJoinBssParams->pSSID, pJoinBssParams->ssidLength); |
|
753 DB_BSS(hCmdBld).BeaconInterval = pJoinBssParams->beaconInterval; |
|
754 DB_BSS(hCmdBld).DtimInterval = (TI_UINT8)pJoinBssParams->dtimInterval; |
|
755 DB_BSS(hCmdBld).RadioChannel = pJoinBssParams->channel; |
|
756 DB_WLAN(hCmdBld).RadioBand = (TI_UINT8)pJoinBssParams->radioBand; |
|
757 DB_BSS(hCmdBld).BasicRateSet = pJoinBssParams->basicRateSet; |
|
758 |
|
759 /* In case we're joining a new BSS, reset the TKIP/AES sequence counter. */ |
|
760 /* The firmware resets its own counter - so we won't have mismatch in the following TX complete events */ |
|
761 pCmdBld->uSecuritySeqNumLow = 0; |
|
762 pCmdBld->uSecuritySeqNumHigh = 0; |
|
763 |
|
764 /* clear HT commands flags */ |
|
765 DB_BSS(hCmdBld).bHtCap = TI_FALSE; |
|
766 DB_BSS(hCmdBld).bHtInf = TI_FALSE; |
|
767 |
|
768 pWlanParams->bJoin = TI_TRUE; |
|
769 pWlanParams->bStaConnected = TI_FALSE; |
|
770 /* |
|
771 * call the hardware to start/join the bss |
|
772 */ |
|
773 return cmdBld_CmdStartJoin (hCmdBld, pJoinBssParams->bssType, fCb, hCb); |
|
774 } |
|
775 |
|
776 |
|
777 TI_STATUS cmdBld_CmdTemplate (TI_HANDLE hCmdBld, TSetTemplate *pTemplateParams, void *fCb, TI_HANDLE hCb) |
|
778 { |
|
779 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
780 TI_STATUS Stt; |
|
781 TTemplateParams *pTemplate; |
|
782 TI_UINT8 uIndex = 0; |
|
783 TemplateType_e eType; |
|
784 |
|
785 TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "cmdBld_CmdTemplate: Type=%d, size=%d, index=%d, RateMask=0x%x\n", pTemplateParams->type, pTemplateParams->len, pTemplateParams->index, pTemplateParams->uRateMask); |
|
786 |
|
787 switch (pTemplateParams->type) |
|
788 { |
|
789 case BEACON_TEMPLATE: |
|
790 eType = TEMPLATE_BEACON; |
|
791 pTemplate = &(DB_TEMP(hCmdBld).Beacon); |
|
792 break; |
|
793 |
|
794 case PROBE_RESPONSE_TEMPLATE: |
|
795 eType = TEMPLATE_PROBE_RESPONSE; |
|
796 pTemplate = &(DB_TEMP(hCmdBld).ProbeResp); |
|
797 break; |
|
798 |
|
799 case PROBE_REQUEST_TEMPLATE: |
|
800 if (pTemplateParams->eBand == RADIO_BAND_2_4_GHZ) |
|
801 { |
|
802 eType = CFG_TEMPLATE_PROBE_REQ_2_4; |
|
803 pTemplate = &(DB_TEMP(hCmdBld).ProbeReq24); |
|
804 } |
|
805 else |
|
806 { |
|
807 eType = CFG_TEMPLATE_PROBE_REQ_5; |
|
808 pTemplate = &(DB_TEMP(hCmdBld).ProbeReq50); |
|
809 } |
|
810 break; |
|
811 |
|
812 case NULL_DATA_TEMPLATE: |
|
813 eType = TEMPLATE_NULL_DATA; |
|
814 pTemplate = &(DB_TEMP(hCmdBld).NullData); |
|
815 break; |
|
816 |
|
817 case PS_POLL_TEMPLATE: |
|
818 eType = TEMPLATE_PS_POLL; |
|
819 pTemplate = &(DB_TEMP(hCmdBld).PsPoll); |
|
820 break; |
|
821 |
|
822 case QOS_NULL_DATA_TEMPLATE: |
|
823 eType = TEMPLATE_QOS_NULL_DATA; |
|
824 pTemplate = &(DB_TEMP(hCmdBld).QosNullData); |
|
825 break; |
|
826 |
|
827 case KEEP_ALIVE_TEMPLATE: |
|
828 eType = TEMPLATE_KLV; |
|
829 uIndex = pTemplateParams->index; |
|
830 pTemplate = &(DB_TEMP(hCmdBld).KeepAlive[uIndex]); |
|
831 break; |
|
832 |
|
833 case DISCONN_TEMPLATE: |
|
834 eType = TEMPLATE_DISCONNECT; |
|
835 pTemplate = &(DB_TEMP(hCmdBld).Disconn); |
|
836 break; |
|
837 |
|
838 default: |
|
839 return TI_NOK; |
|
840 } |
|
841 |
|
842 /* Save template information to DB (for recovery) */ |
|
843 pTemplate->Size = pTemplateParams->len; |
|
844 pTemplate->uRateMask = pTemplateParams->uRateMask; |
|
845 os_memoryCopy (pCmdBld->hOs, |
|
846 (void *)(pTemplate->Buffer), |
|
847 (void *)(pTemplateParams->ptr), |
|
848 pTemplateParams->len); |
|
849 |
|
850 /* Configure template to FW */ |
|
851 Stt = cmdBld_CmdIeConfigureTemplateFrame (hCmdBld, |
|
852 pTemplate, |
|
853 (TI_UINT16)pTemplateParams->len, |
|
854 eType, |
|
855 uIndex, /* index is only relevant for keep-alive template */ |
|
856 fCb, |
|
857 hCb); |
|
858 |
|
859 return Stt; |
|
860 } |
|
861 |
|
862 |
|
863 /**************************************************************************** |
|
864 * cmdBld_switchChannel() |
|
865 **************************************************************************** |
|
866 * DESCRIPTION: Switching the serving channel |
|
867 * |
|
868 * INPUTS: channel - new channel number |
|
869 * |
|
870 * OUTPUT: None |
|
871 * |
|
872 * RETURNS: TI_OK or TI_NOK |
|
873 ****************************************************************************/ |
|
874 TI_STATUS cmdBld_CmdEnableTx (TI_HANDLE hCmdBld, TI_UINT8 channel, void *fCb, TI_HANDLE hCb) |
|
875 { |
|
876 return cmdBld_CmdIeEnableTx (hCmdBld, channel, fCb, hCb); |
|
877 } |
|
878 |
|
879 |
|
880 /**************************************************************************** |
|
881 * cmdBld_DisableTx() |
|
882 **************************************************************************** |
|
883 * DESCRIPTION: Disable Tx path. |
|
884 * |
|
885 * INPUTS: None |
|
886 * |
|
887 * OUTPUT: None |
|
888 * |
|
889 * RETURNS: TI_OK or TI_NOK |
|
890 ****************************************************************************/ |
|
891 TI_STATUS cmdBld_CmdDisableTx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb) |
|
892 { |
|
893 return cmdBld_CmdIeDisableTx (hCmdBld, fCb, hCb); |
|
894 } |
|
895 |
|
896 |
|
897 |
|
898 /**************************************************************************** |
|
899 * cmdBld_SwitchChannelCmd() |
|
900 **************************************************************************** |
|
901 * DESCRIPTION: Send Switch Channel command |
|
902 * |
|
903 * INPUTS: None |
|
904 * |
|
905 * OUTPUT: None |
|
906 * |
|
907 * RETURNS: TI_OK or TI_NOK |
|
908 ****************************************************************************/ |
|
909 TI_STATUS cmdBld_CmdSwitchChannel (TI_HANDLE hCmdBld, TSwitchChannelParams *pSwitchChannelCmd, void *fCb, TI_HANDLE hCb) |
|
910 { |
|
911 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
912 |
|
913 TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "\n SwitchChannelCmd :\n channelNumber = %d\n switchTime = %d\n txFlag = %d\n flush = %d \n ", pSwitchChannelCmd->channelNumber, pSwitchChannelCmd->switchTime, pSwitchChannelCmd->txFlag, pSwitchChannelCmd->flush); |
|
914 |
|
915 DB_BSS(hCmdBld).RadioChannel = pSwitchChannelCmd->channelNumber; |
|
916 |
|
917 return cmdBld_CmdIeSwitchChannel (hCmdBld, pSwitchChannelCmd, fCb, hCb); |
|
918 } |
|
919 |
|
920 |
|
921 /**************************************************************************** |
|
922 * cmdBld_SwitchChannelCmd() |
|
923 **************************************************************************** |
|
924 * DESCRIPTION: Send Switch Channel command |
|
925 * |
|
926 * INPUTS: None |
|
927 * |
|
928 * OUTPUT: None |
|
929 * |
|
930 * RETURNS: TI_OK or TI_NOK |
|
931 ****************************************************************************/ |
|
932 TI_STATUS cmdBld_CmdSwitchChannelCancel (TI_HANDLE hCmdBld, TI_UINT8 channel, void *fCb, TI_HANDLE hCb) |
|
933 { |
|
934 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
935 |
|
936 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "\n TWD_SwitchChannelCancelCmd :\n "); |
|
937 |
|
938 DB_BSS(hCmdBld).RadioChannel = channel; |
|
939 |
|
940 return cmdBld_CmdIeSwitchChannelCancel (hCmdBld, fCb, hCb); |
|
941 } |
|
942 |
|
943 |
|
944 /**************************************************************************** |
|
945 * cmdBld_FwDisconnect() |
|
946 **************************************************************************** |
|
947 * DESCRIPTION: Disconnect. |
|
948 * |
|
949 * INPUTS: None |
|
950 * |
|
951 * OUTPUT: None |
|
952 * |
|
953 * RETURNS: TI_OK or TI_NOK |
|
954 ****************************************************************************/ |
|
955 TI_STATUS cmdBld_CmdFwDisconnect (TI_HANDLE hCmdBld, TI_UINT32 uConfigOptions, TI_UINT32 uFilterOptions, DisconnectType_e uDisconType, TI_UINT16 uDisconReason, void *fCb, TI_HANDLE hCb) |
|
956 { |
|
957 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
958 TWlanParams *pWlanParams = &DB_WLAN(hCmdBld); |
|
959 |
|
960 pWlanParams->bJoin = TI_FALSE; |
|
961 pWlanParams->bStaConnected = TI_FALSE; |
|
962 |
|
963 TRACE4(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Sending FW disconnect, ConfigOptions=%x, FilterOPtions=%x, uDisconType=%d, uDisconReason=%d\n",uConfigOptions, uFilterOptions, uDisconType, uDisconReason); |
|
964 |
|
965 |
|
966 return cmdBld_CmdIeFwDisconnect (hCmdBld, uConfigOptions, uFilterOptions, uDisconType, uDisconReason, fCb, hCb); |
|
967 } |
|
968 |
|
969 |
|
970 TI_STATUS cmdBld_CmdMeasurement (TI_HANDLE hCmdBld, |
|
971 TMeasurementParams *pMeasurementParams, |
|
972 void *fCommandResponseCB, |
|
973 TI_HANDLE hCb) |
|
974 { |
|
975 return cmdBld_CmdIeMeasurement (hCmdBld, pMeasurementParams, fCommandResponseCB, hCb); |
|
976 } |
|
977 |
|
978 |
|
979 /**************************************************************************** |
|
980 * cmdBld_measurementStop() |
|
981 **************************************************************************** |
|
982 * DESCRIPTION: send Command for stoping measurement |
|
983 * |
|
984 * INPUTS: None |
|
985 * |
|
986 * OUTPUT: None |
|
987 * |
|
988 * RETURNS: TI_OK or TI_NOK |
|
989 ****************************************************************************/ |
|
990 TI_STATUS cmdBld_CmdMeasurementStop (TI_HANDLE hCmdBld, void* fMeasureCommandResponseCB, TI_HANDLE hCb) |
|
991 { |
|
992 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
993 |
|
994 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "cmdBld_measurementStop\n"); |
|
995 |
|
996 return cmdBld_CmdIeMeasurementStop (hCmdBld, fMeasureCommandResponseCB, hCb); |
|
997 } |
|
998 |
|
999 |
|
1000 /**************************************************************************** |
|
1001 * cmdBld_ApDiscovery() |
|
1002 **************************************************************************** |
|
1003 * DESCRIPTION: send Command for AP Discovery |
|
1004 * to the mailbox |
|
1005 * |
|
1006 * INPUTS: None |
|
1007 * |
|
1008 * OUTPUT: None |
|
1009 * |
|
1010 * RETURNS: TI_OK or TI_NOK |
|
1011 ****************************************************************************/ |
|
1012 TI_STATUS cmdBld_CmdApDiscovery (TI_HANDLE hCmdBld, TApDiscoveryParams *pApDiscoveryParams, void *fCb, TI_HANDLE hCb) |
|
1013 { |
|
1014 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1015 |
|
1016 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_ApDiscovery\n"); |
|
1017 |
|
1018 return cmdBld_CmdIeApDiscovery (hCmdBld, pApDiscoveryParams, fCb, hCb); |
|
1019 } |
|
1020 |
|
1021 |
|
1022 /**************************************************************************** |
|
1023 * cmdBld_ApDiscoveryStop() |
|
1024 **************************************************************************** |
|
1025 * DESCRIPTION: send Command for stoping AP Discovery |
|
1026 * |
|
1027 * INPUTS: None |
|
1028 * |
|
1029 * OUTPUT: None |
|
1030 * |
|
1031 * RETURNS: TI_OK or TI_NOK |
|
1032 ****************************************************************************/ |
|
1033 TI_STATUS cmdBld_CmdApDiscoveryStop (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb) |
|
1034 { |
|
1035 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1036 |
|
1037 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_ApDiscoveryStop\n"); |
|
1038 |
|
1039 return cmdBld_CmdIeApDiscoveryStop (hCmdBld, fCb, hCb); |
|
1040 } |
|
1041 |
|
1042 |
|
1043 TI_STATUS cmdBld_CmdNoiseHistogram (TI_HANDLE hCmdBld, TNoiseHistogram *pNoiseHistParams, void *fCb, TI_HANDLE hCb) |
|
1044 { |
|
1045 return cmdBld_CmdIeNoiseHistogram (hCmdBld, pNoiseHistParams, fCb, hCb); |
|
1046 } |
|
1047 |
|
1048 |
|
1049 /**************************************************************************** |
|
1050 * cmdBld_PowerMgmtConfigurationSet () |
|
1051 **************************************************************************** |
|
1052 * DESCRIPTION: Set the ACX power management option IE |
|
1053 * |
|
1054 * INPUTS: powerSaveParams |
|
1055 * |
|
1056 * OUTPUT: |
|
1057 * |
|
1058 * RETURNS: TI_OK or TI_NOK |
|
1059 ****************************************************************************/ |
|
1060 TI_STATUS cmdBld_CmdSetPsMode (TI_HANDLE hCmdBld, TPowerSaveParams* powerSaveParams, void *fCb, TI_HANDLE hCb) |
|
1061 { |
|
1062 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1063 |
|
1064 /* Rate conversion is done in the HAL */ |
|
1065 cmdBld_ConvertAppRatesBitmap (powerSaveParams->NullPktRateModulation, |
|
1066 0, |
|
1067 &powerSaveParams->NullPktRateModulation); |
|
1068 |
|
1069 TRACE5(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, " cmdBld_PowerMgmtConfigurationSet ps802_11Enable=0x%x hangOverPeriod=%d needToSendNullData=0x%x numNullPktRetries=%d NullPktRateModulation=0x%x\n", powerSaveParams->ps802_11Enable, powerSaveParams->hangOverPeriod, powerSaveParams->needToSendNullData, powerSaveParams->numNullPktRetries, powerSaveParams->NullPktRateModulation); |
|
1070 |
|
1071 return cmdBld_CmdIeSetPsMode (hCmdBld, powerSaveParams, fCb, hCb); |
|
1072 } |
|
1073 |
|
1074 |
|
1075 /**************************************************************************** |
|
1076 * cmdBld_EnableRx() |
|
1077 **************************************************************************** |
|
1078 * DESCRIPTION: Enable Rx and send Start/Join command |
|
1079 * |
|
1080 * INPUTS: None |
|
1081 * |
|
1082 * OUTPUT: None |
|
1083 * |
|
1084 * RETURNS: TI_OK or TI_NOK |
|
1085 ****************************************************************************/ |
|
1086 TI_STATUS cmdBld_CmdEnableRx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb) |
|
1087 { |
|
1088 return cmdBld_CmdIeEnableRx (hCmdBld, fCb, hCb); |
|
1089 } |
|
1090 |
|
1091 |
|
1092 TI_STATUS cmdBld_CmdAddKey (TI_HANDLE hCmdBld, TSecurityKeys* pKey, TI_BOOL reconfFlag, void *fCb, TI_HANDLE hCb) |
|
1093 { |
|
1094 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1095 TI_UINT8 keyIdx = (TI_UINT8)pKey->keyIndex; |
|
1096 |
|
1097 /* store the security key for reconfigure phase (FW reload)*/ |
|
1098 if (reconfFlag != TI_TRUE) |
|
1099 { |
|
1100 if (keyIdx >= (pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION + NO_OF_EXTRA_RECONF_SECUR_KEYS)) |
|
1101 { |
|
1102 TRACE2(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_CmdAddKey: ERROR Key keyIndex field out of range =%d, range is (0 to %d)\n", pKey->keyIndex, pCmdBld->tSecurity.uNumOfStations * NO_OF_RECONF_SECUR_KEYS_PER_STATION+NO_OF_EXTRA_RECONF_SECUR_KEYS - 1); |
|
1103 |
|
1104 return TI_NOK; |
|
1105 } |
|
1106 |
|
1107 if (pKey->keyType == KEY_NULL) |
|
1108 { |
|
1109 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, "cmdBld_CmdAddKey: ERROR KeyType is NULL_KEY\n"); |
|
1110 |
|
1111 return TI_NOK; |
|
1112 } |
|
1113 |
|
1114 os_memoryCopy (pCmdBld->hOs, |
|
1115 (void *)(DB_KEYS(pCmdBld).pReconfKeys + keyIdx), |
|
1116 (void *)pKey, |
|
1117 sizeof(TSecurityKeys)); |
|
1118 } |
|
1119 |
|
1120 switch (pCmdBld->tSecurity.eSecurityMode) |
|
1121 { |
|
1122 case TWD_CIPHER_WEP: |
|
1123 case TWD_CIPHER_WEP104: |
|
1124 return cmdBld_CmdAddWepKey (hCmdBld, pKey, fCb, hCb); |
|
1125 |
|
1126 case TWD_CIPHER_TKIP: |
|
1127 case TWD_CIPHER_AES_CCMP: |
|
1128 #ifdef GEM_SUPPORT |
|
1129 case TWD_CIPHER_GEM: |
|
1130 #endif |
|
1131 return cmdBld_CmdAddWpaKey (hCmdBld, pKey, fCb, hCb); |
|
1132 |
|
1133 default: |
|
1134 return TI_NOK; |
|
1135 } |
|
1136 } |
|
1137 |
|
1138 |
|
1139 TI_STATUS cmdBld_CmdAddWpaKey (TI_HANDLE hCmdBld, TSecurityKeys* pKey, void *fCb, TI_HANDLE hCb) |
|
1140 { |
|
1141 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1142 |
|
1143 /* Only WEP, TKIP, AES keys are handled*/ |
|
1144 switch (pKey->keyType) |
|
1145 { |
|
1146 case KEY_WEP: |
|
1147 /* Configure the encKeys to the HW - default keys cache*/ |
|
1148 return cmdBld_CmdAddWepDefaultKey (hCmdBld, pKey, fCb, hCb); |
|
1149 |
|
1150 case KEY_TKIP: |
|
1151 /* Set the REAL TKIP key into the TKIP key cache*/ |
|
1152 if (cmdBld_CmdAddTkipMicMappingKey (hCmdBld, pKey, fCb, hCb) != TI_OK) |
|
1153 return TI_NOK; |
|
1154 |
|
1155 break; |
|
1156 |
|
1157 case KEY_AES: |
|
1158 if (cmdBld_CmdAddAesMappingKey (hCmdBld, pKey, fCb, hCb) != TI_OK) |
|
1159 return TI_NOK; |
|
1160 break; |
|
1161 |
|
1162 #ifdef GEM_SUPPORT |
|
1163 case KEY_GEM: |
|
1164 if (cmdBld_CmdAddGemMappingKey (hCmdBld, pKey, fCb, hCb) != TI_OK) |
|
1165 return TI_NOK; |
|
1166 break; |
|
1167 #endif |
|
1168 |
|
1169 default: |
|
1170 return TI_NOK; |
|
1171 } |
|
1172 |
|
1173 /* AES or TKIP key has been successfully added. Store the current */ |
|
1174 /* key type of the unicast (i.e. transmit !) key */ |
|
1175 if (!MAC_BROADCAST (pKey->macAddress)) |
|
1176 { |
|
1177 pCmdBld->tSecurity.eCurTxKeyType = pKey->keyType; |
|
1178 } |
|
1179 |
|
1180 return TI_OK; |
|
1181 } |
|
1182 |
|
1183 |
|
1184 TI_STATUS cmdBld_CmdRemoveWpaKey (TI_HANDLE hCmdBld, TSecurityKeys* pKey, void *fCb, TI_HANDLE hCb) |
|
1185 { |
|
1186 /* Only WEP, TKIP, AES keys are handled*/ |
|
1187 switch (pKey->keyType) |
|
1188 { |
|
1189 case KEY_WEP: |
|
1190 /* Configure the encKeys to the HW - default keys cache*/ |
|
1191 return cmdBld_CmdRemoveWepKey (hCmdBld, pKey, fCb, hCb); |
|
1192 |
|
1193 case KEY_TKIP: |
|
1194 /* Configure the encKeys to the HW - mapping keys cache*/ |
|
1195 /* configure through SET_KEYS command */ |
|
1196 |
|
1197 /* remove the TKIP key from the TKIP key cache*/ |
|
1198 if (cmdBld_CmdRemoveTkipMicMappingKey (hCmdBld, pKey, fCb, hCb) != TI_OK) |
|
1199 return (TI_NOK); |
|
1200 break; |
|
1201 |
|
1202 case KEY_AES: |
|
1203 if (cmdBld_CmdRemoveAesMappingKey (hCmdBld, pKey, fCb, hCb) != TI_OK) |
|
1204 return TI_NOK; |
|
1205 break; |
|
1206 |
|
1207 #ifdef GEM_SUPPORT |
|
1208 case KEY_GEM: |
|
1209 if (cmdBld_CmdRemoveGemMappingKey (hCmdBld, pKey, fCb, hCb) != TI_OK) |
|
1210 return TI_NOK; |
|
1211 break; |
|
1212 #endif |
|
1213 |
|
1214 default: |
|
1215 return TI_NOK; |
|
1216 } |
|
1217 |
|
1218 return TI_OK; |
|
1219 } |
|
1220 |
|
1221 |
|
1222 /* |
|
1223 * ---------------------------------------------------------------------------- |
|
1224 * Function : cmdBld_CmdRemoveKey |
|
1225 * |
|
1226 * Input : |
|
1227 * Output : |
|
1228 * Process : |
|
1229 * Note(s) : |
|
1230 * ----------------------------------------------------------------------------- |
|
1231 */ |
|
1232 TI_STATUS cmdBld_CmdRemoveKey (TI_HANDLE hCmdBld, TSecurityKeys* pKey, void *fCb, TI_HANDLE hCb) |
|
1233 { |
|
1234 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1235 TI_UINT8 keyIdx = (TI_UINT8)pKey->keyIndex; |
|
1236 |
|
1237 /* Clear the remove key in the reconfigure data base */ |
|
1238 (DB_KEYS(pCmdBld).pReconfKeys + keyIdx)->keyType = KEY_NULL; |
|
1239 |
|
1240 switch (pCmdBld->tSecurity.eSecurityMode) |
|
1241 { |
|
1242 case TWD_CIPHER_WEP: |
|
1243 case TWD_CIPHER_WEP104: |
|
1244 return cmdBld_CmdRemoveWepKey (hCmdBld, pKey, fCb, hCb); |
|
1245 case TWD_CIPHER_TKIP: |
|
1246 case TWD_CIPHER_AES_CCMP: |
|
1247 #ifdef GEM_SUPPORT |
|
1248 case TWD_CIPHER_GEM: |
|
1249 #endif |
|
1250 return cmdBld_CmdRemoveWpaKey (hCmdBld, pKey, fCb, hCb); |
|
1251 |
|
1252 default: |
|
1253 return TI_NOK; |
|
1254 } |
|
1255 } |
|
1256 |
|
1257 |
|
1258 /**************************************************************************** |
|
1259 * cmdBld_CmdAddWepKey() |
|
1260 **************************************************************************** |
|
1261 * DESCRIPTION: Decide wheather to call cmdBld_CmdAddWepDefaultKey, or cmdBld_CmdAddWepMappingKey |
|
1262 * |
|
1263 * INPUTS: |
|
1264 * |
|
1265 * OUTPUT: |
|
1266 * |
|
1267 * RETURNS: TI_OK or TI_NOK |
|
1268 ****************************************************************************/ |
|
1269 TI_STATUS cmdBld_CmdAddWepKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1270 { |
|
1271 /* Non WEP keys are trashed*/ |
|
1272 if (aSecurityKey->keyType != KEY_WEP) |
|
1273 { |
|
1274 return TI_NOK; |
|
1275 } |
|
1276 |
|
1277 return (cmdBld_CmdAddWepMappingKey (hCmdBld, aSecurityKey, fCb, hCb)); |
|
1278 |
|
1279 |
|
1280 } |
|
1281 |
|
1282 |
|
1283 /**************************************************************************** |
|
1284 * cmdBld_CmdRemoveWepKey() |
|
1285 **************************************************************************** |
|
1286 * DESCRIPTION: Decide wheather to call cmdBld_CmdRemoveWepDefaultKey, or cmdBld_CmdRemoveWepMappingKey |
|
1287 * |
|
1288 * INPUTS: |
|
1289 * |
|
1290 * OUTPUT: |
|
1291 * |
|
1292 * RETURNS: TI_OK or TI_NOK |
|
1293 ****************************************************************************/ |
|
1294 TI_STATUS cmdBld_CmdRemoveWepKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1295 { |
|
1296 /* Non WEP keys are trashed*/ |
|
1297 if (aSecurityKey->keyType != KEY_WEP) |
|
1298 { |
|
1299 return TI_NOK; |
|
1300 } |
|
1301 |
|
1302 /* Check for mapping key or default key */ |
|
1303 if ( MAC_NULL(&aSecurityKey->macAddress) ) |
|
1304 { |
|
1305 /* Configure the encKeys to the HW - default keys cache*/ |
|
1306 return (cmdBld_CmdRemoveWepDefaultKey (hCmdBld, aSecurityKey, fCb, hCb)); |
|
1307 } |
|
1308 else /* Use key mapping */ |
|
1309 { |
|
1310 return (cmdBld_CmdRemoveWepMappingKey (hCmdBld, aSecurityKey, fCb, hCb)); |
|
1311 } |
|
1312 |
|
1313 } |
|
1314 |
|
1315 /**************************************************************************** |
|
1316 * cmdBld_WepDefaultKeyAdd() |
|
1317 **************************************************************************** |
|
1318 * DESCRIPTION: Set the actual default key |
|
1319 * |
|
1320 * INPUTS: |
|
1321 * |
|
1322 * OUTPUT: |
|
1323 * |
|
1324 * RETURNS: TI_OK or TI_NOK |
|
1325 ****************************************************************************/ |
|
1326 TI_STATUS cmdBld_CmdAddWepDefaultKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1327 { |
|
1328 TI_STATUS status; |
|
1329 TI_UINT8 sMacAddrDummy[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
|
1330 |
|
1331 status = cmdBld_CmdIeSetKey (hCmdBld, |
|
1332 KEY_ADD_OR_REPLACE, |
|
1333 sMacAddrDummy, |
|
1334 aSecurityKey->encLen, |
|
1335 CIPHER_SUITE_WEP, |
|
1336 aSecurityKey->keyIndex, |
|
1337 (TI_UINT8*)aSecurityKey->encKey, |
|
1338 0, |
|
1339 0, |
|
1340 fCb, |
|
1341 hCb); |
|
1342 return status; |
|
1343 } |
|
1344 |
|
1345 /**************************************************************************** |
|
1346 * cmdBld_WepDefaultKeyRemove() |
|
1347 **************************************************************************** |
|
1348 * DESCRIPTION: Set the actual default key |
|
1349 * |
|
1350 * INPUTS: |
|
1351 * |
|
1352 * OUTPUT: |
|
1353 * |
|
1354 * RETURNS: TI_OK or TI_NOK |
|
1355 ****************************************************************************/ |
|
1356 TI_STATUS cmdBld_CmdSetWepDefaultKeyId (TI_HANDLE hCmdBld, TI_UINT8 aKeyIdVal, void *fCb, TI_HANDLE hCb) |
|
1357 { |
|
1358 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1359 TI_UINT8 sMacAddrDummy[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
|
1360 |
|
1361 /* Save the deafult key ID for reconfigure phase */ |
|
1362 DB_KEYS(pCmdBld).bDefaultKeyIdValid = TI_TRUE; |
|
1363 DB_KEYS(pCmdBld).uReconfDefaultKeyId = aKeyIdVal; |
|
1364 |
|
1365 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1366 KEY_SET_ID, |
|
1367 sMacAddrDummy, |
|
1368 0, |
|
1369 CIPHER_SUITE_WEP, |
|
1370 aKeyIdVal, |
|
1371 0, |
|
1372 0, |
|
1373 0, |
|
1374 fCb, |
|
1375 hCb); |
|
1376 } |
|
1377 |
|
1378 |
|
1379 /**************************************************************************** |
|
1380 * cmdBld_WepDefaultKeyRemove() |
|
1381 **************************************************************************** |
|
1382 * DESCRIPTION: Set the actual default key |
|
1383 * |
|
1384 * INPUTS: |
|
1385 * |
|
1386 * OUTPUT: |
|
1387 * |
|
1388 * RETURNS: TI_OK or TI_NOK |
|
1389 ****************************************************************************/ |
|
1390 TI_STATUS cmdBld_CmdRemoveWepDefaultKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1391 { |
|
1392 TI_UINT8 sMacAddrDummy[6] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}; |
|
1393 |
|
1394 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1395 KEY_REMOVE, |
|
1396 sMacAddrDummy, |
|
1397 aSecurityKey->encLen, |
|
1398 CIPHER_SUITE_WEP, |
|
1399 aSecurityKey->keyIndex, |
|
1400 (TI_UINT8*)aSecurityKey->encKey, |
|
1401 0, |
|
1402 0, |
|
1403 fCb, |
|
1404 hCb); |
|
1405 } |
|
1406 |
|
1407 /**************************************************************************** |
|
1408 * cmdBld_WepMappingKeyAdd() |
|
1409 **************************************************************************** |
|
1410 * DESCRIPTION: Set the actual mapping key |
|
1411 * |
|
1412 * INPUTS: |
|
1413 * |
|
1414 * OUTPUT: |
|
1415 * |
|
1416 * RETURNS: TI_OK or TI_NOK |
|
1417 ****************************************************************************/ |
|
1418 TI_STATUS cmdBld_CmdAddWepMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1419 { |
|
1420 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1421 KEY_ADD_OR_REPLACE, |
|
1422 (TI_UINT8*)aSecurityKey->macAddress, |
|
1423 aSecurityKey->encLen, |
|
1424 CIPHER_SUITE_WEP, |
|
1425 aSecurityKey->keyIndex, |
|
1426 (TI_UINT8*)aSecurityKey->encKey, |
|
1427 0, |
|
1428 0, |
|
1429 fCb, |
|
1430 hCb); |
|
1431 } |
|
1432 |
|
1433 /**************************************************************************** |
|
1434 * cmdBld_WepMappingKeyRemove() |
|
1435 **************************************************************************** |
|
1436 * DESCRIPTION: Set the actual mapping key |
|
1437 * |
|
1438 * INPUTS: |
|
1439 * |
|
1440 * OUTPUT: |
|
1441 * |
|
1442 * RETURNS: TI_OK or TI_NOK |
|
1443 ****************************************************************************/ |
|
1444 TI_STATUS cmdBld_CmdRemoveWepMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1445 { |
|
1446 /*In the new security interface it is not allowed to remove uni-cast keys. it will be cleaned on the next join command*/ |
|
1447 if (!MAC_BROADCAST(aSecurityKey->macAddress) ) |
|
1448 { |
|
1449 return TI_OK; |
|
1450 } |
|
1451 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1452 KEY_REMOVE, |
|
1453 (TI_UINT8*)aSecurityKey->macAddress, |
|
1454 aSecurityKey->encLen, |
|
1455 CIPHER_SUITE_WEP, |
|
1456 aSecurityKey->keyIndex, |
|
1457 (TI_UINT8*)aSecurityKey->encKey, |
|
1458 0, |
|
1459 0, |
|
1460 fCb, |
|
1461 hCb); |
|
1462 } |
|
1463 |
|
1464 |
|
1465 /**************************************************************************** |
|
1466 * cmdBld_TkipMicMappingKeyAdd() |
|
1467 **************************************************************************** |
|
1468 * DESCRIPTION: Set the actual mapping key |
|
1469 * |
|
1470 * INPUTS: |
|
1471 * |
|
1472 * OUTPUT: |
|
1473 * |
|
1474 * RETURNS: TI_OK or TI_NOK |
|
1475 ****************************************************************************/ |
|
1476 TI_STATUS cmdBld_CmdAddTkipMicMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1477 { |
|
1478 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1479 TI_UINT8 keyType; |
|
1480 TI_UINT8 keyBuffer[KEY_SIZE_TKIP]; |
|
1481 |
|
1482 keyType = CIPHER_SUITE_TKIP; |
|
1483 |
|
1484 os_memoryCopy (pCmdBld->hOs, (void*)(&keyBuffer[0]), (void*)aSecurityKey->encKey, 16); |
|
1485 os_memoryCopy (pCmdBld->hOs, (void*)(&keyBuffer[16]), (void*)aSecurityKey->micRxKey, 8); |
|
1486 os_memoryCopy (pCmdBld->hOs, (void*)(&keyBuffer[24]), (void*)aSecurityKey->micTxKey, 8); |
|
1487 |
|
1488 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1489 KEY_ADD_OR_REPLACE, |
|
1490 (TI_UINT8*)aSecurityKey->macAddress, |
|
1491 KEY_SIZE_TKIP, |
|
1492 keyType, |
|
1493 aSecurityKey->keyIndex, |
|
1494 (TI_UINT8*)keyBuffer, |
|
1495 pCmdBld->uSecuritySeqNumLow, |
|
1496 pCmdBld->uSecuritySeqNumHigh, |
|
1497 fCb, |
|
1498 hCb); |
|
1499 } |
|
1500 |
|
1501 /**************************************************************************** |
|
1502 * cmdBld_TkipMappingKeyAdd() |
|
1503 **************************************************************************** |
|
1504 * DESCRIPTION: Set the actual mapping key |
|
1505 * |
|
1506 * INPUTS: |
|
1507 * |
|
1508 * OUTPUT: |
|
1509 * |
|
1510 * RETURNS: TI_OK or TI_NOK |
|
1511 ****************************************************************************/ |
|
1512 TI_STATUS cmdBld_CmdRemoveTkipMicMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1513 { |
|
1514 TI_UINT8 keyType; |
|
1515 |
|
1516 keyType = CIPHER_SUITE_TKIP; |
|
1517 |
|
1518 /*In the new security interface it is not allowed to remove uni-cast keys. it will be cleaned on the next join command*/ |
|
1519 if (!MAC_BROADCAST(aSecurityKey->macAddress) ) |
|
1520 { |
|
1521 return TI_OK; |
|
1522 } |
|
1523 |
|
1524 |
|
1525 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1526 KEY_REMOVE, |
|
1527 (TI_UINT8*)aSecurityKey->macAddress, |
|
1528 aSecurityKey->encLen, |
|
1529 keyType, |
|
1530 aSecurityKey->keyIndex, |
|
1531 (TI_UINT8*)aSecurityKey->encKey, |
|
1532 0, |
|
1533 0, |
|
1534 fCb, |
|
1535 hCb); |
|
1536 } |
|
1537 |
|
1538 |
|
1539 /**************************************************************************** |
|
1540 * cmdBld_AesMappingKeyAdd() |
|
1541 **************************************************************************** |
|
1542 * DESCRIPTION: Set the actual Aes mapping key |
|
1543 * |
|
1544 * INPUTS: |
|
1545 * |
|
1546 * OUTPUT: |
|
1547 * |
|
1548 * RETURNS: TI_OK or TI_NOK |
|
1549 ****************************************************************************/ |
|
1550 TI_STATUS cmdBld_CmdAddAesMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1551 { |
|
1552 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1553 TI_UINT8 keyType; |
|
1554 |
|
1555 keyType = CIPHER_SUITE_AES; |
|
1556 |
|
1557 TRACE2(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_AesMappingKeyAdd: uSecuritySeqNumHigh=%ld, pHwCtrl->uSecuritySeqNumLow=%ld \n", pCmdBld->uSecuritySeqNumHigh, pCmdBld->uSecuritySeqNumLow); |
|
1558 |
|
1559 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1560 KEY_ADD_OR_REPLACE, |
|
1561 (TI_UINT8*)aSecurityKey->macAddress, |
|
1562 aSecurityKey->encLen, keyType, |
|
1563 aSecurityKey->keyIndex, |
|
1564 (TI_UINT8*)aSecurityKey->encKey, |
|
1565 pCmdBld->uSecuritySeqNumLow, |
|
1566 pCmdBld->uSecuritySeqNumHigh, |
|
1567 fCb, |
|
1568 hCb); |
|
1569 } |
|
1570 |
|
1571 |
|
1572 /**************************************************************************** |
|
1573 * cmdBld_AesMappingKeyRemove() |
|
1574 **************************************************************************** |
|
1575 * DESCRIPTION: Remove Aes mapping key |
|
1576 * |
|
1577 * INPUTS: |
|
1578 * |
|
1579 * OUTPUT: |
|
1580 * |
|
1581 * RETURNS: TI_OK or TI_NOK |
|
1582 ****************************************************************************/ |
|
1583 TI_STATUS cmdBld_CmdRemoveAesMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1584 { |
|
1585 TI_UINT8 keyType; |
|
1586 |
|
1587 keyType = CIPHER_SUITE_AES; |
|
1588 |
|
1589 /*In the new security interface it is not allowed to remove uni-cast keys. it will be cleaned on the next join command*/ |
|
1590 if (!MAC_BROADCAST(aSecurityKey->macAddress) ) |
|
1591 { |
|
1592 return TI_OK; |
|
1593 } |
|
1594 |
|
1595 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1596 KEY_REMOVE, |
|
1597 (TI_UINT8*)aSecurityKey->macAddress, |
|
1598 aSecurityKey->encLen, |
|
1599 keyType, |
|
1600 aSecurityKey->keyIndex, |
|
1601 (TI_UINT8*)aSecurityKey->encKey, |
|
1602 0, |
|
1603 0, |
|
1604 fCb, |
|
1605 hCb); |
|
1606 } |
|
1607 |
|
1608 /**************************************************************************** |
|
1609 * cmdBld_CmdSetStaState() |
|
1610 **************************************************************************** |
|
1611 * DESCRIPTION: Set station status . |
|
1612 * |
|
1613 * INPUTS: None |
|
1614 * |
|
1615 * OUTPUT: None |
|
1616 * |
|
1617 * RETURNS: TI_OK or TI_NOK |
|
1618 ****************************************************************************/ |
|
1619 TI_STATUS cmdBld_CmdSetStaState (TI_HANDLE hCmdBld, TI_UINT8 staState, void *fCb, TI_HANDLE hCb) |
|
1620 { |
|
1621 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1622 TWlanParams *pWlanParams = &DB_WLAN(hCmdBld); |
|
1623 |
|
1624 pWlanParams->bStaConnected = TI_TRUE; |
|
1625 TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION , "Sending StaState %d\n",staState); |
|
1626 |
|
1627 return cmdBld_CmdIeSetStaState (hCmdBld, staState, fCb, hCb); |
|
1628 } |
|
1629 |
|
1630 #ifdef GEM_SUPPORT |
|
1631 /**************************************************************************** |
|
1632 * cmdBld_CmdAddGemMappingKey() |
|
1633 **************************************************************************** |
|
1634 * DESCRIPTION: Set the actual GEM mapping key |
|
1635 * |
|
1636 * INPUTS: |
|
1637 * |
|
1638 * OUTPUT: |
|
1639 * |
|
1640 * RETURNS: TI_OK or TI_NOK |
|
1641 ****************************************************************************/ |
|
1642 TI_STATUS cmdBld_CmdAddGemMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1643 { |
|
1644 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1645 TI_UINT8 keyType; |
|
1646 TI_UINT8 keyBuffer[MAX_KEY_SIZE]; |
|
1647 |
|
1648 keyType = CIPHER_SUITE_GEM; |
|
1649 |
|
1650 os_memoryCopy (pCmdBld->hOs, (void*)(&keyBuffer[0]), (void*)aSecurityKey->encKey, 16); |
|
1651 os_memoryCopy (pCmdBld->hOs, (void*)(&keyBuffer[16]), (void*)aSecurityKey->micRxKey, 16); |
|
1652 |
|
1653 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1654 KEY_ADD_OR_REPLACE, |
|
1655 aSecurityKey->macAddress, |
|
1656 MAX_KEY_SIZE, |
|
1657 keyType, |
|
1658 aSecurityKey->keyIndex, |
|
1659 keyBuffer, |
|
1660 pCmdBld->uSecuritySeqNumLow, |
|
1661 pCmdBld->uSecuritySeqNumHigh, |
|
1662 fCb, |
|
1663 hCb); |
|
1664 } |
|
1665 |
|
1666 |
|
1667 /**************************************************************************** |
|
1668 * cmdBld_CmdRemoveGemMappingKey() |
|
1669 **************************************************************************** |
|
1670 * DESCRIPTION: Remove GEM mapping key |
|
1671 * |
|
1672 * INPUTS: |
|
1673 * |
|
1674 * OUTPUT: |
|
1675 * |
|
1676 * RETURNS: TI_OK or TI_NOK |
|
1677 ****************************************************************************/ |
|
1678 TI_STATUS cmdBld_CmdRemoveGemMappingKey (TI_HANDLE hCmdBld, TSecurityKeys* aSecurityKey, void *fCb, TI_HANDLE hCb) |
|
1679 { |
|
1680 TI_UINT8 keyType; |
|
1681 |
|
1682 keyType = CIPHER_SUITE_GEM; |
|
1683 |
|
1684 /*In the new security interface it is not allowed to remove uni-cast keys. it will be cleaned on the next join command*/ |
|
1685 if (!MAC_BROADCAST(aSecurityKey->macAddress) ) |
|
1686 { |
|
1687 return TI_OK; |
|
1688 } |
|
1689 |
|
1690 return cmdBld_CmdIeSetKey (hCmdBld, |
|
1691 KEY_REMOVE, |
|
1692 aSecurityKey->macAddress, |
|
1693 aSecurityKey->encLen, |
|
1694 keyType, |
|
1695 aSecurityKey->keyIndex, |
|
1696 aSecurityKey->encKey, |
|
1697 0, |
|
1698 0, |
|
1699 fCb, |
|
1700 hCb); |
|
1701 } |
|
1702 #endif /*GEM_SUPPORT*/ |
|
1703 |
|
1704 /**************************************************************************** |
|
1705 * cmdBld_healthCheck() |
|
1706 **************************************************************************** |
|
1707 * DESCRIPTION: |
|
1708 * |
|
1709 * INPUTS: |
|
1710 * |
|
1711 * OUTPUT: |
|
1712 * |
|
1713 * RETURNS: |
|
1714 ****************************************************************************/ |
|
1715 TI_STATUS cmdBld_CmdHealthCheck (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb) |
|
1716 { |
|
1717 TCmdBld *pCmdBld = (TCmdBld *)hCmdBld; |
|
1718 |
|
1719 TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CmdIeHealthCheck\n"); |
|
1720 |
|
1721 return cmdBld_CmdIeHealthCheck (hCmdBld, fCb, hCb); |
|
1722 } |
|
1723 |
|
1724 TI_STATUS cmdBld_CmdTest (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb, TTestCmd* pTestCmd) |
|
1725 { |
|
1726 return cmdBld_CmdIeTest (hCmdBld, fCb, hCb, pTestCmd); |
|
1727 } |
|
1728 |
|
1729 |