1 /****************************************************************************
2 **+-----------------------------------------------------------------------+**
3 **| |**
4 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |**
5 **| All rights reserved. |**
6 **| |**
7 **| Redistribution and use in source and binary forms, with or without |**
8 **| modification, are permitted provided that the following conditions |**
9 **| are met: |**
10 **| |**
11 **| * Redistributions of source code must retain the above copyright |**
12 **| notice, this list of conditions and the following disclaimer. |**
13 **| * Redistributions in binary form must reproduce the above copyright |**
14 **| notice, this list of conditions and the following disclaimer in |**
15 **| the documentation and/or other materials provided with the |**
16 **| distribution. |**
17 **| * Neither the name Texas Instruments nor the names of its |**
18 **| contributors may be used to endorse or promote products derived |**
19 **| from this software without specific prior written permission. |**
20 **| |**
21 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |**
22 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |**
23 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |**
24 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |**
25 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |**
26 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |**
27 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |**
28 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |**
29 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |**
30 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |**
31 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |**
32 **| |**
33 **+-----------------------------------------------------------------------+**
34 ****************************************************************************/
35
36 /****************************************************************************
37 *
38 * MODULE: whalHwCtrl.c
39 * PURPOSE: Implements action on the wlan hardware card (Reset, Run, SendCmd, Sw Download)
40 *
41 ****************************************************************************/
42
43 #include "802_11Defs.h"
44 #include "Ethernet.h"
45 #include "whalCommon.h"
46
47 #include "whalCtrl_api.h"
48 #include "whalHwDefs.h"
49 #include "whalHwCtrl.h"
50 #include "whalHwMboxCmd.h"
51 #include "whalHwMboxConfig.h"
52 #include "eventMbox_api.h"
53 #include "whalParams.h"
54 #include "commonTypes.h"
55 #include "txResult_api.h"
56 #include "TNETW_Driver_api.h"
57 #include "TNETW_Driver.h"
58 #include "whalSecurity.h"
59
60
61 #define ACX_POWER_MGMT_OPTIONS_STRUCT_DEBUG 0
62
63 int whal_hwCtrl_ConfigTemplates(HwCtrl_T *pHwCtrl);
64 int whal_hwCtrl_ConfigQueues(HwCtrl_T *pHwCtrl, UINT32 MemoryStart);
65 void whal_hwCtrl_OverridePhyRegsDefaults(HwCtrl_T *pHwCtrl);
66
67
68 #define CF_FORM_FACTOR 3 /* Compact Flash*/
69
70 #define CB_FORM_FACTOR 1 /* Card Bus */
71
72 /****************************************************************************
73 * whal_hwCtrl_Create()
74 ****************************************************************************
75 * DESCRIPTION: Create the wlan hardware control object
76 *
77 * INPUTS:
78 *
79 * OUTPUT: None
80 *
81 * RETURNS: The Created object
82 ****************************************************************************/
whal_hwCtrl_Create(TI_HANDLE hOs,WhalParams_T * pWhalParams)83 HwCtrl_T *whal_hwCtrl_Create(TI_HANDLE hOs, WhalParams_T *pWhalParams)
84 {
85 HwCtrl_T *pHwCtrl;
86
87 pHwCtrl = os_memoryAlloc(hOs, sizeof(HwCtrl_T));
88 if (pHwCtrl == NULL)
89 return NULL;
90
91 os_memoryZero(hOs, (void*)pHwCtrl, sizeof(HwCtrl_T));
92
93 pHwCtrl->hOs = hOs;
94 pHwCtrl->pWhalParams = pWhalParams;
95 pHwCtrl->pHwMboxCmd = whal_hwMboxCmd_Create(hOs, pHwCtrl->pWhalParams);
96 pHwCtrl->pHwMboxCmdBit = whal_hwMboxCmdBit_Create(hOs);
97 pHwCtrl->pHwMboxConfig = whal_hwMboxConfig_Create(hOs);
98 pHwCtrl->hWhalBus = whalBus_Create(hOs);
99
100 if ( (!pHwCtrl->pHwMboxCmd) || (!pHwCtrl->pHwMboxConfig) || (!pHwCtrl->hWhalBus) )
101 {
102 whal_hwCtrl_Destroy(pHwCtrl);
103 return NULL;
104 }
105
106 return(pHwCtrl);
107 }
108
109 /****************************************************************************
110 * whal_hwCtrl_Destroy()
111 ****************************************************************************
112 * DESCRIPTION: Destroy the object
113 *
114 * INPUTS:
115 * pHwCtrl The object to free
116 *
117 * OUTPUT: None
118 *
119 * RETURNS: OK or NOK
120 ****************************************************************************/
whal_hwCtrl_Destroy(HwCtrl_T * pHwCtrl)121 int whal_hwCtrl_Destroy(HwCtrl_T *pHwCtrl)
122 {
123 if (pHwCtrl == NULL)
124 return OK;
125
126 whal_hwMboxCmd_Destroy(pHwCtrl->pHwMboxCmd);
127 whal_hwMboxCmdBit_Destroy(pHwCtrl->pHwMboxCmdBit);
128 whal_hwMboxConfig_Destroy(pHwCtrl->pHwMboxConfig);
129 whalBus_Destroy(pHwCtrl->hWhalBus);
130
131 os_memoryFree(pHwCtrl->hOs, pHwCtrl, sizeof(HwCtrl_T));
132 return OK;
133 }
134
135
136 /****************************************************************************
137 * whal_hwCtrl_GetTnentwifHandle()
138 ****************************************************************************
139 * DESCRIPTION: Return TNETWIF handle
140 *
141 * INPUTS:
142 * pHwCtrl The object to free
143 *
144 * OUTPUT: None
145 *
146 * RETURNS: TNETWIF handle
147 ****************************************************************************/
whal_hwCtrl_GetTnentwifHandle(HwCtrl_T * pHwCtrl)148 TI_HANDLE whal_hwCtrl_GetTnentwifHandle (HwCtrl_T *pHwCtrl)
149 {
150 return whalBus_GetTnentwifHandle (pHwCtrl->hWhalBus);
151 }
152
153
154 /****************************************************************************
155 * whal_hwCtrl_StartJoin()
156 ****************************************************************************
157 * DESCRIPTION: Enable Rx/Tx and send Start/Join command
158 *
159 * INPUTS: None
160 *
161 * OUTPUT: None
162 *
163 * RETURNS: OK or NOK
164 ****************************************************************************/
whal_hwCtrl_StartJoin(HwCtrl_T * pHwCtrl,bssType_e BssType,void * JoinCompleteCB,TI_HANDLE CB_handle)165 int whal_hwCtrl_StartJoin(HwCtrl_T *pHwCtrl, bssType_e BssType, void *JoinCompleteCB, TI_HANDLE CB_handle)
166 {
167 HwMboxCmd_T *pHwMboxCmd = pHwCtrl->pHwMboxCmd;
168 UINT8 HwBssType;
169 #ifdef TI_DBG
170 UINT8 *pBssId = whal_ParamsGetBssId(pHwCtrl->pWhalParams);
171
172 WLAN_REPORT_INIT(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
173 ("whal_hwCtrl_StartJoin: Enable Tx, Rx and Start the Bss, type=%d\n", BssType));
174 WLAN_REPORT_INIT(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
175 ("------------------------------------------------------------\n"));
176 WLAN_REPORT_INIT(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
177 ("START/JOIN, SSID=%s, BSSID=%02X-%02X-%02X-%02X-%02X-%02X, Chan=%d\n", whal_ParamsGetElm_Ssid(pHwCtrl->pWhalParams)->serviceSetId, pBssId[0], pBssId[1], pBssId[2], pBssId[3], pBssId[4], pBssId[5], whal_ParamsGetRadioChannel(pHwCtrl->pWhalParams)));
178 WLAN_REPORT_INIT(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
179 ("------------------------------------------------------------\n"));
180 #endif /* TI_DBG */
181
182 /*
183 * Set frame rates according to the values previously configured:
184 * Driver join -> as configured to whalCtrl_JoinBss()
185 * GWSI join -> as configured to the template framed before, or default values
186 * Recovery -> Saved parameters from last Join command
187 */
188 whal_hwCtrl_SetFrameRate(pHwCtrl,
189 pHwCtrl->pWhalParams->BssInfoParams.txCtrlFrmRate,
190 pHwCtrl->pWhalParams->BssInfoParams.txCtrlFrmModulation,
191 pHwCtrl->pWhalParams->BssInfoParams.txMgmtFrmRate,
192 pHwCtrl->pWhalParams->BssInfoParams.txMgmtFrmModulation);
193 /*
194 * set RxFilter (but don't write it to the FW, this is done in the join command),
195 * Configure templates content, ...
196 */
197 whal_hwCtrl_SetBssType(pHwCtrl, BssType, &HwBssType);
198
199 return whal_hwMboxCmd_StartBss(pHwMboxCmd, HwBssType, JoinCompleteCB, CB_handle);
200
201 }
202
203
204 /****************************************************************************
205 * whal_hwCtrl_switchChannel()
206 ****************************************************************************
207 * DESCRIPTION: Switching the serving channel
208 *
209 * INPUTS: channel - new channel number
210 *
211 * OUTPUT: None
212 *
213 * RETURNS: OK or NOK
214 ****************************************************************************/
whal_hwCtrl_switchChannel(HwCtrl_T * pHwCtrl,UINT8 channel)215 int whal_hwCtrl_switchChannel(HwCtrl_T *pHwCtrl,UINT8 channel)
216 {
217 HwMboxCmd_T *pHwMboxCmd = pHwCtrl->pHwMboxCmd;
218
219 return whal_hwMboxCmd_EnableTx(pHwMboxCmd,channel);
220 }
221
222
223 /****************************************************************************
224 * whal_hwCtrl_DisableTx()
225 ****************************************************************************
226 * DESCRIPTION: Disable Tx path.
227 *
228 * INPUTS: None
229 *
230 * OUTPUT: None
231 *
232 * RETURNS: OK or NOK
233 ****************************************************************************/
whal_hwCtrl_DisableTx(HwCtrl_T * pHwCtrl)234 int whal_hwCtrl_DisableTx(HwCtrl_T *pHwCtrl)
235 {
236 HwMboxCmd_T *pHwMboxCmd = pHwCtrl->pHwMboxCmd;
237
238 return whal_hwMboxCmd_DisableTx(pHwMboxCmd);
239 }
240
241 /****************************************************************************
242 * whal_hwCtrl_EnableTx()
243 ****************************************************************************
244 * DESCRIPTION: Disable Tx path.
245 *
246 * INPUTS: channel - new channel number
247 *
248 * OUTPUT: None
249 *
250 * RETURNS: OK or NOK
251 ****************************************************************************/
whal_hwCtrl_EnableTx(HwCtrl_T * pHwCtrl,int channel)252 int whal_hwCtrl_EnableTx(HwCtrl_T *pHwCtrl, int channel)
253 {
254 HwMboxCmd_T *pHwMboxCmd = pHwCtrl->pHwMboxCmd;
255
256 return whal_hwMboxCmd_EnableTx(pHwMboxCmd, (UINT8)channel);
257 }
258
259
260 /****************************************************************************
261 * whal_hwCtrl_EnableDataPath()
262 ****************************************************************************
263 * DESCRIPTION: Enable Rx/Tx and send Start/Join command
264 *
265 * INPUTS: None
266 *
267 * OUTPUT: None
268 *
269 * RETURNS: OK or NOK
270 ****************************************************************************/
whal_hwCtrl_EnableDataPath(HwCtrl_T * pHwCtrl)271 int whal_hwCtrl_EnableDataPath(HwCtrl_T *pHwCtrl)
272 {
273 HwMboxCmd_T *pHwMboxCmd = pHwCtrl->pHwMboxCmd;
274
275 whal_hwMboxCmd_EnableRx(pHwMboxCmd);
276 whal_hwMboxCmd_EnableTx(pHwMboxCmd, whal_ParamsGetDefaultChannel(pHwCtrl->pWhalParams));
277
278
279 #ifdef WDBG_POLLING /* (!!!) ONLY FOR DEBUG WHEN THERE ARE NO INTERRUPTS */
280
281 /* allocate OS timer memory */
282 hal_timer = os_timerCreate(pHwCtrl->hOs, whal_hwCtrl_RxPollingTimeout, (TI_HANDLE) pHwCtrl);
283 if (!hal_timer)
284 return NOK;
285
286 os_timerStart(pHwCtrl->hOs, hal_timer, 20, FALSE);
287 #endif
288
289 return OK;
290 }
291
292 /****************************************************************************
293 * whal_hwCtrl_EnableDataPath()
294 ****************************************************************************
295 * DESCRIPTION: Enable Rx/Tx and send Start/Join command
296 *
297 * INPUTS: None
298 *
299 * OUTPUT: None
300 *
301 * RETURNS: OK or NOK
302 ****************************************************************************/
whal_hwCtrl_DisableDataPath(HwCtrl_T * pHwCtrl)303 int whal_hwCtrl_DisableDataPath(HwCtrl_T *pHwCtrl)
304 {
305 #if 0
306 HwMboxCmd_T *pHwMboxCmd = pHwCtrl->pHwMboxCmd;
307 /*
308 * L.M. removed because of two reasons:
309 * 1. When the FW is dead, it only adds delay to recovery.
310 * 2. WSP does not have it.
311 */
312
313 whal_hwMboxCmd_DisableTx(pHwMboxCmd);
314 whal_hwMboxCmd_DisableRx(pHwMboxCmd);
315
316
317 /* use FwEvent ... whalBus_hwIntr_Disable(pHwCtrl->hWhalBus, HAL_ALL_INTERRUPTS); */
318 #endif
319
320 return OK;
321 }
322
323 /****************************************************************************
324 * whal_hwCtrl_SetBssType()
325 ****************************************************************************
326 * DESCRIPTION: Set Bss type, set RxFilter
327 *
328 * INPUTS: None
329 *
330 * OUTPUT: None
331 *
332 * RETURNS: OK or NOK
333 ****************************************************************************/
whal_hwCtrl_SetBssType(HwCtrl_T * pHwCtrl,bssType_e BssType,UINT8 * HwBssType)334 int whal_hwCtrl_SetBssType(HwCtrl_T *pHwCtrl, bssType_e BssType, UINT8 *HwBssType)
335 {
336 switch (BssType)
337 {
338 case BSS_AP:
339 whal_ParamsSetBssType(pHwCtrl->pWhalParams, BSS_TYPE_AP_BSS);
340 whal_ParamsSetRxFilter(pHwCtrl->pWhalParams, RX_CONFIG_OPTION_ANY_DST_MY_BSS, RX_FILTER_OPTION_DEF);
341 break;
342
343 case BSS_INFRASTRUCTURE:
344 whal_ParamsSetBssType(pHwCtrl->pWhalParams, BSS_TYPE_STA_BSS);
345 whal_ParamsSetRxFilter(pHwCtrl->pWhalParams, RX_CONFIG_OPTION_FOR_JOIN, RX_FILTER_OPTION_JOIN);
346 break;
347
348 case BSS_INDEPENDENT:
349 whal_ParamsSetBssType(pHwCtrl->pWhalParams, BSS_TYPE_IBSS);
350 #ifdef GWSI_LIB
351 /* In GWSI we filter with SSID. This is not done in the full driver because of RTP version.
352 * In the future leave only GWSI option for both cases.
353 */
354 whal_ParamsSetRxFilter(pHwCtrl->pWhalParams, RX_CONFIG_OPTION_FOR_IBSS_JOIN, RX_FILTER_OPTION_DEF);
355 #else
356 whal_ParamsSetRxFilter(pHwCtrl->pWhalParams, RX_CONFIG_OPTION_FOR_JOIN, RX_FILTER_OPTION_DEF);
357 #endif
358 break;
359
360 default:
361 WLAN_REPORT_FATAL_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
362 ("whal_hwCtrl_SetBssType: FATAL_ERROR, unknown BssType %d\n", BssType));
363 return NOK;
364 }
365
366 *HwBssType = whal_ParamsGetBssType(pHwCtrl->pWhalParams);
367
368 return OK;
369 }
370
371
372 /****************************************************************************
373 * whal_hwCtrl_setRxFilters()
374 ****************************************************************************
375 * DESCRIPTION: Sets the filters according to the given configuration.
376 *
377 * INPUTS: RxConfigOption - The given Rx filters configuration
378 * RxFilterOption - The given Rx filters options
379 *
380 * OUTPUT: None
381 *
382 * RETURNS: OK or NOK
383 ****************************************************************************/
whal_hwCtrl_setRxFilters(HwCtrl_T * pHwCtrl,UINT32 RxConfigOption,UINT32 RxFilterOption)384 int whal_hwCtrl_setRxFilters(HwCtrl_T *pHwCtrl, UINT32 RxConfigOption, UINT32 RxFilterOption)
385 {
386 whal_ParamsSetRxFilter(pHwCtrl->pWhalParams, RxConfigOption, RxFilterOption);
387
388 return whal_hwInfoElemRxConfigSet (pHwCtrl->pHwMboxConfig,
389 &pHwCtrl->pWhalParams->WlanParams.RxConfigOption,
390 &pHwCtrl->pWhalParams->WlanParams.RxFilterOption);
391 }
392
393
394 /****************************************************************************
395 * whal_hwCtrl_GetRxFilters()
396 ****************************************************************************
397 * DESCRIPTION: Sets the filters according to the given configuration.
398 *
399 * INPUTS: RxConfigOption - The given Rx filters configuration
400 * RxFilterOption - The given Rx filters options
401 *
402 * OUTPUT: None
403 *
404 * RETURNS: OK or NOK
405 ****************************************************************************/
whal_hwCtrl_GetRxFilters(HwCtrl_T * pHwCtrl,UINT32 * pRxConfigOption,UINT32 * pRxFilterOption)406 int whal_hwCtrl_GetRxFilters(HwCtrl_T *pHwCtrl, UINT32* pRxConfigOption, UINT32* pRxFilterOption)
407 {
408 whal_ParamsGetRxFilter(pHwCtrl->pWhalParams, pRxConfigOption, pRxFilterOption);
409
410 return OK;
411 }
412
413
414 /****************************************************************************
415 * whal_hwCtrl_setRxDataFiltersParams()
416 ****************************************************************************
417 * DESCRIPTION: Enables or disables Rx data filtering.
418 *
419 * INPUTS: enabled - 0 to disable data filtering, any other value to enable.
420 * defaultAction - The default action to take on non-matching packets.
421 *
422 * OUTPUT: None
423 *
424 * RETURNS: OK or NOK
425 ****************************************************************************/
whal_hwCtrl_setRxDataFiltersParams(HwCtrl_T * pHwCtrl,BOOL enabled,filter_e defaultAction)426 int whal_hwCtrl_setRxDataFiltersParams(HwCtrl_T * pHwCtrl, BOOL enabled, filter_e defaultAction)
427 {
428 return whal_hwInfoElemSetRxDataFiltersParams(pHwCtrl->pHwMboxConfig, enabled, defaultAction);
429 }
430
431
432 /****************************************************************************
433 * whal_hwCtrl_setRxDataFilter()
434 ****************************************************************************
435 * DESCRIPTION: Sets the filters according to the given configuration.
436 *
437 * INPUTS: index - Index of the Rx Data filter
438 * command - Add or remove the filter
439 * action - Action to take on packets matching the pattern
440 * numFieldPatterns - Number of field patterns in the filter
441 * lenFieldPatterns - Length of the field pattern series
442 * fieldPatterns - Series of field patterns
443 *
444 * OUTPUT: None
445 *
446 * RETURNS: OK or NOK
447 ****************************************************************************/
whal_hwCtrl_setRxDataFilter(HwCtrl_T * pHwCtrl,UINT8 index,UINT8 command,filter_e action,UINT8 numFieldPatterns,UINT8 lenFieldPatterns,UINT8 * fieldPatterns)448 int whal_hwCtrl_setRxDataFilter(HwCtrl_T * pHwCtrl, UINT8 index, UINT8 command, filter_e action, UINT8 numFieldPatterns, UINT8 lenFieldPatterns, UINT8 * fieldPatterns)
449 {
450 return whal_hwInfoElemSetRxDataFilter(pHwCtrl->pHwMboxConfig,
451 index, command, action, numFieldPatterns, lenFieldPatterns, fieldPatterns);
452 }
453
454
455 /****************************************************************************
456 * whal_hwCtrl_SetarpIpAddressesTable()
457 ****************************************************************************
458 * DESCRIPTION: Sets the ARP IP table according to the given configuration.
459 *
460 * OUTPUT: None
461 *
462 * RETURNS: OK or NOK
463 ****************************************************************************/
whal_hwCtrl_SetarpIpAddressesTable(HwCtrl_T * pHwCtrl,IpAddress_t * IP_addr,UINT8 isEnabled,IPver_e IP_ver)464 int whal_hwCtrl_SetarpIpAddressesTable (HwCtrl_T *pHwCtrl, IpAddress_t *IP_addr, UINT8 isEnabled , IPver_e IP_ver)
465 {
466 if ( NULL == IP_addr )
467 {
468 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
469 ("whal_hwCtrl_SetarpIpAddressesTable: Ip Addr ptr = NULL !!!\n"));
470
471 return PARAM_VALUE_NOT_VALID ;
472 }
473
474 whal_ParamsSetarpIpAddressesTable(pHwCtrl->pWhalParams, IP_addr, IP_ver);
475 whal_ParamsSetarpIpFilterEnabled(pHwCtrl->pWhalParams, isEnabled);
476
477 WLAN_REPORT_DEBUG_CONTROL (pHwCtrl->hReport,
478 ("\n whal_hwCtrl_SetarpIpAddressesTable - ip filtering : %d.%d.%d.%d \n" , IP_addr->addr[0] , IP_addr->addr[1] , IP_addr->addr[2] , IP_addr->addr[3] )) ;
479
480 /* Set the new ip with the current state (e/d) */
481 return whal_hwInfoElemarpIpAddressesTableSet (pHwCtrl->pHwMboxConfig,
482 IP_addr,
483 (UINT32)isEnabled);
484 }
485
486 /****************************************************************************
487 * whalCtrl_GetArpIpAddressesTable()
488 ****************************************************************************
489 * DESCRIPTION: Sets the Group table according to the given configuration.
490 *
491 * OUTPUT: None
492 *
493 * RETURNS: OK or NOK
494 ****************************************************************************/
whalCtrl_GetArpIpAddressesTable(HwCtrl_T * pHwCtrl,IpAddress_t * IP_addr,UINT8 * pisEnabled,IPver_e * pIP_ver)495 int whalCtrl_GetArpIpAddressesTable (HwCtrl_T *pHwCtrl, IpAddress_t *IP_addr, UINT8* pisEnabled , IPver_e* pIP_ver)
496 {
497 if ( NULL == pHwCtrl )
498 {
499 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
500 ("whalCtrl_GetArpIpAddressesTable = pHwCtrl NULL !!!\n"));
501
502 return PARAM_VALUE_NOT_VALID ;
503 }
504
505 if ( NULL == pHwCtrl->pWhalParams )
506 {
507 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
508 ("whalCtrl_GetArpIpAddressesTable = pHwCtrl->pWhalParams NULL !!!\n"));
509
510 return PARAM_VALUE_NOT_VALID ;
511
512 }
513
514 whal_ParamsGetarpIpAddressesTable(pHwCtrl->pWhalParams, IP_addr, pIP_ver);
515 whal_ParamsGetarpIpFilterEnabled(pHwCtrl->pWhalParams, pisEnabled);
516 return OK;
517 }
518
519 /****************************************************************************
520 * whal_hwCtrl_SetarpIpFilterEnabled()
521 ****************************************************************************
522 * DESCRIPTION: Enable\Disable the ARP filter
523 *
524 * OUTPUT: None
525 *
526 * RETURNS: OK or NOK
527 ****************************************************************************/
whal_hwCtrl_SetarpIpFilterEnabled(HwCtrl_T * pHwCtrl,UINT8 isEnabled)528 int whal_hwCtrl_SetarpIpFilterEnabled(HwCtrl_T *pHwCtrl, UINT8 isEnabled )
529 {
530 IpAddress_t *IP_addr = &(pHwCtrl->pWhalParams->WlanParams.arp_IP_addr) ;
531 if ( NULL == pHwCtrl )
532 {
533 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
534 ("whal_hwCtrl_SetarpIpFilterEnabled = pHwCtrl NULL !!!\n"));
535
536 return PARAM_VALUE_NOT_VALID ;
537 }
538
539 /* set the current ip address with the new state (e/d) */
540 whal_ParamsSetarpIpFilterEnabled(pHwCtrl->pWhalParams, isEnabled);
541 return whal_hwInfoElemarpIpAddressesTableSet (pHwCtrl->pHwMboxConfig,
542 IP_addr,
543 (UINT32)isEnabled);
544 }
545
546 /****************************************************************************
547 * whal_hwCtrl_SetGroupAddressesTable()
548 ****************************************************************************
549 * DESCRIPTION: Sets the Group table according to the given configuration.
550 *
551 * OUTPUT: None
552 *
553 * RETURNS: OK or NOK
554 ****************************************************************************/
whal_hwCtrl_SetGroupAddressesTable(HwCtrl_T * pHwCtrl,UINT8 numGroupAddrs,macAddress_t * Group_addr,UINT8 isEnabled)555 int whal_hwCtrl_SetGroupAddressesTable (HwCtrl_T *pHwCtrl,
556 UINT8 numGroupAddrs,
557 macAddress_t *Group_addr,
558 UINT8 isEnabled)
559 {
560 if ( NULL == pHwCtrl )
561 {
562 return PARAM_VALUE_NOT_VALID;
563 }
564
565 if ( NULL == Group_addr)
566 {
567 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
568 ("whal_hwCtrl_SetGroupAddressesTable: numGroupAddrs=%d Group_addr=0x%x !!!\n", numGroupAddrs , Group_addr));
569 return PARAM_VALUE_NOT_VALID;
570 }
571
572 /* Keeps the parameters in the whal */
573 whal_ParamsSetGroupAddressesTable(pHwCtrl->pWhalParams, isEnabled, numGroupAddrs, Group_addr);
574
575 /* Keeps the parameters in the whal for recovery */
576 return whal_hwInfoElemGroupAdressesTableSet (pHwCtrl->pHwMboxConfig,
577 &numGroupAddrs,
578 Group_addr,
579 &isEnabled);
580 }
581
582 /****************************************************************************
583 * whal_hwCtrl_SetRtsThreshold()
584 ****************************************************************************
585 * DESCRIPTION: Sets the Rts Threshold.
586 *
587 * OUTPUT: None
588 *
589 * RETURNS: OK or NOK pWlanParams->RtsThreshold
590 ****************************************************************************/
whal_hwCtrl_SetRtsThreshold(HwCtrl_T * pHwCtrl,UINT16 RtsThreshold)591 int whal_hwCtrl_SetRtsThreshold (HwCtrl_T *pHwCtrl,UINT16 RtsThreshold)
592 {
593 return whal_hwInfoElemRtsThresholdSet (pHwCtrl->pHwMboxConfig, RtsThreshold);
594 }
595
596 /****************************************************************************
597 * whal_hwCtrl_ConfigCb()
598 ****************************************************************************
599 * DESCRIPTION: Config the object
600 *
601 * INPUTS:
602 *
603 * OUTPUT: None
604 *
605 * RETURNS: OK or NOK
606 ****************************************************************************/
whal_hwCtrl_ConfigCb(TI_HANDLE hHwCtrl,TI_STATUS status)607 static void whal_hwCtrl_ConfigCb (TI_HANDLE hHwCtrl, TI_STATUS status)
608 {
609 HwCtrl_T *pHwCtrl = (HwCtrl_T*)hHwCtrl;
610 WHAL_CTRL *pWhalCtrl = (WHAL_CTRL *)pHwCtrl->hWhalCtrl;
611
612 whal_hwMboxCmd_Config(pHwCtrl->pHwMboxCmd, ((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->hCmdQueue, pHwCtrl->hReport);
613 CmdQueue_Config(((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->hCmdQueue,
614 ((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->hCmdMBox, pHwCtrl->hReport);
615 whal_hwMboxCmdBit_Config(pHwCtrl->hWhalCtrl, pHwCtrl->pHwMboxCmdBit, ((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->hCmdQueue, pHwCtrl->hReport);
616 whal_hwMboxConfig_Config(pHwCtrl->pHwMboxConfig, ((TnetwDrv_t*)pWhalCtrl->hTNETW_Driver)->hCmdQueue, pHwCtrl->hReport);
617
618 /* This will initiate the download to the FW */
619 status = whal_hwCtrl_Initiate (pHwCtrl);
620 if (status == TNETWIF_ERROR)
621 {
622 WLAN_REPORT_ERROR (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
623 ("whal_hwCtrl_Config: failed to initialize\n"));
624 }
625 }
626
627 /****************************************************************************
628 * whal_hwCtrl_GetGroupAddressesTable()
629 ****************************************************************************
630 * DESCRIPTION: Sets the Group table according to the given configuration.
631 *
632 * OUTPUT: None
633 *
634 * RETURNS: OK or NOK
635 ****************************************************************************/
whal_hwCtrl_GetGroupAddressesTable(HwCtrl_T * pHwCtrl,UINT8 * pisEnabled,UINT8 * pnumGroupAddrs,macAddress_t * Group_addr)636 int whal_hwCtrl_GetGroupAddressesTable (HwCtrl_T *pHwCtrl,
637 UINT8* pisEnabled, UINT8* pnumGroupAddrs, macAddress_t *Group_addr)
638 {
639 if ( NULL == pHwCtrl )
640 {
641 return PARAM_VALUE_NOT_VALID;
642 }
643
644 if ( (NULL == pisEnabled) || (NULL == pnumGroupAddrs) || (NULL == Group_addr))
645 {
646 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
647 ("whal_hwCtrl_GetGroupAddressesTable: pisEnabled=0x%p pnumGroupAddrs=0x%p Group_addr=0x%p !!!\n", pisEnabled , pnumGroupAddrs, Group_addr));
648 return PARAM_VALUE_NOT_VALID;
649 }
650
651 whal_ParamsGetGroupAddressesTable(pHwCtrl->pWhalParams, pisEnabled, pnumGroupAddrs, Group_addr);
652 return OK;
653 }
654
655
656 /****************************************************************************
657 * whal_hwCtrl_Config()
658 ****************************************************************************
659 * DESCRIPTION: Config the object
660 *
661 * INPUTS:
662 *
663 * OUTPUT: None
664 *
665 * RETURNS: OK or NOK
666 ****************************************************************************/
whal_hwCtrl_Config(HwCtrl_T * pHwCtrl,TI_HANDLE hWhalCtrl,UINT8 AccessMode,UINT32 AcxRegAddr,UINT32 AcxMemAddr,TI_HANDLE hReport,TI_HANDLE hMemMgr,UINT32 * pFWImage,TI_HANDLE hEventMbox)667 TI_STATUS whal_hwCtrl_Config
668 (
669 HwCtrl_T *pHwCtrl,
670 TI_HANDLE hWhalCtrl,
671 UINT8 AccessMode,
672 UINT32 AcxRegAddr,
673 UINT32 AcxMemAddr,
674 TI_HANDLE hReport,
675 TI_HANDLE hMemMgr,
676 UINT32 *pFWImage,
677 TI_HANDLE hEventMbox
678 )
679 {
680 pHwCtrl->hReport = hReport;
681 pHwCtrl->hWhalCtrl = hWhalCtrl;
682 pHwCtrl->hEventMbox = hEventMbox;
683
684 /*
685 * NOTE: Save firmware image parameters before the 1st TNETWIF call.
686 * These parameters are passed from the user application and
687 * may be lost in a case TNETWIF call is asynchronous.
688 */
689 pHwCtrl->uFwBuf = pFWImage[0];
690 pHwCtrl->uFwAddr = pFWImage[1];
691 pHwCtrl->uEEEPROMBuf = pFWImage[2];
692 pHwCtrl->uEEEPROMLen = pFWImage[3];
693
694 return whalBus_Config (pHwCtrl->hWhalBus,
695 hWhalCtrl,
696 AccessMode,
697 AcxRegAddr,
698 AcxMemAddr,
699 hReport,
700 hMemMgr,
701 whal_hwCtrl_ConfigCb,
702 pHwCtrl);
703 }
704
705
706 /****************************************************************************
707 * whal_hwCtrl_FinalizeDownloadCb2()
708 ****************************************************************************
709 * DESCRIPTION: Finalize all the remaining initialization after the download has finished
710 *
711 * INPUTS:
712 *
713 * OUTPUT: None
714 *
715 * RETURNS: OK or NOK
716 ****************************************************************************/
whal_hwCtrl_FinalizeDownloadCb2(TI_HANDLE hHwCtrl,TI_STATUS status,void * pData)717 static void whal_hwCtrl_FinalizeDownloadCb2 (TI_HANDLE hHwCtrl, TI_STATUS status, void *pData)
718 {
719 HwCtrl_T *pHwCtrl = (HwCtrl_T *)hHwCtrl;
720 whalCtrl_antennaDiversityOptions_t antennaDiversityOptions;
721
722 /* Print firmware version */
723 whal_ParamsPrintFwVersion (pHwCtrl->pWhalParams);
724
725 /*
726 * Configure antenna diversity parameters, same for both radio types.
727 * (the only difference between DCR and WBR is the antennas number, which is
728 * hard-coded in the mbox config function per radio type
729 */
730 antennaDiversityOptions.enableRxDiversity = FALSE;
731 antennaDiversityOptions.rxSelectedAntenna = DIVS_RX_START_ANT2;
732 antennaDiversityOptions.enableTxDiversity = FALSE;
733 antennaDiversityOptions.txSelectedAntenna = DIVS_TX_START_ANT2;
734 antennaDiversityOptions.rxTxSharedAnts = TRUE;
735 whal_hwCtrl_SaveAntennaDiversityOptions (pHwCtrl, &antennaDiversityOptions);
736
737 whalCtrl_FinalizeDownload (pHwCtrl->hWhalCtrl);
738 }
739
740
741 /****************************************************************************
742 * whal_hwCtrl_FinalizeDownloadCb1()
743 ****************************************************************************
744 * DESCRIPTION: Finalize all the remaining initialization after the download has finished
745 *
746 * INPUTS:
747 *
748 * OUTPUT: None
749 *
750 * RETURNS: OK or NOK
751 ****************************************************************************/
whal_hwCtrl_FinalizeDownloadCb1(TI_HANDLE hHwCtrl,TI_STATUS status,void * pData)752 static void whal_hwCtrl_FinalizeDownloadCb1 (TI_HANDLE hHwCtrl, TI_STATUS status, void *pData)
753 {
754 HwCtrl_T *pHwCtrl = (HwCtrl_T *)hHwCtrl;
755 ACXRevision_t *pACXRevision = whal_ParamsGetAcxVersion (pHwCtrl->pWhalParams);
756 UINT8 *pStationId = ((dot11StationIDStruct*)pData)->dot11StationID;
757 UINT32 i;
758
759 /* Swap bytes of the station id */
760 for (i = 0; i < 3; i++)
761 {
762 UINT8 uTmp = pStationId[i];
763 pStationId[i] = pStationId[5 - i];
764 pStationId[5 - i] = uTmp;
765 }
766
767 whal_ParamsSetSrcMac (pHwCtrl->pWhalParams, (char*)pStationId);
768
769 /* Get firmware version */
770 whal_hwInfoElemAcxRevisionGet (pHwCtrl->pHwMboxConfig,
771 (void *)whal_hwCtrl_FinalizeDownloadCb2,
772 hHwCtrl,
773 pACXRevision);
774 }
775
776
777 /****************************************************************************
778 * whal_hwCtrl_FinalizeDownload()
779 ****************************************************************************
780 * DESCRIPTION: Finalize all the remaining initialization after the download has finished
781 *
782 * INPUTS:
783 *
784 * OUTPUT: None
785 *
786 * RETURNS: OK or NOK
787 ****************************************************************************/
whal_hwCtrl_FinalizeDownload(TI_HANDLE hHwCtrl,BootAttr_T * pBootAttr)788 TI_STATUS whal_hwCtrl_FinalizeDownload (TI_HANDLE hHwCtrl, BootAttr_T *pBootAttr)
789 {
790 HwCtrl_T *pHwCtrl= (HwCtrl_T *)hHwCtrl;
791
792 /*
793 * Just comment it since we may need it in future version when we will read from the NVS the
794 * Configure options (for example power levels)
795 */
796 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams (pHwCtrl->pWhalParams);
797
798 /* Read NVS version */
799 pWlanParams->radioType = pBootAttr->radioType;
800 pWlanParams->minorE2Ver = pBootAttr->minorE2Ver;
801 pWlanParams->majorE2Ver = pBootAttr->majorE2Ver;
802 pWlanParams->bugfixE2Ver = pBootAttr->bugfixE2Ver;
803
804 /*
805 * Read config options (WLAN hardware EEPROM). Must be before any configuration
806 * because the WLAN hardware put the data in the mbox after running the FW
807 * Not used by now but keep it in code since the data may be requested later on when the
808 * NVS data will be read from the driver and not from the INI:
809 * For example the number of power level
810 * whal_hwInfoElemConfigOptionsRead(pHwCtrl->pHwMboxConfig, pConfigOptions);
811 */
812 if (whal_hwInfoElemStationIdGet (pHwCtrl->pHwMboxConfig,
813 (void *)whal_hwCtrl_FinalizeDownloadCb1,
814 hHwCtrl,
815 &pHwCtrl->mbox) != OK)
816 {
817 WLAN_REPORT_ERROR (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
818 ("whal_hwCtrl_Config: Error on whal_hwInfoElemStationIdGet\n"));
819 /* For driver debug only, don't return error */
820 /* return NOK; */
821 }
822
823 return OK;
824 }
825
826
827 /****************************************************************************
828 * whal_hwCtrl_FinalizeOnFailure()
829 ****************************************************************************
830 * DESCRIPTION: Finalize all the initialization upon failure
831 *
832 * INPUTS:
833 *
834 * OUTPUT: None
835 *
836 * RETURNS: OK or NOK
837 ****************************************************************************/
whal_hwCtrl_FinalizeOnFailure(TI_HANDLE hHwCtrl)838 TI_STATUS whal_hwCtrl_FinalizeOnFailure (TI_HANDLE hHwCtrl)
839 {
840 HwCtrl_T *pHwCtrl= (HwCtrl_T *)hHwCtrl;
841
842 return whalCtrl_FinalizeOnFailure (pHwCtrl->hWhalCtrl);
843 }
844
845
846
847
848
849 typedef int (*fcallback_t) (TI_HANDLE, TI_STATUS);
850
851
852 /****************************************************************************
853 * whal_hwCtrl_ConfigHwCb2()
854 ****************************************************************************
855 * DESCRIPTION: Configure the WLAN hardware
856 *
857 * INPUTS: None
858 *
859 * OUTPUT: None
860 *
861 * RETURNS: OK or NOK
862 ****************************************************************************/
whal_hwCtrl_ConfigHwCb2(HwCtrl_T * pHwCtrl,TI_STATUS status,void * pData)863 static int whal_hwCtrl_ConfigHwCb2 (HwCtrl_T *pHwCtrl, TI_STATUS status, void *pData)
864 {
865 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams (pHwCtrl->pWhalParams);
866 UINT8 *pSrcMacAddr = whal_ParamsGetSrcMac (pHwCtrl->pWhalParams);
867 UINT32 acID;
868 whalCtrl_powerMgmtConfig_t powerMgmtConfig;
869
870 /* Arrived from callback */
871 if (pData)
872 {
873 ACXDataPathParamsResp_t *pCfg = &pHwCtrl->DataPathParams;
874
875 WLAN_REPORT_INIT (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
876 ("%s: rxPacketRingChunkSize = 0x%x,txPacketRingChunkSize = 0x%x,rxPacketRingAddr = 0x%x\n",
877 __FUNCTION__,pCfg->rxPacketRingChunkSize,pCfg->txPacketRingChunkSize,pCfg->rxPacketRingAddr));
878
879 WLAN_REPORT_INIT (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
880 ("(cont')%s: txPacketRingAddr = 0x%x,rxControlAddr = 0x%x,txControlAddr = 0x%x,txCompleteAddr = 0x%x\n",
881 __FUNCTION__,pCfg->txPacketRingAddr,pCfg->rxControlAddr,pCfg->txControlAddr,pCfg->txCompleteAddr));
882
883 pCfg->rxPacketRingChunkSize = ENDIAN_HANDLE_WORD(pCfg->rxPacketRingChunkSize);
884 pCfg->txPacketRingChunkSize = ENDIAN_HANDLE_WORD(pCfg->txPacketRingChunkSize);
885 pCfg->rxPacketRingAddr = ENDIAN_HANDLE_LONG(pCfg->rxPacketRingAddr);
886 pCfg->txPacketRingAddr = ENDIAN_HANDLE_LONG(pCfg->txPacketRingAddr);
887 pCfg->rxControlAddr = ENDIAN_HANDLE_LONG(pCfg->rxControlAddr);
888 pCfg->txControlAddr = ENDIAN_HANDLE_LONG(pCfg->txControlAddr);
889 pCfg->txCompleteAddr = ENDIAN_HANDLE_LONG(pCfg->txCompleteAddr);
890 }
891
892 /* Configure WEP maximum space */
893 WLAN_REPORT_INIT (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG, ("whal_hwCtrl_Configure: WEP cache - none\n"));
894
895 #ifdef CORE_5_0
896 whal_hwInfoElemMemoryMapPrint (pHwCtrl->pHwMboxConfig);
897 #endif
898
899 /* Override WLAN hardware defaults */
900 whal_hwInfoElemStationIdSet (pHwCtrl->pHwMboxConfig, pSrcMacAddr);
901 /* Configure the Rx Msdu Life Time (expiry time of de-fragmentation in FW) */
902 whal_hwInfoElemRxMsduLifeTimeSet (pHwCtrl->pHwMboxConfig, pWlanParams->MaxRxMsduLifetime);
903 whal_hwInfoElemRxConfigSet (pHwCtrl->pHwMboxConfig, &pWlanParams->RxConfigOption, &pWlanParams->RxFilterOption);
904
905 #if 0
906 /* Use firmware default parameters for ant. which is ant 2 for both TX and RX */
907 whal_hwCtrl_CurrentAntennaDiversitySendCmd (pHwCtrl);
908 #endif
909
910 for (acID = 0; acID < MAX_NUM_OF_AC; acID++)
911 {
912 whal_hwCtrl_QueueConf (pHwCtrl, &pWlanParams->acQueuesParams[acID]);
913
914 /*
915 * NOTE: Set following parameters only if they were configured.
916 * Otherwise, they contain garbage.
917 */
918
919 if (pHwCtrl->pWhalParams->AcParams.isAcConfigured[acID])
920 {
921 configureCmdCBParams_t configureCmdAc = {NULL,NULL,NULL};
922
923 configureCmdAc.CB_buf = (UINT8*)&pHwCtrl->pWhalParams->AcParams.ac[acID];
924 whal_hwCtrl_AcParamsConf (pHwCtrl, &configureCmdAc);
925 }
926
927 if (pHwCtrl->pWhalParams->QueuesParams.isQueueConfigured[acID])
928 {
929 whal_hwCtrl_TrafficConf (pHwCtrl, &pHwCtrl->pWhalParams->QueuesParams.queues[acID]);
930 }
931 }
932
933 whal_hwCtrl_PacketDetectionThreshold (pHwCtrl, &pHwCtrl->pWhalParams->WlanParams.PacketDetectionThreshold);
934 whal_hwCtrl_SetSlotTime (pHwCtrl, (slotTime_e )pWlanParams->SlotTime);
935 whal_hwCtrl_SetarpIpAddressesTable (pHwCtrl,
936 &pWlanParams->arp_IP_addr,
937 pWlanParams->isArpIpFilteringEnabled,
938 IP_VER_4);
939 whal_hwCtrl_SetGroupAddressesTable (pHwCtrl,
940 pWlanParams->numGroupAddrs,
941 pWlanParams->Group_addr,
942 pWlanParams->isMacAddrFilteringnabled);
943 whal_hwInfoElemRxTimeOutSet (pHwCtrl->pHwMboxConfig, &pWlanParams->rxTimeOut);
944 whal_hwCtrl_SetRtsThreshold (pHwCtrl, pWlanParams->RtsThreshold);
945
946 /* Set The Beacon Filter in HAL */
947 whal_hwCtrl_SetBeaconFiltering (pHwCtrl,
948 pWlanParams->beaconFilterParams.desiredState,
949 pWlanParams->beaconFilterParams.numOfElements);
950 whal_hwCtrl_SetBeaconFilterIETable (pHwCtrl,
951 &pWlanParams->beaconFilterIETable.numberOfIEs,
952 pWlanParams->beaconFilterIETable.IETable,
953 &pWlanParams->beaconFilterIETable.IETableSize);
954
955 /* Set SG Params only in Init Phase. */
956 /* In recovery it will be handled in SoftGemini_hanfleRecovery() */
957 if (pData)
958 {
959 WLAN_REPORT_INIT (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG, ("whal_hwCtrl_Configure: Setting the Soft Gemini state\n"));
960
961 /* Set the Soft Gemini state */
962 if (pWlanParams->SoftGeminiEnable == SG_SENSE_ACTIVE)
963 {
964 whal_hwCtrl_SoftGeminiEnable (pHwCtrl, SG_SENSE_NO_ACTIVITY);
965 }
966 else
967 {
968 whal_hwCtrl_SoftGeminiEnable (pHwCtrl, pWlanParams->SoftGeminiEnable);
969 }
970
971 /* Set the Soft Gemini params */
972 whal_hwCtrl_SetSoftGeminiParams (pHwCtrl, &pWlanParams->SoftGeminiParams);
973 }
974
975 /* For recovery decision */
976 eventMbox_EvUnMask (pHwCtrl->hEventMbox, HAL_EVENT_HEALTH_REPORT);
977 whal_hwCtrl_OverridePhyRegsDefaults (pHwCtrl);
978 #ifdef TNETW1150
979 whal_hwCtrl_SetACIConfiguration (pHwCtrl,
980 pWlanParams->ACIMode,
981 pWlanParams->inputCCA,
982 pWlanParams->qualifiedCCA,
983 pWlanParams->stompForRx,
984 pWlanParams->stompForTx,
985 pWlanParams->txCCA);
986 #endif/*TNETW1150*/
987
988 /* Beacon broadcast options */
989 powerMgmtConfig.BcnBrcOptions = pWlanParams->BcnBrcOptions;
990 powerMgmtConfig.ConsecutivePsPollDeliveryFailureThreshold = pWlanParams->ConsecutivePsPollDeliveryFailureThreshold;
991 whal_hwCtrl_BcnBrcOptions (pHwCtrl, &powerMgmtConfig);
992
993 /* Enable rx/tx path on the hardware */
994 if (whal_hwCtrl_EnableDataPath (pHwCtrl) != OK)
995 return NOK;
996
997 /* ACX for a work around for Wi-Fi test */
998 whal_hwInfoElemWiFiWmmPSWASet (pHwCtrl->pHwMboxConfig, pWlanParams->WiFiWmmPS);
999
1000 /* Enable the scan complete interrupt source */
1001 eventMbox_EvUnMask (pHwCtrl->hEventMbox, HAL_EVENT_SCAN_CMPLT);
1002 eventMbox_EvUnMask (pHwCtrl->hEventMbox, HAL_EVENT_SPS_SCAN_CMPLT);
1003
1004 /* Call the upper layer callback */
1005 return (*((fcallback_t)pHwCtrl->fCb)) (pHwCtrl->hCb, OK);
1006 }
1007
1008
1009 /****************************************************************************
1010 * whal_hwCtrl_ConfigHwCb1()
1011 ****************************************************************************
1012 * DESCRIPTION: Configure the WLAN hardware
1013 *
1014 * INPUTS: None
1015 *
1016 * OUTPUT: None
1017 *
1018 * RETURNS: OK or NOK
1019 ****************************************************************************/
whal_hwCtrl_ConfigHwCb1(HwCtrl_T * pHwCtrl,TI_STATUS status,void * pData)1020 static int whal_hwCtrl_ConfigHwCb1 (HwCtrl_T *pHwCtrl, TI_STATUS status, void *pData)
1021 {
1022 MemoryMap_t *pMemMap = &pHwCtrl->MemMap;
1023 DmaParams_T *pDmaParams = whal_ParamsGetDmaParams (pHwCtrl->pWhalParams);
1024 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams (pHwCtrl->pWhalParams);
1025
1026 /* Arrived from callback */
1027 if (pData)
1028 {
1029 UINT32 *pSwap, i;
1030
1031 /* Solve endian problem (all fields are 32 bit) */
1032 pSwap = (UINT32* )&(pMemMap->codeStart);
1033 for (i = 0; i < MEM_MAP_NUM_FIELDS; i++)
1034 pSwap[i] = ENDIAN_HANDLE_LONG(pSwap[i]);
1035 }
1036
1037 /* Save number of TX blocks */
1038 pDmaParams->NumTxBlocks = pMemMap->numTxMemBlks;
1039
1040 /*
1041 * Configure DataPath parameters to default
1042 * values and Read the Addresses of the FW data path buffers
1043 */
1044
1045 /* Set Data path parameters to constant value to emulate the original double buffer*/
1046 whal_hwInfoElemDataPathParamsSet (pHwCtrl->pHwMboxConfig,
1047 DP_RX_PACKET_RING_CHUNK_SIZE,
1048 DP_TX_PACKET_RING_CHUNK_SIZE,
1049 DP_RX_PACKET_RING_CHUNK_NUM,
1050 DP_TX_PACKET_RING_CHUNK_NUM,
1051 pWlanParams->TxCompleteThreshold,
1052 FW_TX_CMPLT_BLOCK_SIZE,
1053 DP_TX_COMPLETE_TIME_OUT);
1054
1055 /* Arrived from callback */
1056 if (pData)
1057 {
1058 /* Get the double buffers and registers address values */
1059 return whal_hwInfoElemDataPathParamsGet (pHwCtrl->pHwMboxConfig,
1060 &pHwCtrl->DataPathParams,
1061 (void *)whal_hwCtrl_ConfigHwCb2,
1062 pHwCtrl);
1063 }
1064
1065 /* Called directly */
1066 else
1067 {
1068 return whal_hwCtrl_ConfigHwCb2 (pHwCtrl, OK, NULL);
1069 }
1070 }
1071
1072
1073 /****************************************************************************
1074 * whal_hwCtrl_ConfigHw()
1075 ****************************************************************************
1076 * DESCRIPTION: Configure the WLAN hardware
1077 *
1078 * INPUTS: None
1079 *
1080 * OUTPUT: None
1081 *
1082 * RETURNS: OK or NOK
1083 ****************************************************************************/
whal_hwCtrl_ConfigHw(HwCtrl_T * pHwCtrl,void * fCb,TI_HANDLE hCb,BOOL bRecovery)1084 int whal_hwCtrl_ConfigHw (HwCtrl_T *pHwCtrl, void *fCb, TI_HANDLE hCb, BOOL bRecovery)
1085 {
1086 MemoryMap_t *pMemMap = &pHwCtrl->MemMap;
1087
1088 /*
1089 * The addresses of the Double buffer, The Tx Path Status,
1090 * Rx Path Status, Tx Path Control, Rx Path Control
1091 */
1092 /* ACXDataPathParamsResp_t *DataPathParam = &pHwCtrl->DataPathParams; */
1093
1094 /*
1095 * The DmaParams_T is the same struct as the halTxRxQueueGlobalsParams_t struct
1096 * but is defined in the whalBus_Defs.h and not in the paramOut.h as done by BCIL
1097 */
1098 DmaParams_T *pDmaParams = whal_ParamsGetDmaParams (pHwCtrl->pWhalParams);
1099
1100 pHwCtrl->fCb = fCb;
1101 pHwCtrl->hCb = hCb;
1102
1103 /* Configure the WLAN hardware memory (WEP, Templates, Queue, Buffers) */
1104
1105 /* Configure packet templates */
1106 WLAN_REPORT_INIT (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG, ("whal_hwCtrl_Configure: templates \n"));
1107 whal_hwCtrl_ConfigTemplates (pHwCtrl);
1108
1109 /* Configure RX/TX queues */
1110 WLAN_REPORT_INIT (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG, ("whal_hwCtrl_Configure: queues\n"));
1111
1112 /* Configure the weight among the different hardware queues */
1113 whal_hwInfoElemConfigMemorySet (pHwCtrl->pHwMboxConfig, pDmaParams);
1114
1115 /* Extract total number of blocks in the pool */
1116 if (bRecovery)
1117 return whal_hwCtrl_ConfigHwCb1 (pHwCtrl, OK, NULL);
1118 else
1119 return whal_hwInfoElemMemoryMapGet (pHwCtrl->pHwMboxConfig,
1120 pMemMap,
1121 (void *)whal_hwCtrl_ConfigHwCb1,
1122 pHwCtrl);
1123 }
1124
1125
1126 #ifdef TNETW1150
1127 /****************************************************************************
1128 * whal_hwCtrl_SetACIConfiguration()
1129 ****************************************************************************
1130 * DESCRIPTION: Set the hardware ACI configuration
1131 *
1132 * INPUTS: None
1133 *
1134 * OUTPUT: None
1135 *
1136 * RETURNS: OK or NOK
1137 ****************************************************************************/
whal_hwCtrl_SetACIConfiguration(HwCtrl_T * pHwCtrl,UINT8 ACIMode,UINT8 inputCCA,UINT8 qualifiedCCA,UINT8 stompForRx,UINT8 stompForTx,UINT8 txCCA)1138 int whal_hwCtrl_SetACIConfiguration (HwCtrl_T *pHwCtrl, UINT8 ACIMode,
1139 UINT8 inputCCA, UINT8 qualifiedCCA,
1140 UINT8 stompForRx, UINT8 stompForTx,
1141 UINT8 txCCA)
1142 {
1143 return (whal_hwInfoElemACIConfigurationSet (pHwCtrl->pHwMboxConfig, ACIMode,
1144 inputCCA, qualifiedCCA, stompForRx,
1145 stompForTx, txCCA));
1146 }
1147 #endif/*TNETW1150*/
1148
1149 /****************************************************************************
1150 * whal_hwCtrl_SetMacAddress()
1151 ****************************************************************************
1152 * DESCRIPTION:
1153 *
1154 * INPUTS: None
1155 *
1156 * OUTPUT: None
1157 *
1158 * RETURNS: OK or NOK
1159 ****************************************************************************/
whal_hwCtrl_SetMacAddress(HwCtrl_T * pHwCtrl,macAddress_t * macAddr)1160 int whal_hwCtrl_SetMacAddress(HwCtrl_T *pHwCtrl, macAddress_t *macAddr)
1161 {
1162 whal_ParamsSetSrcMac(pHwCtrl->pWhalParams, (char*)macAddr->addr);
1163
1164 return whal_hwInfoElemStationIdSet (pHwCtrl->pHwMboxConfig, (UINT8*)macAddr->addr);
1165 }
1166
1167
1168 /****************************************************************************
1169 * whal_hwCtrl_ConfigTemplates()
1170 ****************************************************************************
1171 * DESCRIPTION: Configure the packet templates
1172 *
1173 * AP - beacon, probe response, tim
1174 * STA (INFRA) - probe request
1175 * STA (IBSS) - beacon, probe response, probe request
1176 * know yet the bss type
1177 *
1178 * INPUTS:
1179 *
1180 * OUTPUT: None
1181 *
1182 * RETURNS: OK or NOK
1183 ****************************************************************************/
whal_hwCtrl_ConfigTemplates(HwCtrl_T * pHwCtrl)1184 int whal_hwCtrl_ConfigTemplates(HwCtrl_T *pHwCtrl)
1185 {
1186 UINT8 PartialVirtualBmap[DOT11_PARTIAL_VIRTUAL_BITMAP_MAX];
1187 UINT8 BmapControl;
1188 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams(pHwCtrl->pWhalParams);
1189
1190 /*
1191 * Probe request template
1192 */
1193 whal_hwMboxCmd_ConfigureTemplateFrame(pHwCtrl->pHwMboxCmd, NULL, pWlanParams->probeRequestTemplateSize,
1194 CMD_PROBE_REQ,NULL,NULL);
1195
1196 /*
1197 * Null Data template
1198 */
1199 whal_hwMboxCmd_ConfigureTemplateFrame(pHwCtrl->pHwMboxCmd, NULL, pWlanParams->nullTemplateSize,
1200 CMD_NULL_DATA,NULL,NULL);
1201
1202 /*
1203 * Ps Poll template
1204 */
1205 whal_hwMboxCmd_ConfigureTemplateFrame(pHwCtrl->pHwMboxCmd, NULL, pWlanParams->PsPollTemplateSize,
1206 CMD_PS_POLL,NULL,NULL);
1207
1208 /*
1209 * Qos Null Data template
1210 */
1211 whal_hwMboxCmd_ConfigureTemplateFrame(pHwCtrl->pHwMboxCmd, NULL, pWlanParams->qosNullDataTemplateSize,
1212 CMD_QOS_NULL_DATA,NULL,NULL);
1213
1214 /*
1215 * Probe response template
1216 */
1217 whal_hwMboxCmd_ConfigureTemplateFrame(pHwCtrl->pHwMboxCmd, NULL, pWlanParams->probeResponseTemplateSize,
1218 CMD_PROBE_RESP,NULL,NULL);
1219 /*
1220 * Beacon template
1221 */
1222 whal_hwMboxCmd_ConfigureTemplateFrame(pHwCtrl->pHwMboxCmd, NULL, pWlanParams->beaconTemplateSize,
1223 CMD_BEACON,NULL,NULL);
1224
1225 /*
1226 * Tim template, first reserve space (len=MAX), second init to empty
1227 */
1228 BmapControl = 0;
1229 os_memoryZero(pHwCtrl->hOs, (void*)PartialVirtualBmap, DOT11_PARTIAL_VIRTUAL_BITMAP_MAX);
1230 whal_hwMboxCmd_TimTemplate(pHwCtrl->pHwMboxCmd, BmapControl, (char*)PartialVirtualBmap, DOT11_PARTIAL_VIRTUAL_BITMAP_MAX);
1231 whal_hwMboxCmd_TimTemplate(pHwCtrl->pHwMboxCmd, BmapControl, (char*)PartialVirtualBmap, 1);
1232
1233 return OK;
1234 }
1235
1236
1237 /****************************************************************************
1238 * whal_hwCtrl_SetSlotTime()
1239 ****************************************************************************
1240 * DESCRIPTION: Set the Slot field in ACM_IFS_CFG1 hardware register
1241 *
1242 * INPUTS:
1243 * SlotTimeVal The Short SlotTime bit value in the Capabilities
1244 *
1245 * OUTPUT: None
1246 *
1247 * RETURNS: None
1248 ****************************************************************************/
whal_hwCtrl_SetSlotTime(HwCtrl_T * pHwCtrl,slotTime_e SlotTimeVal)1249 int whal_hwCtrl_SetSlotTime(HwCtrl_T *pHwCtrl, slotTime_e SlotTimeVal)
1250 {
1251 UINT8 slotTime;
1252
1253 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,(" whal_hwCtrl_SetSlotTime: SlotTimeVal = 0x%x\n",SlotTimeVal));
1254
1255 if (SlotTimeVal == SLOT_TIME_LONG)
1256 slotTime = (UINT8) SLOT_TIME_LONG;
1257 else
1258 slotTime = (UINT8) SLOT_TIME_SHORT;
1259
1260 return whal_hwInfoElemSlotTimeSet (pHwCtrl->pHwMboxConfig, &slotTime);
1261
1262 }
1263
1264
1265 /****************************************************************************
1266 * whal_hwCtrl_SetPreamble()
1267 ****************************************************************************
1268 * DESCRIPTION: Set the preamble in ?????? hardware register
1269 *
1270 * INPUTS:
1271 * preambleVal
1272 *
1273 * OUTPUT: None
1274 *
1275 * RETURNS: None
1276 ****************************************************************************/
whal_hwCtrl_SetPreamble(HwCtrl_T * pHwCtrl,Preamble_e preambleVal)1277 int whal_hwCtrl_SetPreamble(HwCtrl_T *pHwCtrl, Preamble_e preambleVal)
1278 {
1279 UINT8 preamble;
1280
1281 preamble = (UINT8)preambleVal;
1282
1283 return whal_hwInfoElemPreambleSet (pHwCtrl->pHwMboxConfig, &preamble);
1284 }
1285
1286 /****************************************************************************
1287 * whal_hwCtrl_SetFrameRate()
1288 ****************************************************************************
1289 * DESCRIPTION: Set the Frame Rate to HW
1290 *
1291 * INPUTS:
1292 * Rate_e txCtrlFrmRate;
1293 * Mod_e txCtrlFrmMod;
1294 * Rate_e txMgmtFrmRate;
1295 * Mod_e txMgmtFrmMod;
1296 *
1297 * OUTPUT: None
1298 *
1299 * RETURNS: None
1300 ****************************************************************************/
whal_hwCtrl_SetFrameRate(HwCtrl_T * pHwCtrl,UINT8 txCtrlFrmRateVal,UINT8 txCtrlFrmModVal,UINT8 txMgmtFrmRateVal,UINT8 txMgmtFrmModVal)1301 int whal_hwCtrl_SetFrameRate (HwCtrl_T *pHwCtrl,
1302 UINT8 txCtrlFrmRateVal,
1303 UINT8 txCtrlFrmModVal,
1304 UINT8 txMgmtFrmRateVal,
1305 UINT8 txMgmtFrmModVal)
1306 {
1307 UINT8 txCtrlFrmRate;
1308 UINT8 txCtrlFrmMod;
1309 UINT8 txMgmtFrmRate;
1310 UINT8 txMgmtFrmMod;
1311
1312 txCtrlFrmRate = txCtrlFrmRateVal;
1313 txCtrlFrmMod = txCtrlFrmModVal;
1314 txMgmtFrmRate = txMgmtFrmRateVal;
1315 txMgmtFrmMod = txMgmtFrmModVal;
1316
1317
1318 return whal_hwInfoElemGeneratedFrameRateSet (pHwCtrl->pHwMboxConfig,
1319 &txCtrlFrmRate,
1320 &txCtrlFrmMod,
1321 &txMgmtFrmRate,
1322 &txMgmtFrmMod);
1323
1324 }
1325
1326 /****************************************************************************
1327 * whal_hwCtrl_PMConfig()
1328 ****************************************************************************
1329 * DESCRIPTION: Configure the wlan hardware
1330 *
1331 * INPUTS: None
1332 *
1333 * OUTPUT: None
1334 *
1335 * RETURNS: OK or NOK
1336 ****************************************************************************/
whal_hwCtrl_PMConfig(HwCtrl_T * pHwCtrl,whalCtrl_powerMgmtConfig_t * pPMConfig)1337 int whal_hwCtrl_PMConfig(HwCtrl_T *pHwCtrl, whalCtrl_powerMgmtConfig_t *pPMConfig)
1338 {
1339
1340 ACXConfigPM_t AcxElm_PMConfig;
1341 ACXConfigPM_t *pCfg = &AcxElm_PMConfig;
1342
1343
1344 pCfg->BBWakeUpTime = pPMConfig->BBWakeUpTime;
1345
1346 pCfg->ELPEnable = pPMConfig->ELPEnable;
1347
1348 pCfg->PLLlockTime = pPMConfig->PLLlockTime;
1349
1350 WLAN_REPORT_INFORMATION(pHwCtrl->hReport,
1351 HAL_HW_CTRL_MODULE_LOG,
1352 (" whal_hwCtrl_PMConfig BBWakeUpTime=%d ELPEnable=%d PLLlockTime=%d WakeOnGPIOenable=0x%x\n"
1353 ,pCfg->BBWakeUpTime,pCfg->ELPEnable,pCfg->PLLlockTime,pCfg->WakeOnGPIOenable));
1354
1355 /*
1356 * Set the desired features
1357 */
1358 return whal_hwInfoElemAcxPMConfigSet (pHwCtrl->pHwMboxConfig, pCfg);
1359 }
1360
1361 /****************************************************************************
1362 * whal_hwCtrl_BcnBrcOptions()
1363 ****************************************************************************
1364 * DESCRIPTION: Configure the wlan hardware
1365 *
1366 * INPUTS: None
1367 *
1368 * OUTPUT: None
1369 *
1370 * RETURNS: OK or NOK
1371 ****************************************************************************/
whal_hwCtrl_BcnBrcOptions(HwCtrl_T * pHwCtrl,whalCtrl_powerMgmtConfig_t * pPMConfig)1372 int whal_hwCtrl_BcnBrcOptions(HwCtrl_T *pHwCtrl, whalCtrl_powerMgmtConfig_t *pPMConfig)
1373 {
1374 ACXBeaconAndBroadcastOptions_t AcxElm_BcnBrcOptions;
1375 ACXBeaconAndBroadcastOptions_t *pCfg = &AcxElm_BcnBrcOptions;
1376
1377
1378 pCfg->beaconRxTimeOut = pPMConfig->BcnBrcOptions.BeaconRxTimeout;
1379
1380 pCfg->broadcastTimeOut = pPMConfig->BcnBrcOptions.BroadcastRxTimeout;
1381
1382 pCfg->rxBroadcastInPS = pPMConfig->BcnBrcOptions.RxBroadcastInPs;
1383
1384 pCfg->consecutivePsPollDeliveryFailureThr = pPMConfig->ConsecutivePsPollDeliveryFailureThreshold;
1385
1386 WLAN_REPORT_INFORMATION(pHwCtrl->hReport,
1387 HAL_HW_CTRL_MODULE_LOG,
1388 (" whal_hwCtrl_BcnBrcOptions BeaconRxTimeout=%d BroadcastRxTimeout=%d RxBroadcastInPs=0x%x ConsecutivePsPoll = %d\n"
1389 ,pCfg->beaconRxTimeOut,pCfg->broadcastTimeOut,pCfg->rxBroadcastInPS,pCfg->consecutivePsPollDeliveryFailureThr));
1390 /*
1391 * Set the desired features
1392 */
1393 return whal_hwInfoElemAcxBcnBrcOptionsSet (pHwCtrl->pHwMboxConfig, pCfg);
1394 }
1395
1396 /****************************************************************************
1397 * whal_hwCtrl_wakeUpCondition()
1398 ****************************************************************************
1399 * DESCRIPTION: Configure the wlan hardware
1400 *
1401 * INPUTS: None
1402 *
1403 * OUTPUT: None
1404 *
1405 * RETURNS: OK or NOK
1406 ****************************************************************************/
whal_hwCtrl_wakeUpCondition(HwCtrl_T * pHwCtrl,whalCtrl_powerMgmtConfig_t * pPMConfig)1407 int whal_hwCtrl_wakeUpCondition(HwCtrl_T *pHwCtrl, whalCtrl_powerMgmtConfig_t *pPMConfig)
1408 {
1409 WakeUpCondition_t AcxElm_WakeUpCondition;
1410 WakeUpCondition_t *pCfg = &AcxElm_WakeUpCondition;
1411
1412
1413 switch (pPMConfig->tnetWakeupOn)
1414 {
1415 case TNET_WAKE_ON_BEACON:
1416 pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_BEACON_BITMAP;
1417 break;
1418 case TNET_WAKE_ON_DTIM:
1419 pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_DTIM_BITMAP;
1420 break;
1421 case TNET_WAKE_ON_N_BEACON:
1422 pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_N_BEACONS_BITMAP;
1423 break;
1424 case TNET_WAKE_ON_N_DTIM:
1425 pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_N_DTIM_BITMAP;
1426 break;
1427 default:
1428 pCfg->wakeUpConditionBitmap = WAKE_UP_EVENT_BEACON_BITMAP;
1429 break;
1430 }
1431
1432 pCfg->listenInterval = pPMConfig->listenInterval;
1433
1434 WLAN_REPORT_INFORMATION(pHwCtrl->hReport,
1435 HAL_HW_CTRL_MODULE_LOG,
1436 (" whal_hwCtrl_wakeUpCondition tnetWakeupOn=0x%x listenInterval=%d\n",pCfg->wakeUpConditionBitmap,pCfg->listenInterval));
1437 /*
1438 * Set the desired features
1439 */
1440 return whal_hwInfoElemAcxwakeUpConditionSet (pHwCtrl->pHwMboxConfig, pCfg);
1441 }
1442
1443 /****************************************************************************
1444 * whal_hwCtrl_PowerMgmtConfigurationSet ()
1445 ****************************************************************************
1446 * DESCRIPTION: Set the ACX power management option IE
1447 *
1448 * INPUTS: whalHwCtrl_powerMgmtOptionsConfig
1449 *
1450 * OUTPUT:
1451 *
1452 * RETURNS: OK or NOK
1453 ****************************************************************************/
whal_hwCtrl_PowerMgmtConfigurationSet(HwCtrl_T * pHwCtrl,whalCtrl_powerSaveParams_t * powerSaveParams)1454 int whal_hwCtrl_PowerMgmtConfigurationSet (HwCtrl_T *pHwCtrl,
1455 whalCtrl_powerSaveParams_t* powerSaveParams)
1456
1457 /*whalCtrl_powerMgmtConfig_t *thePowerMgmtOptionsConfig)*/
1458 {
1459 whalCtrl_powerSaveParams_t AcxElm_PowerMgmtConfiguration;
1460 whalCtrl_powerSaveParams_t *pCfg = &AcxElm_PowerMgmtConfiguration;
1461
1462
1463 pCfg->ps802_11Enable = powerSaveParams->ps802_11Enable;
1464 pCfg->hangOverPeriod = powerSaveParams->hangOverPeriod;
1465 pCfg->needToSendNullData = powerSaveParams->needToSendNullData;
1466 pCfg->numNullPktRetries = powerSaveParams->numNullPktRetries;
1467 pCfg->powerSaveCBObject = powerSaveParams->powerSaveCBObject;
1468 pCfg->powerSavecmdResponseCB = powerSaveParams->powerSavecmdResponseCB;
1469 /* Rate conversion is done in the HAL */
1470 whalUtils_ConvertAppRatesBitmap(powerSaveParams->NullPktRateModulation, 0, &(pCfg->NullPktRateModulation));
1471
1472
1473 WLAN_REPORT_INFORMATION(pHwCtrl->hReport,
1474 HAL_HW_CTRL_MODULE_LOG,
1475 (" whal_hwCtrl_PowerMgmtConfigurationSet ps802_11Enable=0x%x hangOverPeriod=%d needToSendNullData=0x%x numNullPktRetries=%d NullPktRateModulation=0x%x\n"
1476 ,pCfg->ps802_11Enable,pCfg->hangOverPeriod,pCfg->needToSendNullData,pCfg->numNullPktRetries,pCfg->NullPktRateModulation));
1477
1478 return(whal_hwMboxCmd_PowerMgmtConfiguration (pHwCtrl->pHwMboxCmd,pCfg));
1479 }
1480
1481
1482 /****************************************************************************
1483 * whal_hwCtrl_MinPowerLevelSet ()
1484 ****************************************************************************
1485 * DESCRIPTION: Set the min power level
1486 *
1487 * INPUTS:
1488 *
1489 * OUTPUT:
1490 *
1491 * RETURNS: OK or NOK
1492 ****************************************************************************/
whal_hwCtrl_MinPowerLevelSet(HwCtrl_T * pHwCtrl,powerAutho_PowerPolicy_e minPowerLevel)1493 int whal_hwCtrl_MinPowerLevelSet (HwCtrl_T *pHwCtrl,
1494 powerAutho_PowerPolicy_e minPowerLevel)
1495 {
1496 ACXSleepAuth_t AcxElm_SleepAuth;
1497 ACXSleepAuth_t *pCfg = &AcxElm_SleepAuth;
1498
1499 /* in the info element the enums are in reverse */
1500 switch(minPowerLevel)
1501 {
1502 case POWERAUTHO_POLICY_ELP:
1503 pCfg->sleepAuth = 2;
1504 break;
1505 case POWERAUTHO_POLICY_AWAKE:
1506 pCfg->sleepAuth = 0;
1507 break;
1508 default:
1509 pCfg->sleepAuth = minPowerLevel;
1510 }
1511
1512 WLAN_REPORT_INFORMATION(pHwCtrl->hReport,
1513 HAL_HW_CTRL_MODULE_LOG,
1514 (" whal_hwCtrl_MinPowerLevelSet sleepAuth=%d\n",
1515 minPowerLevel));
1516
1517 /*
1518 * Set the desired min power level
1519 */
1520 return whal_hwInfoElemAcxSleepAuthoSet (pHwCtrl->pHwMboxConfig, pCfg);
1521 }
1522
1523
1524 /****************************************************************************
1525 * whal_hwCtrl_PowerMgmtOptionsPrint ()
1526 ****************************************************************************
1527 * DESCRIPTION: Print the ACX power management option
1528 *
1529 * INPUTS:
1530 *
1531 * OUTPUT:
1532 *
1533 * RETURNS: OK or NOK
1534 ****************************************************************************/
whal_hwCtrl_PowerMgmtOptionsPrint(HwCtrl_T * pHwCtrl)1535 int whal_hwCtrl_PowerMgmtOptionsPrint (HwCtrl_T *pHwCtrl)
1536 {
1537 int Stt1, Stt2;
1538
1539 ACXBeaconAndBroadcastOptions_t AcxElm_BcnBrcOptions;
1540 ACXBeaconAndBroadcastOptions_t *pCfgBcnBrcOptions = &AcxElm_BcnBrcOptions;
1541
1542 ACXDtimPeriodCfg_t AcxElm_TbttAndDtim;
1543 ACXDtimPeriodCfg_t *pCfgTbttAndDtim = &AcxElm_TbttAndDtim;
1544
1545 Stt1 = whal_hwInfoElemAcxBcnBrcOptionsGet (pHwCtrl->pHwMboxConfig, pCfgBcnBrcOptions);
1546
1547 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1548 ("BeaconRxTimeout=0x%X\n", pCfgBcnBrcOptions->beaconRxTimeOut));
1549
1550 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1551 ("BroadcastRxTimeout=0x%X\n", pCfgBcnBrcOptions->broadcastTimeOut));
1552
1553 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1554 ("RxBroadcastInPs=0x%X\n", pCfgBcnBrcOptions->rxBroadcastInPS));
1555
1556
1557 Stt2 = whal_hwInfoElemDtimPeriodGet (pHwCtrl->pHwMboxConfig,
1558 &(pCfgTbttAndDtim->dtimInterval),
1559 &(pCfgTbttAndDtim->tbtt));
1560
1561 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1562 ("Time Between Beacon(TBTT)=NOT IMPLEMENTED\n"));
1563
1564 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1565 ("dtimPeriod=NOT IMPLEMENTED\n"));
1566
1567 if ((Stt1 == OK) && (Stt2 == OK))
1568 return(OK);
1569 else
1570 return(NOK);
1571 }
1572
1573 /****************************************************************************
1574 * whal_hwCtrl_SetFeatureOptions()
1575 ****************************************************************************
1576 * DESCRIPTION: Configure the wlan hardware
1577 *
1578 * INPUTS: None
1579 *
1580 * OUTPUT: None
1581 *
1582 * RETURNS: OK or NOK
1583 ****************************************************************************/
whal_hwCtrl_SetEnergyDetection(HwCtrl_T * pHwCtrl,BOOL energyDetection)1584 int whal_hwCtrl_SetEnergyDetection(HwCtrl_T *pHwCtrl, BOOL energyDetection)
1585 {
1586 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams(pHwCtrl->pWhalParams);
1587 UINT16 ccaThreshold = 0xefff;
1588
1589 pWlanParams->RxEnergyDetection = energyDetection;
1590
1591 if (energyDetection)
1592 ccaThreshold = ACX_PHI_CCA_THRSH_ENABLE_ENERGY_D; /* enable energy detect */
1593 else
1594 ccaThreshold = ACX_PHI_CCA_THRSH_DISABLE_ENERGY_D; /* disable energy detect */
1595
1596 whal_hwInfoElemCcaThresholdSet (pHwCtrl->pHwMboxConfig, &ccaThreshold, pWlanParams->TxEnergyDetection);
1597
1598 return OK;
1599 }
1600
1601
1602 #if defined(TNETW1150)
1603 /****************************************************************************
1604 * whal_hwCtrl_ArmClockSet()
1605 ****************************************************************************
1606 * DESCRIPTION: Configure the arm clock
1607 * !!! Note that the firmware will set the slot time according to the new clock
1608 *
1609 * INPUTS: None
1610 *
1611 * OUTPUT: None
1612 *
1613 * RETURNS: OK or NOK
1614 ****************************************************************************/
whal_hwCtrl_ArmClockSet(HwCtrl_T * pHwCtrl,UINT32 ArmClock)1615 int whal_hwCtrl_ArmClockSet (HwCtrl_T *pHwCtrl, UINT32 ArmClock)
1616 {
1617 WlanParams_T *pWlanParams = &pHwCtrl->pWhalParams->WlanParams;
1618
1619 pWlanParams->ArmClock = ArmClock;
1620
1621 WLAN_REPORT_REPLY(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1622 ("whal_hwCtrl_ArmClockSet: Arm=%d (Mac=%d)\n", pWlanParams->ArmClock, pWlanParams->MacClock));
1623
1624 /* Illegal combination Mac=80, Arm=40 ==> force setting 40/40*/
1625 if ((pWlanParams->MacClock == HW_CLOCK_80_MHZ) && (pWlanParams->ArmClock == HW_CLOCK_40_MHZ))
1626 {
1627 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1628 ("whal_hwCtrl_ArmClockSet: ---------- Illegal combination Mac=80, Arm=40 ==> force setting 40/40\n"));
1629 pWlanParams->MacClock = HW_CLOCK_40_MHZ;
1630 }
1631
1632 return whal_hwInfoElemFeatureConfigSet (pHwCtrl->pHwMboxConfig, pWlanParams->FeatureOptions, pWlanParams->FeatureDataFlowOptions);
1633 }
1634 #endif
1635
1636 /****************************************************************************
1637 * whal_hwCtrl_MacClockSet()
1638 ****************************************************************************
1639 * DESCRIPTION: Configure the mac clock
1640 * !!! Note that the firmware will set the slot time according to the new clock
1641 *
1642 * INPUTS: None
1643 *
1644 * OUTPUT: None
1645 *
1646 * RETURNS: OK or NOK
1647 ****************************************************************************/
whal_hwCtrl_MacClockSet(HwCtrl_T * pHwCtrl,UINT32 MacClock)1648 int whal_hwCtrl_MacClockSet (HwCtrl_T *pHwCtrl, UINT32 MacClock)
1649 {
1650 WlanParams_T *pWlanParams = &pHwCtrl->pWhalParams->WlanParams;
1651
1652 pWlanParams->MacClock = MacClock;
1653
1654 /* force same clock - for printing */
1655 pWlanParams->ArmClock = MacClock;
1656 WLAN_REPORT_REPLY(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1657 ("whal_hwCtrl_MacClockSet: Mac=%d (Arm=%d)\n", pWlanParams->MacClock, pWlanParams->ArmClock));
1658
1659 /* Illegal combination Mac=80, Arm=40 ==> force setting 40/40*/
1660 if ((pWlanParams->MacClock == HW_CLOCK_80_MHZ) && (pWlanParams->ArmClock == HW_CLOCK_40_MHZ))
1661 {
1662 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1663 ("whal_hwCtrl_MacClockSet: ---------- Illegal combination Mac=80, Arm=40 ==> force setting 40/40\n"));
1664 pWlanParams->MacClock = HW_CLOCK_40_MHZ;
1665 }
1666
1667 return whal_hwInfoElemFeatureConfigSet (pHwCtrl->pHwMboxConfig, pWlanParams->FeatureOptions, pWlanParams->FeatureDataFlowOptions);
1668 }
1669
1670 /****************************************************************************
1671 * whal_hwCtrl_WepDefaultKeyAdd()
1672 ****************************************************************************
1673 * DESCRIPTION: Set the actual default key
1674 *
1675 * INPUTS:
1676 *
1677 * OUTPUT:
1678 *
1679 * RETURNS: OK or NOK
1680 ****************************************************************************/
whal_hwCtrl_WepDefaultKeyAdd(HwCtrl_T * pHwCtrl,securityKeys_t * aSecurityKey,void * CB_Func,TI_HANDLE CB_handle)1681 int whal_hwCtrl_WepDefaultKeyAdd (HwCtrl_T *pHwCtrl, securityKeys_t* aSecurityKey, void *CB_Func, TI_HANDLE CB_handle)
1682 {
1683 int Stt;
1684
1685 char MacAddr_Dummy[6];
1686
1687 Stt = whal_hwMboxCmd_SetKey(pHwCtrl->pHwMboxCmd, KEY_ADD_OR_REPLACE,
1688 (char*)MacAddr_Dummy,
1689 aSecurityKey->encLen, KEY_WEP_DEFAULT,
1690 aSecurityKey->keyIndex,
1691 (char*)aSecurityKey->encKey, 0, 0,
1692 CB_Func, CB_handle);
1693
1694 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1695 ("whal_hwCtrl_WepDefaultKeyAdd: ## len=%d, id=%d encKey[5 entries]=0x %x %x %x %x %x\n",
1696 aSecurityKey->encLen,
1697 aSecurityKey->keyIndex,
1698 aSecurityKey->encKey[0], aSecurityKey->encKey[1], aSecurityKey->encKey[2], aSecurityKey->encKey[3], aSecurityKey->encKey[4] ));
1699
1700 return Stt;
1701 }
1702
1703 /****************************************************************************
1704 * whal_hwCtrl_WepDefaultKeyRemove()
1705 ****************************************************************************
1706 * DESCRIPTION: Set the actual default key
1707 *
1708 * INPUTS:
1709 *
1710 * OUTPUT:
1711 *
1712 * RETURNS: OK or NOK
1713 ****************************************************************************/
whal_hwCtrl_WepDefaultKeyRemove(HwCtrl_T * pHwCtrl,securityKeys_t * aSecurityKey,void * CB_Func,TI_HANDLE CB_handle)1714 int whal_hwCtrl_WepDefaultKeyRemove (HwCtrl_T *pHwCtrl, securityKeys_t* aSecurityKey, void *CB_Func, TI_HANDLE CB_handle)
1715 {
1716 int Stt;
1717
1718 char MacAddr_Dummy[6];
1719
1720 Stt = whal_hwMboxCmd_SetKey(pHwCtrl->pHwMboxCmd, KEY_REMOVE,
1721 (char*)MacAddr_Dummy,
1722 aSecurityKey->encLen, KEY_WEP_DEFAULT,
1723 aSecurityKey->keyIndex,
1724 (char*)aSecurityKey->encKey, 0, 0,
1725 CB_Func, CB_handle);
1726
1727 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1728 ("whal_hwCtrl_WepDefaultKeyRemove: ## id=%d \n",
1729 aSecurityKey->keyIndex));
1730
1731 return Stt;
1732 }
1733
1734 /****************************************************************************
1735 * whal_hwCtrl_WepMappingKeyAdd()
1736 ****************************************************************************
1737 * DESCRIPTION: Set the actual mapping key
1738 *
1739 * INPUTS:
1740 *
1741 * OUTPUT:
1742 *
1743 * RETURNS: OK or NOK
1744 ****************************************************************************/
whal_hwCtrl_WepMappingKeyAdd(HwCtrl_T * pHwCtrl,securityKeys_t * aSecurityKey,void * CB_Func,TI_HANDLE CB_handle)1745 int whal_hwCtrl_WepMappingKeyAdd (HwCtrl_T *pHwCtrl, securityKeys_t* aSecurityKey, void *CB_Func, TI_HANDLE CB_handle)
1746 {
1747 int Stt;
1748
1749 Stt = whal_hwMboxCmd_SetKey(pHwCtrl->pHwMboxCmd, KEY_ADD_OR_REPLACE,
1750 (char*)aSecurityKey->macAddress.addr,
1751 aSecurityKey->encLen, KEY_WEP_ADDR,
1752 aSecurityKey->keyIndex,
1753 (char*)aSecurityKey->encKey, 0, 0,
1754 CB_Func, CB_handle);
1755
1756 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1757 ("whal_hwCtrl_WepMappingKeyAdd: ## len=%d, id=%d encKey[5 entries]=0x %x %x %x %x %x\n",
1758 aSecurityKey->encLen,
1759 aSecurityKey->keyIndex,
1760 aSecurityKey->encKey[0], aSecurityKey->encKey[1], aSecurityKey->encKey[2], aSecurityKey->encKey[3], aSecurityKey->encKey[4] ));
1761
1762
1763 return Stt;
1764 }
1765
1766 /****************************************************************************
1767 * whal_hwCtrl_WepMappingKeyRemove()
1768 ****************************************************************************
1769 * DESCRIPTION: Set the actual mapping key
1770 *
1771 * INPUTS:
1772 *
1773 * OUTPUT:
1774 *
1775 * RETURNS: OK or NOK
1776 ****************************************************************************/
whal_hwCtrl_WepMappingKeyRemove(HwCtrl_T * pHwCtrl,securityKeys_t * aSecurityKey,void * CB_Func,TI_HANDLE CB_handle)1777 int whal_hwCtrl_WepMappingKeyRemove (HwCtrl_T *pHwCtrl, securityKeys_t* aSecurityKey, void *CB_Func, TI_HANDLE CB_handle)
1778 {
1779 int Stt;
1780
1781 Stt = whal_hwMboxCmd_SetKey(pHwCtrl->pHwMboxCmd, KEY_REMOVE,
1782 (char*)aSecurityKey->macAddress.addr,
1783 aSecurityKey->encLen, KEY_WEP_ADDR,
1784 aSecurityKey->keyIndex,
1785 (char*)aSecurityKey->encKey, 0, 0,
1786 CB_Func, CB_handle);
1787
1788 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1789 ("whal_hwCtrl_WepMappingKeyRemove: ## id=%d \n",
1790 aSecurityKey->keyIndex));
1791
1792 return Stt;
1793 }
1794
1795 /****************************************************************************
1796 * whal_hwCtrl_TkipMicMappingKeyAdd()
1797 ****************************************************************************
1798 * DESCRIPTION: Set the actual mapping key
1799 *
1800 * INPUTS:
1801 *
1802 * OUTPUT:
1803 *
1804 * RETURNS: OK or NOK
1805 ****************************************************************************/
whal_hwCtrl_TkipMicMappingKeyAdd(HwCtrl_T * pHwCtrl,securityKeys_t * aSecurityKey,void * CB_Func,TI_HANDLE CB_handle)1806 int whal_hwCtrl_TkipMicMappingKeyAdd (HwCtrl_T *pHwCtrl, securityKeys_t* aSecurityKey, void *CB_Func, TI_HANDLE CB_handle)
1807 {
1808 int Stt = OK;
1809
1810 UINT8 keyType;
1811 UINT8 keyBuffer[KEY_SIZE_TKIP];
1812
1813 keyType = (IsMacAddressGroup(&(aSecurityKey->macAddress))==1) ? KEY_TKIP_MIC_GROUP: KEY_TKIP_MIC_PAIRWISE;
1814
1815 os_memoryCopy(pHwCtrl->hOs, (PVOID)(&keyBuffer[0]), (PVOID)aSecurityKey->encKey, 16);
1816 os_memoryCopy(pHwCtrl->hOs, (PVOID)(&keyBuffer[16]), (PVOID)aSecurityKey->micRxKey, 8);
1817 os_memoryCopy(pHwCtrl->hOs, (PVOID)(&keyBuffer[24]), (PVOID)aSecurityKey->micTxKey, 8);
1818
1819 Stt = whal_hwMboxCmd_SetKey(pHwCtrl->pHwMboxCmd, KEY_ADD_OR_REPLACE,
1820 (char*)aSecurityKey->macAddress.addr,
1821 KEY_SIZE_TKIP, keyType,
1822 aSecurityKey->keyIndex ,
1823 (char*)keyBuffer, pHwCtrl->SecuritySeqNumLow, pHwCtrl->SecuritySeqNumHigh,
1824 CB_Func, CB_handle);
1825
1826 return Stt;
1827 }
1828
1829 /****************************************************************************
1830 * whal_hwCtrl_TkipMappingKeyAdd()
1831 ****************************************************************************
1832 * DESCRIPTION: Set the actual mapping key
1833 *
1834 * INPUTS:
1835 *
1836 * OUTPUT:
1837 *
1838 * RETURNS: OK or NOK
1839 ****************************************************************************/
whal_hwCtrl_TkipMicMappingKeyRemove(HwCtrl_T * pHwCtrl,securityKeys_t * aSecurityKey,void * CB_Func,TI_HANDLE CB_handle)1840 int whal_hwCtrl_TkipMicMappingKeyRemove (HwCtrl_T *pHwCtrl, securityKeys_t* aSecurityKey, void *CB_Func, TI_HANDLE CB_handle)
1841 {
1842 int Stt;
1843 /* UINT8 bcast[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; */
1844
1845 UINT8 keyType;
1846
1847 keyType = (IsMacAddressGroup(&(aSecurityKey->macAddress))==1) ? KEY_TKIP_MIC_GROUP: KEY_TKIP_MIC_PAIRWISE;
1848
1849 Stt = whal_hwMboxCmd_SetKey(pHwCtrl->pHwMboxCmd, KEY_REMOVE,
1850 (char*)aSecurityKey->macAddress.addr,
1851 aSecurityKey->encLen, keyType,
1852 aSecurityKey->keyIndex ,
1853 (char*)aSecurityKey->encKey, 0, 0,
1854 CB_Func, CB_handle);
1855
1856 return Stt;
1857 }
1858
1859 /****************************************************************************
1860 * whal_hwCtrl_AesMappingKeyAdd()
1861 ****************************************************************************
1862 * DESCRIPTION: Set the actual Aes mapping key
1863 *
1864 * INPUTS:
1865 *
1866 * OUTPUT:
1867 *
1868 * RETURNS: OK or NOK
1869 ****************************************************************************/
whal_hwCtrl_AesMappingKeyAdd(HwCtrl_T * pHwCtrl,securityKeys_t * aSecurityKey,void * CB_Func,TI_HANDLE CB_handle)1870 int whal_hwCtrl_AesMappingKeyAdd (HwCtrl_T *pHwCtrl, securityKeys_t* aSecurityKey, void *CB_Func, TI_HANDLE CB_handle)
1871 {
1872 int Stt;
1873 UINT8 keyType;
1874
1875 keyType = IsMacAddressGroup(&(aSecurityKey->macAddress)) ?
1876 KEY_AES_GROUP: KEY_AES_PAIRWISE;
1877
1878 Stt = whal_hwMboxCmd_SetKey(pHwCtrl->pHwMboxCmd, KEY_ADD_OR_REPLACE,
1879 (char*)aSecurityKey->macAddress.addr,
1880 aSecurityKey->encLen, keyType,
1881 aSecurityKey->keyIndex ,
1882 (char*)aSecurityKey->encKey, pHwCtrl->SecuritySeqNumLow, pHwCtrl->SecuritySeqNumHigh,
1883 CB_Func, CB_handle);
1884
1885 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1886 ("whal_hwCtrl_AesMappingKeyAdd: SecuritySeqNumHigh=%ld, pHwCtrl->SecuritySeqNumLow=%ld \n",
1887 pHwCtrl->SecuritySeqNumHigh, pHwCtrl->SecuritySeqNumLow));
1888
1889
1890 return Stt;
1891
1892 }
1893
1894
1895 /****************************************************************************
1896 * whal_hwCtrl_AesMappingKeyRemove()
1897 ****************************************************************************
1898 * DESCRIPTION: Remove Aes mapping key
1899 *
1900 * INPUTS:
1901 *
1902 * OUTPUT:
1903 *
1904 * RETURNS: OK or NOK
1905 ****************************************************************************/
whal_hwCtrl_AesMappingKeyRemove(HwCtrl_T * pHwCtrl,securityKeys_t * aSecurityKey,void * CB_Func,TI_HANDLE CB_handle)1906 int whal_hwCtrl_AesMappingKeyRemove (HwCtrl_T *pHwCtrl, securityKeys_t* aSecurityKey, void *CB_Func, TI_HANDLE CB_handle)
1907 {
1908 int Stt;
1909 UINT8 keyType;
1910
1911 keyType = IsMacAddressGroup(&(aSecurityKey->macAddress)) ?
1912 KEY_AES_GROUP: KEY_AES_PAIRWISE;
1913
1914 Stt = whal_hwMboxCmd_SetKey(pHwCtrl->pHwMboxCmd, KEY_REMOVE,
1915 (char*)aSecurityKey->macAddress.addr,
1916 aSecurityKey->encLen, keyType,
1917 aSecurityKey->keyIndex ,
1918 (char*)aSecurityKey->encKey, 0, 0,
1919 CB_Func, CB_handle);
1920
1921 return Stt;
1922 }
1923
1924 /****************************************************************************
1925 * whal_hwCtrl_DefaultKeyIdSet()
1926 ****************************************************************************
1927 * DESCRIPTION: Set the default key ID
1928 *
1929 * INPUTS:
1930 *
1931 * OUTPUT:
1932 *
1933 * RETURNS: OK or NOK
1934 ****************************************************************************/
whal_hwCtrl_DefaultKeyIdSet(HwCtrl_T * pHwCtrl,UINT8 aKeyIdVal,void * CB_Func,TI_HANDLE CB_handle)1935 int whal_hwCtrl_DefaultKeyIdSet (HwCtrl_T *pHwCtrl, UINT8 aKeyIdVal, void *CB_Func, TI_HANDLE CB_handle)
1936 {
1937 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1938 ("whal_hwCtrl_DefaultKeyIdSet: ## Id=%d\n", aKeyIdVal));
1939
1940 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1941 ("whal_hwCtrl_DefaultKeyIdSet: ## Id=%d\n", aKeyIdVal));
1942
1943 /* Set the default key Id */
1944 return whal_hwInfoElemWepDefaultKeyIdSet (pHwCtrl->pHwMboxConfig, &aKeyIdVal, CB_Func, CB_handle);
1945 }
1946
1947 /****************************************************************************
1948 * whal_hwCtrl_DefaultKeyIdGet()
1949 ****************************************************************************
1950 * DESCRIPTION: Get the default key ID
1951 *
1952 * INPUTS:
1953 *
1954 * OUTPUT:
1955 *
1956 * RETURNS: OK or NOK
1957 ****************************************************************************/
whal_hwCtrl_DefaultKeyIdGet(HwCtrl_T * pHwCtrl,UINT8 * pKeyIdVal)1958 int whal_hwCtrl_DefaultKeyIdGet (HwCtrl_T *pHwCtrl, UINT8 *pKeyIdVal)
1959 {
1960 /* Get the default key Id */
1961 return whal_hwInfoElemWepDefaultKeyIdGet (pHwCtrl->pHwMboxConfig, pKeyIdVal, NULL, NULL);
1962 }
1963
1964 /****************************************************************************
1965 * whal_hwCtrl_Initiate()
1966 ****************************************************************************
1967 * DESCRIPTION: Download firmware code to the Hardware and run it
1968 *
1969 * INPUTS: None
1970 *
1971 * OUTPUT: None
1972 *
1973 * RETURNS: OK or NOK
1974 ****************************************************************************/
whal_hwCtrl_Initiate(HwCtrl_T * pHwCtrl)1975 TI_STATUS whal_hwCtrl_Initiate (HwCtrl_T *pHwCtrl)
1976 {
1977 WlanParams_T *pWlanParams = whal_ParamsGetWlanParams(pHwCtrl->pWhalParams);
1978 BootAttr_T BootAttr;
1979 TI_STATUS status;
1980
1981 BootAttr.MacClock = pWlanParams->MacClock;
1982 BootAttr.ArmClock = pWlanParams->ArmClock;
1983
1984 if ((status = whalBus_FwCtrl_Boot (pHwCtrl->hWhalBus, (TI_HANDLE)pHwCtrl, &BootAttr)) == TNETWIF_ERROR)
1985 {
1986 WLAN_REPORT_WARNING (pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
1987 ("whal_hwCtrl_Initiate: whalBus_FwCtrl_Boot failure!!!\n"));
1988 }
1989
1990 return status;
1991 }
1992
1993
1994
1995 /****************************************************************************
1996 * whal_hwCtrl_Stop()
1997 ****************************************************************************
1998 * DESCRIPTION: Stop the Hardware firmware
1999 *
2000 * INPUTS: None
2001 *
2002 * OUTPUT: None
2003 *
2004 * RETURNS: None
2005 ****************************************************************************/
whal_hwCtrl_Stop(HwCtrl_T * pHwCtrl)2006 void whal_hwCtrl_Stop(HwCtrl_T *pHwCtrl)
2007 {
2008
2009 #ifdef WDBG_POLLING /* (!!!) ONLY FOR DEBUG WHEN THERE ARE NO INTERRUPTS */
2010 os_timerStop(pHwCtrl->hOs, hal_timer);
2011 #endif
2012
2013 /*
2014 * Stop Acx Cpu
2015 */
2016 whalBus_FwCtrl_Halt(pHwCtrl->hWhalBus);
2017 return;
2018 }
2019
2020 /****************************************************************************
2021 * whal_hwCtrl_GetBusHandle()
2022 ****************************************************************************
2023 * DESCRIPTION: Return the handle of the Bus object.
2024 *
2025 * INPUTS:
2026 *
2027 * OUTPUT: None
2028 *
2029 * RETURNS: handle of the HwIntr object
2030 ****************************************************************************/
whal_hwCtrl_GetBusHandle(HwCtrl_T * pHwCtrl)2031 TI_HANDLE whal_hwCtrl_GetBusHandle(HwCtrl_T *pHwCtrl)
2032 {
2033 return pHwCtrl->hWhalBus;
2034 }
2035
2036 /****************************************************************************
2037 * whal_hwCtrl_GetMboxConfig()
2038 ****************************************************************************
2039 * DESCRIPTION: Return the handle of the MboxConfig object.
2040 *
2041 * INPUTS:
2042 *
2043 * OUTPUT: None
2044 *
2045 * RETURNS: handle of the MboxConfig object
2046 ****************************************************************************/
whal_hwCtrl_GetMboxConfig(HwCtrl_T * pHwCtrl)2047 HwMboxConfig_T *whal_hwCtrl_GetMboxConfig(HwCtrl_T *pHwCtrl)
2048 {
2049 return pHwCtrl->pHwMboxConfig;
2050 }
2051
2052 /****************************************************************************
2053 * whal_hwCtrl_GetMboxCmd()
2054 ****************************************************************************
2055 * DESCRIPTION: Return the handle of the MboxCmd object.
2056 *
2057 * INPUTS:
2058 *
2059 * OUTPUT: None
2060 *
2061 * RETURNS: handle of the MboxCmd object
2062 ****************************************************************************/
whal_hwCtrl_GetMboxCmd(HwCtrl_T * pHwCtrl)2063 HwMboxCmd_T *whal_hwCtrl_GetMboxCmd(HwCtrl_T *pHwCtrl)
2064 {
2065 return pHwCtrl->pHwMboxCmd;
2066 }
2067
2068 /****************************************************************************
2069 * whal_hwCtrl_StartScan()
2070 ****************************************************************************
2071 * DESCRIPTION: Send Start Scan command
2072 *
2073 * INPUTS: None
2074 *
2075 * OUTPUT: None
2076 *
2077 * RETURNS: OK or NOK
2078 ****************************************************************************/
whal_hwCtrl_StartScan(HwCtrl_T * pHwCtrl,ScanParameters_t * pScanVals,void * ScanCommandResponseCB,TI_HANDLE CB_handle)2079 int whal_hwCtrl_StartScan (HwCtrl_T *pHwCtrl, ScanParameters_t* pScanVals, void* ScanCommandResponseCB, TI_HANDLE CB_handle)
2080 {
2081 return (whal_hwMboxCmd_StartScan (pHwCtrl->pHwMboxCmd, pScanVals, ScanCommandResponseCB,CB_handle));
2082 }
2083
2084 /****************************************************************************
2085 * whal_hwCtrl_StartSPSScan()
2086 ****************************************************************************
2087 * DESCRIPTION: Send Start SPS Scan command
2088 *
2089 * INPUTS: None
2090 *
2091 * OUTPUT: None
2092 *
2093 * RETURNS: OK or NOK
2094 ****************************************************************************/
whal_hwCtrl_StartSPSScan(HwCtrl_T * pHwCtrl,ScheduledScanParameters_t * pScanVals,void * ScanCommandResponseCB,TI_HANDLE CB_handle)2095 int whal_hwCtrl_StartSPSScan( HwCtrl_T *pHwCtrl, ScheduledScanParameters_t* pScanVals, void* ScanCommandResponseCB, TI_HANDLE CB_handle)
2096 {
2097 return (whal_hwMboxCmd_StartSPSScan (pHwCtrl->pHwMboxCmd, pScanVals, ScanCommandResponseCB, CB_handle));
2098 }
2099
2100 /****************************************************************************
2101 * whal_hwCtrl_StopScan()
2102 ****************************************************************************
2103 * DESCRIPTION: Send Stop Scan command
2104 *
2105 * INPUTS: None
2106 *
2107 * OUTPUT: None
2108 *
2109 * RETURNS: OK or NOK
2110 ****************************************************************************/
whal_hwCtrl_StopScan(HwCtrl_T * pHwCtrl,void * ScanCommandResponseCB,TI_HANDLE CB_handle)2111 int whal_hwCtrl_StopScan (HwCtrl_T *pHwCtrl, void *ScanCommandResponseCB, TI_HANDLE CB_handle)
2112 {
2113 return(whal_hwMboxCmd_StopScan (pHwCtrl->pHwMboxCmd, ScanCommandResponseCB, CB_handle));
2114 }
2115
2116 /****************************************************************************
2117 * whal_hwCtrl_StopSPSScan()
2118 ****************************************************************************
2119 * DESCRIPTION: Send Stop SPS Scan command
2120 *
2121 * INPUTS: None
2122 *
2123 * OUTPUT: None
2124 *
2125 * RETURNS: OK or NOK
2126 ****************************************************************************/
whal_hwCtrl_StopSPSScan(HwCtrl_T * pHwCtrl,void * ScanCommandResponseCB,TI_HANDLE CB_handle)2127 int whal_hwCtrl_StopSPSScan (HwCtrl_T *pHwCtrl, void* ScanCommandResponseCB, TI_HANDLE CB_handle)
2128 {
2129 return(whal_hwMboxCmd_StopSPSScan (pHwCtrl->pHwMboxCmd, ScanCommandResponseCB, CB_handle));
2130 }
2131
2132 /****************************************************************************
2133 * whal_hwCtrl_GenCmd()
2134 ****************************************************************************
2135 * DESCRIPTION: Send any command to hw MB command
2136 *
2137 * INPUTS: None
2138 *
2139 * OUTPUT: None
2140 *
2141 * RETURNS: OK or NOK
2142 ****************************************************************************/
whal_hwCtrl_GenCmd(HwCtrl_T * pHwCtrl,short CmdID,char * pBuf,UINT32 Length)2143 int whal_hwCtrl_GenCmd(HwCtrl_T *pHwCtrl, short CmdID, char* pBuf, UINT32 Length)
2144 {
2145 return (whal_hwMboxCmd_GenCmd(pHwCtrl->pHwMboxCmd, CmdID, pBuf, Length));
2146 }
2147
2148 /****************************************************************************
2149 * whal_hwCtrl_isElpSupported ()
2150 ****************************************************************************
2151 * DESCRIPTION: Check if ELP feature is supported based on the HW device
2152 *
2153 * INPUTS:
2154 *
2155 * OUTPUT:
2156 *
2157 * RETURNS: ELP feature is supported/not
2158 ****************************************************************************/
whal_hwCtrl_isElpSupported(HwCtrl_T * pHwCtrl)2159 BOOL whal_hwCtrl_isElpSupported (HwCtrl_T *pHwCtrl)
2160 {
2161 return TRUE;
2162 }
2163
2164 /****************************************************************************
2165 * whal_hwCtrl_AidSet()
2166 ****************************************************************************
2167 * DESCRIPTION: Set the AID
2168 *
2169 * INPUTS:
2170 *
2171 * OUTPUT:
2172 *
2173 * RETURNS: OK or NOK
2174 ****************************************************************************/
whal_hwCtrl_AidSet(HwCtrl_T * pHwCtrl,UINT16 aAidVal)2175 int whal_hwCtrl_AidSet (HwCtrl_T *pHwCtrl, UINT16 aAidVal)
2176 {
2177 /* Set the Aid */
2178 return whal_hwInfoElemAidSet (pHwCtrl->pHwMboxConfig, &aAidVal);
2179 }
2180
2181
2182 /****************************************************************************
2183 * whal_hwCtrl_CurrentTxRxAntennaSendCmd()
2184 ****************************************************************************
2185 * DESCRIPTION: send Diversity command to F/W with the pre-stored antenna
2186 * diversity parameters
2187 *
2188 * INPUTS:
2189 *
2190 * OUTPUT:
2191 *
2192 * RETURNS: OK or NOK
2193 ****************************************************************************/
whal_hwCtrl_CurrentAntennaDiversitySendCmd(HwCtrl_T * pHwCtrl)2194 int whal_hwCtrl_CurrentAntennaDiversitySendCmd (HwCtrl_T *pHwCtrl)
2195 {
2196 int status;
2197
2198 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,("whal_hwCtrl_CurrentRxAntennaSet\n"));
2199
2200 /* Write the current antenna diversity values to the HW*/
2201 if ( RADIO_RADIA_DCR_ID == pHwCtrl->pWhalParams->WlanParams.radioType )
2202 {
2203 status = whal_hwInfoElemAntennaDiversitySet (pHwCtrl->pHwMboxConfig,
2204 &(pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions),
2205 1);
2206 }
2207 else
2208 {
2209 status = whal_hwInfoElemAntennaDiversitySet (pHwCtrl->pHwMboxConfig,
2210 &(pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions),
2211 2);
2212 }
2213
2214 return(status);
2215 }
2216
2217 /****************************************************************************
2218 * whal_hwCtrl_SetTxAntenna()
2219 ****************************************************************************
2220 * DESCRIPTION: Save TX antenna
2221 *
2222 * INPUTS:
2223 *
2224 * OUTPUT:
2225 *
2226 * RETURNS: OK or NOK
2227 ****************************************************************************/
whal_hwCtrl_SetTxAntenna(HwCtrl_T * pHwCtrl,UINT8 TxAntenna)2228 int whal_hwCtrl_SetTxAntenna (HwCtrl_T *pHwCtrl, UINT8 TxAntenna)
2229 {
2230 if (TxAntenna == 1)
2231 {
2232 pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.txSelectedAntenna = DIVS_TX_START_ANT1;
2233 }
2234 else if (TxAntenna == 2)
2235 {
2236 pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.txSelectedAntenna = DIVS_TX_START_ANT2;
2237 }
2238 else
2239 {
2240 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2241 ("whal_hwCtrl_SetTxAntenna: wrong antenna param %d\n", TxAntenna));
2242 return PARAM_VALUE_NOT_VALID;
2243 }
2244
2245 return OK;
2246 }
2247
2248 /****************************************************************************
2249 * whal_hwCtrl_GetTxAntenna()
2250 ****************************************************************************
2251 * DESCRIPTION: retrieve TX antenna
2252 *
2253 * INPUTS:
2254 *
2255 * OUTPUT:
2256 *
2257 * RETURNS: OK or NOK
2258 ****************************************************************************/
whal_hwCtrl_GetTxAntenna(HwCtrl_T * pHwCtrl,UINT8 * TxAntenna)2259 int whal_hwCtrl_GetTxAntenna (HwCtrl_T *pHwCtrl, UINT8* TxAntenna)
2260 {
2261 if (pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.txSelectedAntenna == DIVS_RX_START_ANT1)
2262 {
2263 *TxAntenna = 1;
2264 }
2265 else if (pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.txSelectedAntenna == DIVS_RX_START_ANT2)
2266 {
2267 *TxAntenna = 2;
2268 }
2269 else
2270 {
2271 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2272 ("whal_hwCtrl_GetTxAntenna: wrong configured antenna param %d\n", pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.txSelectedAntenna));
2273 return CONFIGURATION_NOT_VALID;
2274 }
2275
2276 return OK;
2277 }
2278
2279 /****************************************************************************
2280 * whal_hwCtrl_SetRxAntenna()
2281 ****************************************************************************
2282 * DESCRIPTION: Save RX antenna
2283 *
2284 * INPUTS:
2285 *
2286 * OUTPUT:
2287 *
2288 * RETURNS: OK or NOK
2289 ****************************************************************************/
whal_hwCtrl_SetRxAntenna(HwCtrl_T * pHwCtrl,UINT8 RxAntenna)2290 int whal_hwCtrl_SetRxAntenna (HwCtrl_T *pHwCtrl, UINT8 RxAntenna)
2291 {
2292 if (RxAntenna == 1)
2293 {
2294 pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.rxSelectedAntenna = DIVS_RX_START_ANT1;
2295 }
2296 else if (RxAntenna == 2)
2297 {
2298 pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.rxSelectedAntenna = DIVS_RX_START_ANT2;
2299 }
2300 else
2301 {
2302 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2303 ("whal_hwCtrl_SetRxAntenna: wrong antenna param %d\n", RxAntenna));
2304 return PARAM_VALUE_NOT_VALID;
2305 }
2306
2307 return OK;
2308 }
2309
2310 /****************************************************************************
2311 * whal_hwCtrl_GetRxAntenna()
2312 ****************************************************************************
2313 * DESCRIPTION: retrieve RX antenna
2314 *
2315 * INPUTS:
2316 *
2317 * OUTPUT:
2318 *
2319 * RETURNS: OK or NOK
2320 ****************************************************************************/
whal_hwCtrl_GetRxAntenna(HwCtrl_T * pHwCtrl,UINT8 * RxAntenna)2321 int whal_hwCtrl_GetRxAntenna (HwCtrl_T *pHwCtrl, UINT8* RxAntenna)
2322 {
2323 if (pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.rxSelectedAntenna == DIVS_RX_START_ANT1)
2324 {
2325 *RxAntenna = 1;
2326 }
2327 else if (pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.rxSelectedAntenna == DIVS_RX_START_ANT2)
2328 {
2329 *RxAntenna = 2;
2330 }
2331 else
2332 {
2333 WLAN_REPORT_ERROR(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2334 ("whal_hwCtrl_GetRxAntenna: wrong configured antenna param %d\n", pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions.rxSelectedAntenna));
2335 return CONFIGURATION_NOT_VALID;
2336 }
2337
2338 return OK;
2339 }
2340
2341 /****************************************************************************
2342 * whal_hwCtrl_SaveAntennaDiversityOptions()
2343 ****************************************************************************
2344 * DESCRIPTION: Save antenna diversity parameters
2345 *
2346 * INPUTS:
2347 *
2348 * OUTPUT:
2349 *
2350 * RETURNS: OK or NOK
2351 ****************************************************************************/
whal_hwCtrl_SaveAntennaDiversityOptions(HwCtrl_T * pHwCtrl,whalCtrl_antennaDiversityOptions_t * pAntennaDivresityOptions)2352 int whal_hwCtrl_SaveAntennaDiversityOptions (HwCtrl_T *pHwCtrl,
2353 whalCtrl_antennaDiversityOptions_t* pAntennaDivresityOptions )
2354 {
2355 os_memoryCopy( pHwCtrl->hOs, (void*)&(pHwCtrl->pWhalParams->WlanParams.antennaDiversityOptions),
2356 (void*)pAntennaDivresityOptions, sizeof( whalCtrl_antennaDiversityOptions_t ) );
2357 whal_hwCtrl_SetTxAntenna(pHwCtrl, pAntennaDivresityOptions->txSelectedAntenna);
2358 whal_hwCtrl_SetRxAntenna(pHwCtrl, pAntennaDivresityOptions->rxSelectedAntenna);
2359 return OK;
2360 }
2361
2362 /****************************************************************************
2363 * whal_hwCtrl_CurrentAssociationIdGet()
2364 ****************************************************************************
2365 * DESCRIPTION: Get the current TX antenna
2366 *
2367 * INPUTS:
2368 *
2369 * OUTPUT:
2370 *
2371 * RETURNS: OK or NOK
2372 ****************************************************************************/
whal_hwCtrl_CurrentAssociationIdGet(HwCtrl_T * pHwCtrl,UINT16 * pAidVal)2373 int whal_hwCtrl_CurrentAssociationIdGet (HwCtrl_T *pHwCtrl, UINT16 *pAidVal)
2374 {
2375 *pAidVal = pHwCtrl->pWhalParams->WlanParams.Aid;
2376 return OK;
2377 }
2378
2379 /****************************************************************************
2380 * whal_hwCtrl_OverridePhyRegsDefaults()
2381 ****************************************************************************
2382 * DESCRIPTION: Set phy register for short preamble problem
2383 *
2384 * INPUTS:
2385 *
2386 * OUTPUT:
2387 *
2388 * RETURNS:
2389 ****************************************************************************/
whal_hwCtrl_OverridePhyRegsDefaults(HwCtrl_T * pHwCtrl)2390 void whal_hwCtrl_OverridePhyRegsDefaults(HwCtrl_T *pHwCtrl)
2391 {
2392 /*
2393 * Configure the energy detection
2394 */
2395 whal_hwCtrl_SetEnergyDetection(pHwCtrl, pHwCtrl->pWhalParams->WlanParams.RxEnergyDetection);
2396
2397 /*
2398 * Disable OFDM receiver in channel 14 (overcome FCS errors problem)
2399 */
2400 /* moved to the firmware */
2401 }
2402
2403
whal_hwCtrl_EncDecrSet(HwCtrl_T * pHwCtrl,BOOL aHwEncEnable,BOOL aHwDecEnable)2404 int whal_hwCtrl_EncDecrSet (HwCtrl_T *pHwCtrl, BOOL aHwEncEnable, BOOL aHwDecEnable)
2405 {
2406 WlanParams_T *pWlanParams = &pHwCtrl->pWhalParams->WlanParams;
2407
2408 if (aHwEncEnable)
2409 pWlanParams->FeatureDataFlowOptions &= ~DF_ENCRYPTION_DISABLE;
2410 else
2411 pWlanParams->FeatureDataFlowOptions |= DF_ENCRYPTION_DISABLE;
2412
2413 /* Set bit DF_SNIFF_MODE_ENABLE to enable or prevent decryption in fw */
2414 /* WARNING: Have to check how to control the decryption (which bit) and then set/reset
2415 the appropriate bit*/
2416 if (aHwDecEnable)
2417 pWlanParams->FeatureDataFlowOptions &= ~DF_SNIFF_MODE_ENABLE;
2418 else
2419 pWlanParams->FeatureDataFlowOptions |= DF_SNIFF_MODE_ENABLE;
2420
2421 return whal_hwInfoElemFeatureConfigSet (pHwCtrl->pHwMboxConfig, pWlanParams->FeatureOptions, pWlanParams->FeatureDataFlowOptions);
2422 }
2423
whal_hwCtrl_ClkRunEnableSet(HwCtrl_T * pHwCtrl,BOOL aClkRunEnable)2424 int whal_hwCtrl_ClkRunEnableSet (HwCtrl_T *pHwCtrl, BOOL aClkRunEnable)
2425 {
2426 WlanParams_T *pWlanParams = &pHwCtrl->pWhalParams->WlanParams;
2427
2428 if (aClkRunEnable)
2429 pWlanParams->FeatureDataFlowOptions |= FEAT_PCI_CLK_RUN_ENABLE;
2430 else
2431 pWlanParams->FeatureDataFlowOptions &= ~FEAT_PCI_CLK_RUN_ENABLE;
2432
2433 return whal_hwInfoElemFeatureConfigSet (pHwCtrl->pHwMboxConfig, pWlanParams->FeatureOptions, pWlanParams->FeatureDataFlowOptions);
2434 }
2435
whal_hwCtrl_RxMsduFormatSet(HwCtrl_T * pHwCtrl,BOOL aRxMsduForamtEnable)2436 int whal_hwCtrl_RxMsduFormatSet (HwCtrl_T *pHwCtrl, BOOL aRxMsduForamtEnable)
2437 {
2438 #if 1
2439 /* WARNING: Have to check how to control the Rx Frame format select (which bit)
2440 and then access the HW*/
2441 return(OK);
2442 #else
2443 WlanParams_T *pWlanParams = &pHwCtrl->pWhalParams->WlanParams;
2444 if (aRxMsduForamtEnable)
2445 pWlanParams->FeatureDataFlowOptions |= DATA_FLOW_RX_MSDU_FRAME;
2446 else
2447 pWlanParams->FeatureDataFlowOptions &= ~DATA_FLOW_RX_MSDU_FRAME;
2448
2449 return whal_hwInfoElemFeatureConfigSet (pHwCtrl->pHwMboxConfig, pWlanParams->FeatureOptions, pWlanParams->FeatureDataFlowOptions);
2450 #endif
2451 }
2452
2453 /****************************************************************************
2454 * whal_hwCtrl_getTsf()
2455 ****************************************************************************
2456 * DESCRIPTION: Get the current time stamp from the FW
2457 *
2458 * INPUTS: hwHalCtrl handle, pTsf container for the FW mac timer
2459 *
2460 * OUTPUT: pTsf FW mac timer
2461 *
2462 * RETURNS: OK, NOK
2463 *
2464 * NOTES: The time will be in usec
2465 ****************************************************************************/
2466
whal_hwCtrl_getTsf(HwCtrl_T * pHwCtrl,UINT32 * pTsf)2467 int whal_hwCtrl_getTsf(HwCtrl_T *pHwCtrl, UINT32 *pTsf)
2468 {
2469 /* for debug only - Not implemented as direct access to register */
2470 return(OK);
2471 }
2472
2473
2474 /****************************************************************************
2475 * whal_hwCtrl_NoiseHistogramCmd()
2476 ****************************************************************************
2477 * DESCRIPTION: Send Noise Histogram command
2478 *
2479 * INPUTS: None
2480 *
2481 * OUTPUT: None
2482 *
2483 * RETURNS: OK or NOK
2484 ****************************************************************************/
whal_hwCtrl_NoiseHistogramCmd(HwCtrl_T * pHwCtrl,whalCtrl_noiseHistogram_t * pNoiseHistParams)2485 int whal_hwCtrl_NoiseHistogramCmd (HwCtrl_T *pHwCtrl, whalCtrl_noiseHistogram_t* pNoiseHistParams)
2486 {
2487 return (whal_hwMboxCmd_NoiseHistogramCmd (pHwCtrl->pHwMboxCmd, pNoiseHistParams));
2488 }
2489
2490 /****************************************************************************
2491 * whal_hwCtrl_TrafficConf()
2492 ****************************************************************************
2493 * DESCRIPTION: configure Queue traffic params
2494 *
2495 * INPUTS: None
2496 *
2497 * OUTPUT: None
2498 *
2499 * RETURNS: OK or NOK
2500 ****************************************************************************/
whal_hwCtrl_TrafficConf(TI_HANDLE hHwCtrl,queueTrafficParams_t * pQtrafficParams)2501 int whal_hwCtrl_TrafficConf(TI_HANDLE hHwCtrl, queueTrafficParams_t *pQtrafficParams)
2502 {
2503 TI_STATUS status;
2504 HwCtrl_T *pHwCtrl = (HwCtrl_T*)hHwCtrl;
2505
2506
2507 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,(" whal_hwCtrl_TrafficConf: pQtrafficParams->aQueueId = 0x%x , pQtrafficParams->channelType %x pQtrafficParams->tsid %d pQtrafficParams->dot11EDCATableMSDULifeTime %d \n",
2508 pQtrafficParams->queueID,pQtrafficParams->channelType,pQtrafficParams->tsid,pQtrafficParams->dot11EDCATableMSDULifeTime));
2509
2510 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,("whal_hwCtrl_TrafficConf : psScheme = 0x%x , ackPolicy %d APSDConf[0] = 0x%x ,APSDConf[1] = 0x%x\n",pQtrafficParams->psScheme,pQtrafficParams->ackPolicy,pQtrafficParams->APSDConf[0],pQtrafficParams->APSDConf[1]));
2511
2512
2513 /* Setting the queue configuration into the HW */
2514 status = (TI_STATUS)whal_hwInfoElemQueueConfigurationSet (pHwCtrl->pHwMboxConfig,pQtrafficParams);
2515
2516 /* Set the queue param object database fields according to the succeded configuration (for recovery) */
2517 if (status == OK)
2518 whal_ParamsSetQueueParams(pHwCtrl->pWhalParams,pQtrafficParams);
2519
2520 return status;
2521 }
2522 /****************************************************************************
2523 * whal_hwCtrl_AcParamsConf()
2524 ****************************************************************************
2525 * DESCRIPTION: configure AC params
2526 *
2527 * INPUTS: None
2528 *
2529 * OUTPUT: None
2530 *
2531 * RETURNS: OK or NOK
2532 ****************************************************************************/
2533
whal_hwCtrl_AcParamsConf(TI_HANDLE hHwCtrl,configureCmdCBParams_t * pConfigureCommand)2534 int whal_hwCtrl_AcParamsConf(TI_HANDLE hHwCtrl,configureCmdCBParams_t *pConfigureCommand)
2535 {
2536
2537 TI_STATUS status;
2538 HwCtrl_T *pHwCtrl = (HwCtrl_T*)hHwCtrl;
2539 acQosParams_t *pAcQosParams = (acQosParams_t*)(pConfigureCommand->CB_buf);
2540
2541 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,(" whal_hwCtrl_AcParamsConf: Index = 0x%x, aCwMin = 0x%x, aCwMax = 0x%x, aAIFS = 0x%x, aTxOpLimit = 0x%x\n",
2542 pAcQosParams->ac,pAcQosParams->cwMin,pAcQosParams->cwMax,pAcQosParams->aifsn,pAcQosParams->txopLimit));
2543
2544 /* Setting the AC configuration into the HW */
2545
2546 if (pConfigureCommand->CB_Func == NULL)
2547 status = (TI_STATUS)whal_hwInfoElemAcParamsConfigurationSet (pHwCtrl->pHwMboxConfig,pConfigureCommand);
2548 else
2549 status = (TI_STATUS)whal_hwInfoElemAcParamsConfigurationGet (pHwCtrl->pHwMboxConfig,pConfigureCommand);
2550
2551 /* Set the AC param object database fields according to the succeeded configuration (for recovery) */
2552 if (status == OK)
2553 whal_ParamsSetAcParams(pHwCtrl->pWhalParams,pAcQosParams);
2554
2555 return status;
2556
2557 }
2558 /****************************************************************************
2559 * whal_hwCtrl_AccessCategoryConf()
2560 ****************************************************************************
2561 * DESCRIPTION: Send Access Category Configuration
2562 *
2563 * INPUTS: None
2564 *
2565 * OUTPUT: None
2566 *
2567 * RETURNS: OK or NOK
2568 ****************************************************************************/
whal_hwCtrl_QueueConf(TI_HANDLE hHwCtrl,acQueuesParams_t * pAcQueuesParams)2569 int whal_hwCtrl_QueueConf(TI_HANDLE hHwCtrl, acQueuesParams_t* pAcQueuesParams)
2570 {
2571 TI_STATUS status;
2572 HwCtrl_T *pHwCtrl = (HwCtrl_T*)hHwCtrl;
2573
2574 /* Setting the queue configuration into the HW */
2575 status = (TI_STATUS)whal_hwInfoElemTxQueueCfgSet (pHwCtrl->pHwMboxConfig,
2576 pAcQueuesParams,
2577 pHwCtrl->MemMap.numTxMemBlks);
2578
2579 /* Set the queue param object database fields according to the succeeds configuration (for recovery) */
2580 if (status == OK)
2581 whal_ParamsSetAccessCategoryParams(pHwCtrl->pWhalParams, pAcQueuesParams);
2582
2583 return status;
2584 }
2585
2586 /****************************************************************************
2587 * whal_hwCtrl_PacketDetectionThreshold()
2588 ****************************************************************************
2589 * DESCRIPTION: Send Noise Histogram command
2590 *
2591 * INPUTS: None
2592 *
2593 * OUTPUT: None
2594 *
2595 * RETURNS: OK or NOK
2596 ****************************************************************************/
whal_hwCtrl_PacketDetectionThreshold(TI_HANDLE hHwCtrl,UINT8 * pPdThreshold)2597 int whal_hwCtrl_PacketDetectionThreshold (TI_HANDLE hHwCtrl, UINT8* pPdThreshold)
2598 {
2599 TI_STATUS status;
2600 HwCtrl_T *pHwCtrl = (HwCtrl_T*)hHwCtrl;
2601 UINT32 packetDetection = *pPdThreshold;
2602
2603 /* Setting the queue configuration into the HW */
2604 status = (TI_STATUS)whal_hwInfoElemPacketDetectionThresholdSet (pHwCtrl->pHwMboxConfig, &packetDetection);
2605
2606 return status;
2607 }
2608
2609
2610
2611 /****************************************************************************
2612 * whal_hwCtrl_SetBeaconFiltering
2613 ****************************************************************************
2614 * DESCRIPTION: Sets Beacon filtering state
2615 *
2616 * INPUTS: None
2617 *
2618 * OUTPUT: None
2619 *
2620 * RETURNS: OK or NOK
2621 ****************************************************************************/
whal_hwCtrl_SetBeaconFiltering(HwCtrl_T * pHwCtrl,UINT8 beaconFilteringStatus,UINT8 numOfBeaconsToBuffer)2622 int whal_hwCtrl_SetBeaconFiltering(HwCtrl_T *pHwCtrl, UINT8 beaconFilteringStatus, UINT8 numOfBeaconsToBuffer)
2623 {
2624 ACXBeaconFilterOptions_t AcxElm_BeaconFilterOptions;
2625 ACXBeaconFilterOptions_t *pCfg = &AcxElm_BeaconFilterOptions;
2626
2627 pCfg->enable = beaconFilteringStatus;
2628 pCfg->maxNumOfBeaconsStored = numOfBeaconsToBuffer;
2629
2630 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport , ("Set beacon filter to %d" , beaconFilteringStatus) ) ;
2631
2632 return whal_hwInfoElemAcxBeaconFilterOptionsSet (pHwCtrl->pHwMboxConfig, pCfg);
2633 }
2634
2635
2636 /****************************************************************************
2637 * whal_hwCtrl_SetBeaconFilterIETable
2638 ****************************************************************************
2639 * DESCRIPTION: Sets Beacon filtering state
2640 *
2641 * INPUTS: None
2642 *
2643 * OUTPUT: None
2644 *
2645 * RETURNS: OK or NOK
2646 ****************************************************************************/
whal_hwCtrl_SetBeaconFilterIETable(HwCtrl_T * pHwCtrl,UINT8 * numberOfIEs,UINT8 * IETable,UINT8 * IETableSize)2647 int whal_hwCtrl_SetBeaconFilterIETable(HwCtrl_T *pHwCtrl, UINT8* numberOfIEs, UINT8 * IETable, UINT8* IETableSize)
2648 {
2649 int counter = 0 ;
2650 if ( NULL == pHwCtrl)
2651 {
2652 return PARAM_VALUE_NOT_VALID ;
2653 }
2654
2655 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,
2656 ("\n whal_hwCtrl_SetBeaconFilterIETable Beacon IE Table:\n"));
2657
2658 for ( counter = 0 ; counter < * IETableSize ; counter++)
2659 {
2660 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,
2661 ("%2.x " , IETable[counter]));
2662 }
2663
2664 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,
2665 ("\n "));
2666
2667
2668 return whal_hwInfoElemAcxBeaconFilterIETableSet (pHwCtrl->pHwMboxConfig,
2669 numberOfIEs,
2670 IETable,
2671 IETableSize);
2672 }
2673
2674
2675 /****************************************************************************
2676 * whal_HwCtrl_enableMboxAsyncMode()
2677 ****************************************************************************
2678 * DESCRIPTION:
2679 *
2680 * INPUTS:
2681 *
2682 * OUTPUT:
2683 *
2684 * RETURNS: OK, NOK
2685 *
2686 * NOTES:
2687 ****************************************************************************/
whal_HwCtrl_enableMboxAsyncMode(HwCtrl_T * pHwCtrl)2688 int whal_HwCtrl_enableMboxAsyncMode(HwCtrl_T *pHwCtrl)
2689 {
2690 eventMbox_InitComplete(pHwCtrl->hEventMbox);
2691 return OK;
2692 }
2693
2694 /****************************************************************************
2695 * whal_HwCtrl_resetMacRx()
2696 ****************************************************************************
2697 * DESCRIPTION: Reset the Rx Max module
2698 *
2699 * INPUTS:
2700 *
2701 * OUTPUT:
2702 *
2703 * RETURNS: OK, NOK
2704 *
2705 * NOTES:
2706 ****************************************************************************/
whal_HwCtrl_resetMacRx(HwCtrl_T * pHwCtrl)2707 int whal_HwCtrl_resetMacRx(HwCtrl_T *pHwCtrl)
2708 {
2709 return whal_hwMboxCmd_RxReset(pHwCtrl->pHwMboxCmd);
2710 }
2711
2712 /****************************************************************************
2713 * whal_HwCtrl_LNAControl()
2714 ****************************************************************************
2715 * DESCRIPTION: Control the LNA (On <-> Off)
2716 *
2717 * INPUTS:
2718 *
2719 * OUTPUT:
2720 *
2721 * RETURNS: OK, NOK
2722 *
2723 * NOTES:
2724 ****************************************************************************/
whal_HwCtrl_LNAControl(HwCtrl_T * pHwCtrl,UINT8 LNAControlField)2725 int whal_HwCtrl_LNAControl(HwCtrl_T *pHwCtrl, UINT8 LNAControlField)
2726 {
2727 return whal_hwMboxCmd_LNAControl(pHwCtrl->pHwMboxCmd, LNAControlField);
2728 }
2729
2730 /****************************************************************************
2731 * whal_hwCtrl_SwitchChannelCmd()
2732 ****************************************************************************
2733 * DESCRIPTION: Send Switch Channel command
2734 *
2735 * INPUTS: None
2736 *
2737 * OUTPUT: None
2738 *
2739 * RETURNS: OK or NOK
2740 ****************************************************************************/
whal_hwCtrl_SwitchChannelCmd(HwCtrl_T * pHwCtrl,whalCtrl_switchChannelCmd_t * pSwitchChannelCmd)2741 int whal_hwCtrl_SwitchChannelCmd (HwCtrl_T *pHwCtrl, whalCtrl_switchChannelCmd_t* pSwitchChannelCmd)
2742 {
2743 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2744 ("whal_hwCtrl_SwitchChannelCmd\n"));
2745 return (whal_hwMboxCmd_SwitchChannelCmd (pHwCtrl->pHwMboxCmd, pSwitchChannelCmd));
2746 }
2747
2748 /****************************************************************************
2749 * whal_hwCtrl_SwitchChannelCmd()
2750 ****************************************************************************
2751 * DESCRIPTION: Send Switch Channel command
2752 *
2753 * INPUTS: None
2754 *
2755 * OUTPUT: None
2756 *
2757 * RETURNS: OK or NOK
2758 ****************************************************************************/
whal_hwCtrl_SwitchChannelCancelCmd(HwCtrl_T * pHwCtrl)2759 int whal_hwCtrl_SwitchChannelCancelCmd (HwCtrl_T *pHwCtrl)
2760 {
2761 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2762 ("whal_hwCtrl_SwitchChannelCmd\n"));
2763 return (whal_hwMboxCmd_SwitchChannelCancelCmd (pHwCtrl->pHwMboxCmd));
2764 }
2765
2766
2767 /*----------------------------------------*/
2768 /* Roaming Trigger Configuration Commands */
2769 /*----------------------------------------*/
2770
2771 /****************************************************************************
2772 * whal_hwCtrl_SetSNRParameters()
2773 ****************************************************************************
2774 * DESCRIPTION: Set SNR parameters.
2775 *
2776 * INPUTS:
2777 *
2778 * OUTPUT: None
2779 *
2780 * RETURNS: None
2781 ****************************************************************************/
whal_hwCtrl_SetSNRParams(HwCtrl_T * pHwCtrl,whalCtrl_roamingTriggerCmd_t * pRoamingTriggerCmd)2782 int whal_hwCtrl_SetSNRParams(HwCtrl_T *pHwCtrl, whalCtrl_roamingTriggerCmd_t* pRoamingTriggerCmd)
2783 {
2784 ACXLowSNRTriggerParameters_t AcxElm_LowThresholdOptions;
2785 AcxElm_LowThresholdOptions.SNRThreshold = pRoamingTriggerCmd->snrThreshold ;
2786 AcxElm_LowThresholdOptions.SNRFilterWeight = pRoamingTriggerCmd->snrFilterWeight ;
2787 AcxElm_LowThresholdOptions.SNRFilterDepth = pRoamingTriggerCmd->snrFilterDepth ;
2788 AcxElm_LowThresholdOptions.LowSNREventType = pRoamingTriggerCmd->lowSNREventType;
2789
2790
2791 return whal_hwInfoElemAcxLowSNRThresholdSet (pHwCtrl->pHwMboxConfig, &AcxElm_LowThresholdOptions);
2792 }
2793
2794 /****************************************************************************
2795 * whal_hwCtrl_SetRSSIParameters()
2796 ****************************************************************************
2797 * DESCRIPTION: Set RSSI parameters used by the TNET for its calulation
2798 * that is used for generating of RSSI cross threshold interrupts.
2799 *
2800 * INPUTS:
2801 *
2802 * OUTPUT: None
2803 *
2804 * RETURNS: None
2805 ****************************************************************************/
whal_hwCtrl_SetRSSIParams(HwCtrl_T * pHwCtrl,whalCtrl_roamingTriggerCmd_t * pRoamingTriggerCmd)2806 int whal_hwCtrl_SetRSSIParams(HwCtrl_T *pHwCtrl, whalCtrl_roamingTriggerCmd_t* pRoamingTriggerCmd)
2807 {
2808 ACXLowRSSITriggerParameters_t AcxElm_LowRSSIThresholdOptions;
2809 ACXLowRSSITriggerParameters_t *pCfg = &AcxElm_LowRSSIThresholdOptions;
2810
2811 pCfg->rssiFilterDepth = pRoamingTriggerCmd->rssiFilterDepth;
2812 pCfg->rssiFilterWeight = pRoamingTriggerCmd->rssiFilterWeight;
2813 pCfg->rssiThreshold = pRoamingTriggerCmd->rssiThreshold;
2814 pCfg->LowRSSIEventType = pRoamingTriggerCmd->lowRSSIEventType;
2815
2816 return whal_hwInfoElemAcxLowRSSIThresholdSet (pHwCtrl->pHwMboxConfig, pCfg);
2817 }
2818
2819 /****************************************************************************
2820 * whal_hwCtrl_SetMaxTxRetryParameters()
2821 ****************************************************************************
2822 * DESCRIPTION: Set Max Tx retry parmaters.
2823 *
2824 * INPUTS:
2825 * maxTxRetry max Tx Retry
2826 *
2827 * OUTPUT: None
2828 *
2829 * RETURNS: None
2830 ****************************************************************************/
whal_hwCtrl_SetMaxTxRetryParams(HwCtrl_T * pHwCtrl,whalCtrl_roamingTriggerCmd_t * pRoamingTriggerCmd)2831 int whal_hwCtrl_SetMaxTxRetryParams(HwCtrl_T *pHwCtrl, whalCtrl_roamingTriggerCmd_t* pRoamingTriggerCmd)
2832 {
2833 ACXConsTxFailureTriggerParameters_t AcxElm_MaxTxRetry;
2834 ACXConsTxFailureTriggerParameters_t *pCfg = &AcxElm_MaxTxRetry;
2835
2836 pCfg->maxTxRetry = pRoamingTriggerCmd->maxTxRetry;
2837
2838 return whal_hwInfoElemAcxSetMaxTxRetrySet (pHwCtrl->pHwMboxConfig, pCfg);
2839 }
2840
2841
2842 /****************************************************************************
2843 * whal_hwCtrl_GetAsynRSSI ()
2844 ****************************************************************************
2845 * DESCRIPTION: Get the Average RSSI
2846 *
2847 * INPUTS:
2848 *
2849 * OUTPUT:
2850 *
2851 * RETURNS: OK or NOK
2852 ****************************************************************************/
whal_hwCtrl_GetAsynRSSI(HwCtrl_T * pHwCtrl,void * CB_Func,TI_HANDLE CB_handle,PUINT8 CB_Buf)2853 int whal_hwCtrl_GetAsynRSSI (HwCtrl_T *pHwCtrl,void *CB_Func, TI_HANDLE CB_handle, PUINT8 CB_Buf)
2854 {
2855 int Stt;
2856
2857 Stt = whal_hwInfoElemRSSIGet (pHwCtrl->pHwMboxConfig, CB_Func, CB_handle, CB_Buf);
2858
2859 return Stt;
2860 }
2861
2862
2863
2864 /****************************************************************************
2865 * whal_hwCtrl_SetBssLossTsfThresholdParams()
2866 ****************************************************************************
2867 * DESCRIPTION:
2868 *
2869 *
2870 *
2871 * INPUTS:
2872 *
2873 * OUTPUT: None
2874 *
2875 * RETURNS: None
2876 ****************************************************************************/
whal_hwCtrl_SetBssLossTsfThresholdParams(HwCtrl_T * pHwCtrl,whalCtrl_roamingTriggerCmd_t * pRoamingTriggerCmd)2877 int whal_hwCtrl_SetBssLossTsfThresholdParams( HwCtrl_T *pHwCtrl,whalCtrl_roamingTriggerCmd_t* pRoamingTriggerCmd)
2878 {
2879 AcxConnectionMonitorOptions AcxElm_BssLossTsfSynchronize;
2880 AcxConnectionMonitorOptions *pCfg = &AcxElm_BssLossTsfSynchronize;
2881
2882 pCfg->BSSLossTimeout = pRoamingTriggerCmd->BssLossTimeout;
2883 pCfg->TSFMissedThreshold = pRoamingTriggerCmd->TsfMissThreshold;
2884
2885 return whal_hwInfoElemAcxBssLossTsfThresholdSet (pHwCtrl->pHwMboxConfig, pCfg);
2886 }
2887
2888 /****************************************************************************
2889 * whal_hwCtrl_FwDisconnect()
2890 ****************************************************************************
2891 * DESCRIPTION: Disconnect.
2892 *
2893 * INPUTS: None
2894 *
2895 * OUTPUT: None
2896 *
2897 * RETURNS: OK or NOK
2898 ****************************************************************************/
whal_hwCtrl_FwDisconnect(HwCtrl_T * pHwCtrl,uint32 ConfigOptions,uint32 FilterOptions)2899 int whal_hwCtrl_FwDisconnect(HwCtrl_T *pHwCtrl, uint32 ConfigOptions, uint32 FilterOptions)
2900 {
2901 HwMboxCmd_T *pHwMboxCmd = pHwCtrl->pHwMboxCmd;
2902
2903 return whal_hwMboxCmd_FwDisconnect(pHwMboxCmd, ConfigOptions, FilterOptions);
2904
2905 } /* whal_hwCtrl_FwDisconnect()*/
2906
2907
2908
2909
2910 /****************************************************************************
2911 * whal_hwCtrl_measurementParams()
2912 ****************************************************************************
2913 * DESCRIPTION: send Command for measurement configuration
2914 * to the mailbox
2915 *
2916 * INPUTS: None
2917 *
2918 * OUTPUT: None
2919 *
2920 * RETURNS: OK or NOK
2921 ****************************************************************************/
whal_hwCtrl_measurement(HwCtrl_T * pHwCtrl,whalCtrl_MeasurementParameters_t * pMeasurementParams,void * MeasureCommandResponseCB,TI_HANDLE CB_handle)2922 int whal_hwCtrl_measurement (HwCtrl_T *pHwCtrl, whalCtrl_MeasurementParameters_t* pMeasurementParams,
2923 void* MeasureCommandResponseCB, TI_HANDLE CB_handle)
2924 {
2925 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2926 ("whal_hwCtrl_measurementParams\n"));
2927 return whal_hwMboxCmd_measurement (pHwCtrl->pHwMboxCmd, pMeasurementParams,
2928 MeasureCommandResponseCB, CB_handle);
2929 }
2930
2931
2932 /****************************************************************************
2933 * whal_hwCtrl_measurementStop()
2934 ****************************************************************************
2935 * DESCRIPTION: send Command for stoping measurement
2936 *
2937 * INPUTS: None
2938 *
2939 * OUTPUT: None
2940 *
2941 * RETURNS: OK or NOK
2942 ****************************************************************************/
whal_hwCtrl_measurementStop(HwCtrl_T * pHwCtrl,void * MeasureCommandResponseCB,TI_HANDLE CB_handle)2943 int whal_hwCtrl_measurementStop (HwCtrl_T *pHwCtrl, void* MeasureCommandResponseCB, TI_HANDLE CB_handle)
2944 {
2945 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2946 ("whal_hwCtrl_measurementStop\n"));
2947
2948 return whal_hwMboxCmd_measurementStop (pHwCtrl->pHwMboxCmd, MeasureCommandResponseCB, CB_handle);
2949 }
2950
2951 /****************************************************************************
2952 * whal_hwCtrl_ApDiscovery()
2953 ****************************************************************************
2954 * DESCRIPTION: send Command for AP Discovery
2955 * to the mailbox
2956 *
2957 * INPUTS: None
2958 *
2959 * OUTPUT: None
2960 *
2961 * RETURNS: OK or NOK
2962 ****************************************************************************/
whal_hwCtrl_ApDiscovery(HwCtrl_T * pHwCtrl,whalCtrl_ApDiscoveryParameters_t * pApDiscoveryParams)2963 int whal_hwCtrl_ApDiscovery (HwCtrl_T *pHwCtrl, whalCtrl_ApDiscoveryParameters_t* pApDiscoveryParams)
2964
2965 {
2966 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2967 ("whal_hwCtrl_ApDiscovery\n"));
2968
2969 return( whal_hwMboxCmd_ApDiscovery (pHwCtrl->pHwMboxCmd, pApDiscoveryParams));
2970
2971 }
2972 /****************************************************************************
2973 * whal_hwCtrl_ApDiscoveryStop()
2974 ****************************************************************************
2975 * DESCRIPTION: send Command for stoping AP Discovery
2976 *
2977 * INPUTS: None
2978 *
2979 * OUTPUT: None
2980 *
2981 * RETURNS: OK or NOK
2982 ****************************************************************************/
whal_hwCtrl_ApDiscoveryStop(HwCtrl_T * pHwCtrl)2983 int whal_hwCtrl_ApDiscoveryStop (HwCtrl_T *pHwCtrl)
2984
2985
2986 {
2987 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
2988 ("whal_hwCtrl_ApDiscoveryStop\n"));
2989
2990 return(whal_hwMboxCmd_ApDiscoveryStop (pHwCtrl->pHwMboxCmd));
2991 }
2992
2993 /****************************************************************************
2994 * whal_hwCtrl_healthCheck()
2995 ****************************************************************************
2996 * DESCRIPTION:
2997 *
2998 * INPUTS:
2999 *
3000 * OUTPUT:
3001 *
3002 * RETURNS:
3003 ****************************************************************************/
whal_hwCtrl_healthCheck(HwCtrl_T * pHwCtrl)3004 int whal_hwCtrl_healthCheck (HwCtrl_T *pHwCtrl)
3005 {
3006 WLAN_REPORT_INFORMATION(pHwCtrl->hReport, HAL_HW_CTRL_MODULE_LOG,
3007 ("whal_hwMboxCmd_HealthCheck\n"));
3008
3009 return(whal_hwMboxCmd_HealthCheck(pHwCtrl->pHwMboxCmd));
3010 }
3011
3012
3013 /****************************************************************************
3014 * whal_hwCtrl_SoftGeminiEnable()
3015 ****************************************************************************
3016 * DESCRIPTION: Save Soft Gemini enable parameter
3017 *
3018 * INPUTS:
3019 *
3020 * OUTPUT:
3021 *
3022 * RETURNS: OK or NOK
3023 ****************************************************************************/
whal_hwCtrl_SoftGeminiEnable(HwCtrl_T * pHwCtrl,SoftGeminiEnableModes_e SgEnable)3024 int whal_hwCtrl_SoftGeminiEnable (HwCtrl_T *pHwCtrl,
3025 SoftGeminiEnableModes_e SgEnable )
3026 {
3027 /* copy params for recovery */
3028 pHwCtrl->pWhalParams->WlanParams.SoftGeminiEnable = SgEnable;
3029
3030 return whal_hwInfoElemSoftGeminiEnableSet (pHwCtrl->pHwMboxConfig, SgEnable);
3031 }
3032
3033 /****************************************************************************
3034 * whal_hwCtrl_SetSoftGeminiParams()
3035 ****************************************************************************
3036 * DESCRIPTION: Save Soft Gemini config parameter
3037 *
3038 * INPUTS:
3039 *
3040 * OUTPUT:
3041 *
3042 * RETURNS: OK or NOK
3043 ****************************************************************************/
whal_hwCtrl_SetSoftGeminiParams(HwCtrl_T * pHwCtrl,SoftGeminiParam_t * SgParam)3044 int whal_hwCtrl_SetSoftGeminiParams (HwCtrl_T *pHwCtrl,
3045 SoftGeminiParam_t *SgParam )
3046 {
3047 /* copy params for recovery */
3048 os_memoryCopy(pHwCtrl->hOs,(void*)&pHwCtrl->pWhalParams->WlanParams.SoftGeminiParams,
3049 (void*)SgParam,sizeof(SoftGeminiParam_t));
3050
3051 return whal_hwInfoElemSoftGeminiParamsSet (pHwCtrl->pHwMboxConfig,SgParam);
3052 }
3053
3054 /****************************************************************************
3055 * whal_hwCtrl_GetSoftGeminiParams()
3056 ****************************************************************************
3057 * DESCRIPTION: Get Soft Gemini config parameter
3058 *
3059 * INPUTS:
3060 *
3061 * OUTPUT:
3062 *
3063 * RETURNS: OK or NOK
3064 ****************************************************************************/
whal_hwCtrl_GetSoftGeminiParams(HwCtrl_T * pHwCtrl,void * CB_Func,TI_HANDLE CB_handle,void * CB_Buf)3065 int whal_hwCtrl_GetSoftGeminiParams (HwCtrl_T *pHwCtrl, void *CB_Func, TI_HANDLE CB_handle, void* CB_Buf)
3066 {
3067 return whal_hwInfoElemSoftGeminiParamsGet (pHwCtrl->pHwMboxConfig, CB_Func, CB_handle, CB_Buf);
3068 }
3069 /****************************************************************************
3070 * whal_hwCtrl_GxRatePolicy()
3071 ****************************************************************************
3072 * DESCRIPTION: Get TxRatePolicy params
3073 *
3074 * INPUTS: None
3075 *
3076 * OUTPUT: None
3077 *
3078 * RETURNS: txRatePolicy_t* - the TX rate policy
3079 ****************************************************************************/
3080
whal_hwCtrl_GetTxRatePolicy(TI_HANDLE hHwCtrl)3081 txRatePolicy_t* whal_hwCtrl_GetTxRatePolicy(TI_HANDLE hHwCtrl)
3082 {
3083 HwCtrl_T *pHwCtrl = (HwCtrl_T*)hHwCtrl;
3084 return whal_ParamsGetTxRateClassParams(pHwCtrl->pWhalParams);
3085 }
3086
3087
3088 /****************************************************************************
3089 * whal_hwCtrl_TxRatePolicy()
3090 ****************************************************************************
3091 * DESCRIPTION: configure TxRatePolicy params
3092 *
3093 * INPUTS: None
3094 *
3095 * OUTPUT: None
3096 *
3097 * RETURNS: OK or NOK
3098 ****************************************************************************/
3099
whal_hwCtrl_TxRatePolicy(TI_HANDLE hHwCtrl,txRatePolicy_t * pTxRatePolicy)3100 int whal_hwCtrl_TxRatePolicy(TI_HANDLE hHwCtrl,txRatePolicy_t *pTxRatePolicy)
3101 {
3102 TI_STATUS status = NOK;
3103 HwCtrl_T *pHwCtrl = (HwCtrl_T*)hHwCtrl;
3104
3105 UINT8 index;
3106 txRateClass_t *pTxRateClass = pTxRatePolicy->rateClass;
3107
3108 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,
3109 ("%s_1, Num of classes = 0x%x\n",__FUNCTION__, pTxRatePolicy->numOfRateClasses));
3110
3111 for(index = 0; index < pTxRatePolicy->numOfRateClasses; index++, pTxRateClass++)
3112 {
3113 WLAN_REPORT_DEBUG_CONTROL(pHwCtrl->hReport,
3114 ("%s_2loop, Index = %d, Short R = 0x%x, Long R = 0x%x, Flags = 0x%x Rates(HexDump) = \n",
3115 __FUNCTION__, index,
3116 pTxRateClass->shortRetryLimit, pTxRateClass->longRetryLimit, pTxRateClass->flags));
3117
3118 WLAN_REPORT_HEX_INFORMATION(pHwCtrl->hReport,
3119 HAL_HW_CTRL_MODULE_LOG,
3120 (PUINT8)pTxRateClass->txRate, sizeof(pTxRateClass->txRate));
3121 }
3122
3123 /* Setting Rate Policy configuration into the HW */
3124 status = (TI_STATUS)whal_hwInfoElemTxRatePolicyConfigurationSet (pHwCtrl->pHwMboxConfig, pTxRatePolicy);
3125
3126 /* Set the Policy param object database fields according to the succeeded configuration (for recovery) */
3127 if (status == OK)
3128 {
3129 whal_ParamsSetTxRateClassParams(pHwCtrl->pWhalParams,(txRatePolicy_t *)pTxRatePolicy);
3130 }
3131
3132 return status;
3133 }
3134
3135
3136 /****************************************************************************
3137 * whal_hwCtrl_ReJoinBss()
3138 ****************************************************************************
3139 * DESCRIPTION:
3140 *
3141 * INPUTS: None
3142 *
3143 * OUTPUT: None
3144 *
3145 * RETURNS: OK or NOK
3146 ****************************************************************************/
whal_hwCtrl_ReJoinBss(TI_HANDLE hHwCtrl)3147 int whal_hwCtrl_ReJoinBss (TI_HANDLE hHwCtrl)
3148 {
3149 HwCtrl_T *pHwCtrl = (HwCtrl_T*)hHwCtrl;
3150 BssInfoParams_T *pBssInfoParams = &pHwCtrl->pWhalParams->BssInfoParams;
3151 TemplateListParams_T *pWhalTemplates = &pHwCtrl->pWhalParams->TemplateList;
3152 HwMboxCmd_T *pHwCmd = whal_hwCtrl_GetMboxCmd (pHwCtrl);
3153
3154 /*
3155 * Set the templates
3156 */
3157 if (pWhalTemplates->Beacon.Size != 0)
3158 whal_hwMboxCmd_ConfigureTemplateFrame (pHwCmd,
3159 pWhalTemplates->Beacon.Buffer,
3160 (UINT16)pWhalTemplates->Beacon.Size,
3161 CMD_BEACON,
3162 NULL,
3163 NULL);
3164
3165 if (pWhalTemplates->ProbeResp.Size != 0)
3166 whal_hwMboxCmd_ConfigureTemplateFrame (pHwCmd,
3167 pWhalTemplates->ProbeResp.Buffer,
3168 (UINT16)pWhalTemplates->ProbeResp.Size,
3169 CMD_PROBE_RESP,
3170 NULL,
3171 NULL);
3172
3173 if (pWhalTemplates->ProbeReq.Size != 0)
3174 whal_hwMboxCmd_ConfigureTemplateFrame (pHwCmd,
3175 pWhalTemplates->ProbeReq.Buffer,
3176 (UINT16)pWhalTemplates->ProbeReq.Size,
3177 CMD_PROBE_REQ,
3178 NULL,
3179 NULL);
3180
3181 if (pWhalTemplates->NullData.Size != 0)
3182 whal_hwMboxCmd_ConfigureTemplateFrame (pHwCmd,
3183 pWhalTemplates->NullData.Buffer,
3184 (UINT16)pWhalTemplates->NullData.Size,
3185 CMD_NULL_DATA,
3186 NULL,
3187 NULL);
3188
3189 if (pWhalTemplates->PsPoll.Size != 0)
3190 whal_hwMboxCmd_ConfigureTemplateFrame (pHwCmd,
3191 pWhalTemplates->PsPoll.Buffer,
3192 (UINT16)pWhalTemplates->PsPoll.Size,
3193 CMD_PS_POLL,
3194 NULL,
3195 NULL);
3196
3197 /*
3198 * Call the hardware to start/join the BSS
3199 */
3200 return whal_hwCtrl_StartJoin (pHwCtrl, (bssType_e)pBssInfoParams->ReqBssType, NULL, NULL);
3201 }
3202
3203 /****************************************************************************
3204 * whal_hwCtrl_setBetParams()
3205 ****************************************************************************
3206 * DESCRIPTION: Configures Beacon Early Termination information element.
3207 *
3208 * Input : enabled - 0 to disable BET, 0 to disable BET
3209 * MaximumConsecutiveET - Max number of consecutive beacons
3210 * that may be early terminated.
3211 * OUTPUT: None
3212 *
3213 * RETURNS: OK or NOK
3214 ****************************************************************************/
whal_hwCtrl_setBetParams(HwCtrl_T * pHwCtrl,UINT8 Enable,UINT8 MaximumConsecutiveET)3215 int whal_hwCtrl_setBetParams(HwCtrl_T * pHwCtrl, UINT8 Enable, UINT8 MaximumConsecutiveET)
3216 {
3217 return whal_hwInfoElemBETSet(pHwCtrl->pHwMboxConfig, Enable, MaximumConsecutiveET);
3218 }
3219
3220
3221