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: whalParams.c
39 * PURPOSE: Holds all the whal parameters
40 *
41 ****************************************************************************/
42
43 #include "whalCommon.h"
44 #include "whalHwDefs.h"
45 #include "802_11Defs.h"
46 #include "whalParams.h"
47 #include "whalBus_Api.h"
48
49 /******************************* definitions ********************************/
50 #define HW_MODULATION_PBCC 0x80
51 #define HW_MODULATION_OFDM 0x40
52
53 /*
54 * Internals
55 */
56 void whal_ParamsInitDmaParams (WhalParams_T *pWhalParams);
57 int whal_ParamsInitWlanParams (WhalParams_T *pWhalParams);
58 int whal_ParamsInitBssInfoParams(WhalParams_T *pWhalParams, BOOL TxFlashEnable);
59 int whal_ParamsInitGenParams (WhalParams_T *pWhalParams);
60 int whal_ParamsInitHwInfoParams (WhalParams_T *pWhalParams);
61 int whal_ParamsInitGenCounters (WhalParams_T *pWhalParams);
62 void whal_ParamsSetQidToAcTable (WhalParams_T *pWhalParams,UINT8 Qid,UINT8 AcId);
63
64 /****************************************************************************
65 * whal_params_Create()
66 ****************************************************************************
67 * DESCRIPTION: Create the whal parameters(data base) object
68 *
69 * INPUTS:
70 *
71 * OUTPUT: None
72 *
73 * RETURNS: The Created object
74 ****************************************************************************/
whal_params_Create(TI_HANDLE hOs,BOOL TxFlashEnable)75 WhalParams_T *whal_params_Create(TI_HANDLE hOs, BOOL TxFlashEnable)
76 {
77 WhalParams_T *pObj;
78
79 pObj = os_memoryAlloc(hOs, sizeof(WhalParams_T));
80 if (pObj == NULL)
81 return NULL;
82
83 os_memoryZero(hOs, (void *)pObj, sizeof(WhalParams_T));
84
85 pObj->hOs = hOs;
86
87 whal_ParamsInitDmaParams(pObj);
88 whal_ParamsInitGenParams(pObj);
89 whal_ParamsInitBssInfoParams(pObj,TxFlashEnable);
90 whal_ParamsInitWlanParams(pObj);
91 whal_ParamsInitGenCounters(pObj);
92
93 return(pObj);
94 }
95
96 /****************************************************************************
97 * whal_params_Destroy()
98 ****************************************************************************
99 * DESCRIPTION: Destroy the object
100 *
101 * INPUTS:
102 * WhalParams_T The object to free
103 *
104 * OUTPUT: None
105 *
106 * RETURNS: OK or NOK
107 ****************************************************************************/
whal_params_Destroy(WhalParams_T * pWhalParams)108 int whal_params_Destroy(WhalParams_T *pWhalParams)
109 {
110 if (pWhalParams)
111 os_memoryFree(pWhalParams->hOs, pWhalParams, sizeof(WhalParams_T));
112 return OK;
113 }
114
115 /****************************************************************************
116 * whal_params_Config()
117 ****************************************************************************
118 * DESCRIPTION: Config the object
119 *
120 * INPUTS:
121 * pWhalParams The object
122 * hReport The reports objects
123 *
124 * OUTPUT: None
125 *
126 * RETURNS: OK or NOK
127 ****************************************************************************/
whal_params_Config(WhalParams_T * pWhalParams,TI_HANDLE hReport)128 int whal_params_Config(WhalParams_T *pWhalParams, TI_HANDLE hReport)
129 {
130 pWhalParams->hReport = hReport;
131 return OK;
132 }
133
134 /*
135 * --------------------------------------------------------------------------
136 * DmaParams_T - Rx/Tx Queues and Bufs params
137 * --------------------------------------------------------------------------
138 */
139 /* defaults for large queue size */
140 #define DEFAULT_UCAST_PRIORITY 0
141 #define DEFAULT_RX_Q_PRIORITY 0
142
143 #define DEFAULT_NUM_STATIONS 1
144 #define DEFAULT_RXQ_PRIORITY 0 /* low 0 .. 15 high */
145 #define DEFAULT_RXQ_TYPE 0x07 /* All frames, Data/Ctrl/Mgmt -- not documented well */
146
147 /* only for AP */
148 #define DEFAULT_NUM_BCAST_TX_DESC 16 /* 8 increase number of BC frames */
149 #define DEFAULT_BCAST_PRIORITY 0x81
150
151 /****************************************************************************
152 * whal_ParamsInitDmaParams()
153 ****************************************************************************
154 * DESCRIPTION: Initiate DmaParams to the default values
155 *
156 * INPUTS:
157 *
158 * OUTPUT: None
159 *
160 * RETURNS: OK or NOK
161 ****************************************************************************/
whal_ParamsInitDmaParams(WhalParams_T * pWhalParams)162 void whal_ParamsInitDmaParams(WhalParams_T *pWhalParams)
163 {
164 }
165
166 /****************************************************************************
167 * whal_ParamsGetDmaParams()
168 ****************************************************************************
169 * DESCRIPTION: return DmaParams pointer
170 ****************************************************************************/
whal_ParamsGetDmaParams(WhalParams_T * pWhalParams)171 DmaParams_T *whal_ParamsGetDmaParams(WhalParams_T *pWhalParams)
172 {
173 return (&pWhalParams->DmaParams);
174 }
175
176 /****************************************************************************
177 * whal_ParamsSetDmaParams()
178 ****************************************************************************
179 * DESCRIPTION: set new DmaParams
180 ****************************************************************************/
whal_ParamsSetDmaParams(WhalParams_T * pWhalParams)181 int whal_ParamsSetDmaParams(WhalParams_T *pWhalParams)
182 {
183 DmaParams_T *pDmaParams = whal_ParamsGetDmaParams(pWhalParams);
184 int i;
185
186 /* Initialize the Params object database fields*/
187 pDmaParams->rxMemBlkNumber = 35; /*pInitParams->rxMemBlkNumber;*/
188 pDmaParams->txMinMemBlkNumber = 64; /*pInitParams->txMinMemBlkNumber;*/
189 pDmaParams->BlockSize = HAL_CTRL_ACX_BLOCK_SIZE_DEF; /*pInitParams->blockSize;*/
190 pDmaParams->NumRxQueues = 1;
191 pDmaParams->NumTxQueues = MAX_NUM_OF_TX_QUEUES; /*pInitParams->numTxQueues;*/
192 pDmaParams->RxNumDesc = HAL_CTRL_ACX_RX_DESC_DEF; /*pInitParams->rxDescNum;*/
193 /* TRACE_BUFFER_MAX_SIZE is UINT32 so multiply by 4 to have the actual length */
194 pDmaParams->TraceBufferSize = (TRACE_BUFFER_MAX_SIZE * 4); /*pInitParams->TraceBufferSize;*/
195 pDmaParams->TraceBufferDoPrint = FALSE; /*pInitParams->bDoPrint;*/
196
197 if ((pDmaParams->NumTxQueues > MAX_NUM_OF_TX_QUEUES) || (pDmaParams->NumTxQueues < 1) )
198 {
199 WLAN_REPORT_REPLY(pWhalParams->hReport, HAL_HW_CTRL_MODULE_LOG,
200 ("\nwhal_ParamsSetDmaParams: numTxQueues is invalid, setting it to 1. numTxQueues=%d\n",pDmaParams->NumTxQueues ));
201 pDmaParams->NumTxQueues = 1;
202 }
203
204 for (i=0;i<pDmaParams->NumTxQueues;i++)
205 {
206 pDmaParams->TxNumDesc[i] = HAL_CTRL_ACX_TX_DESC_DEF; /*pInitParams->tx_attrib_queue[i].numDesc;*/
207 pDmaParams->TxQPriority[i] = i; /*pInitParams->tx_attrib_queue[i].priority; */
208 }
209
210 /* default values */
211 pDmaParams->RxQPriority = DEFAULT_RX_Q_PRIORITY;
212 pDmaParams->NumStations = DEFAULT_NUM_STATIONS;
213 pDmaParams->RxQueue_Priority = DEFAULT_RXQ_PRIORITY;
214 pDmaParams->RxQueue_Type = DEFAULT_RXQ_TYPE;
215
216 /* only for AP */
217 #ifdef CONFIGURE_BSS_TYPE_AP
218 pDmaParams->NumTxQueues = 2;
219 pDmaParams->TxNumDesc[1] = DEFAULT_NUM_BCAST_TX_DESC;
220 pDmaParams->TxQPriority[1] = DEFAULT_BCAST_PRIORITY;
221 #endif
222
223 return OK;
224 }
225
226 /****************************************************************************
227 * whal_ParamsSetRoamingParams()
228 ****************************************************************************
229 * DESCRIPTION: set new DmaParams
230 ****************************************************************************/
whal_ParamsSetRoamingParams(WhalParams_T * pWhalParams)231 int whal_ParamsSetRoamingParams(WhalParams_T *pWhalParams)
232 {
233
234 pWhalParams->WlanParams.roamTriggers.rssiThreshold = RSSI_DEFAULT_THRESHOLD;
235 pWhalParams->WlanParams.roamTriggers.rssiFilterWeight = RSSI_DEFAULT_WEIGHT;
236 pWhalParams->WlanParams.roamTriggers.rssiFilterDepth = RSSI_DEFAULT_DEPTH;
237 pWhalParams->WlanParams.roamTriggers.lowRSSIEventType = LOW_RSSI_EVENT_LEVEL;
238
239 pWhalParams->WlanParams.roamTriggers.snrThreshold = SNR_DEFAULT_THRESHOLD;
240 pWhalParams->WlanParams.roamTriggers.snrFilterWeight = SNR_DEFAULT_WEIGHT;
241 pWhalParams->WlanParams.roamTriggers.snrFilterDepth = SNR_DEFAULT_DEPTH;
242 pWhalParams->WlanParams.roamTriggers.lowSNREventType = LOW_SNR_EVENT_LEVEL;
243
244 pWhalParams->WlanParams.roamTriggers.BssLossTimeout = NO_BEACON_DEFAULT_TIMEOUT;
245 pWhalParams->WlanParams.roamTriggers.TsfMissThreshold = OUT_OF_SYNC_DEFAULT_THRESHOLD;
246
247 return OK;
248 }
249
250
251 /****************************************************************************
252 * whal_ParamsSetQueueParams()
253 ****************************************************************************
254 * DESCRIPTION: set new QueueParams
255 ****************************************************************************/
whal_ParamsSetQueueParams(WhalParams_T * pWhalParams,queueTrafficParams_t * pQtrafficParams)256 int whal_ParamsSetQueueParams(WhalParams_T *pWhalParams,queueTrafficParams_t *pQtrafficParams)
257 {
258 pWhalParams->QueuesParams.isQueueConfigured[pQtrafficParams->queueID] = TRUE;
259 os_memoryCopy(pWhalParams->hOs,(void *)&(pWhalParams->QueuesParams.queues[pQtrafficParams->queueID]),(void *)pQtrafficParams,sizeof(queueTrafficParams_t));
260
261 return OK;
262 }
263 /****************************************************************************
264 * whal_ParamsSetAcParams()
265 ****************************************************************************
266 * DESCRIPTION: set new QueueParams
267 ****************************************************************************/
268
whal_ParamsSetAcParams(WhalParams_T * pWhalParams,acQosParams_t * pAcQosParams)269 void whal_ParamsSetAcParams(WhalParams_T *pWhalParams,acQosParams_t *pAcQosParams)
270 {
271 pWhalParams->AcParams.isAcConfigured[pAcQosParams->ac] = TRUE;
272 os_memoryCopy(pWhalParams->hOs,(void *)&(pWhalParams->AcParams.ac[pAcQosParams->ac]),(void *)pAcQosParams,sizeof(acQosParams_t));
273 }
274
275 /****************************************************************************
276 * whal_ParamsGetTxParams()
277 ****************************************************************************
278 * DESCRIPTION: set new DmaParams
279 ****************************************************************************/
whal_ParamsGetTxParams(WhalParams_T * pWhalParams)280 TxParam_t *whal_ParamsGetTxParams (WhalParams_T *pWhalParams)
281 {
282 return (&pWhalParams->TxParams);
283 }
284
285 /****************************************************************************
286 * whal_ParamsSetTrafficParams()
287 ****************************************************************************
288 * DESCRIPTION: Traffic Parameters :(IE ACX_TID_CFG)
289 ****************************************************************************/
whal_ParamsSetTrafficParams(WhalParams_T * pWhalParams,whaCtrl_acTrafficParams_t * pTconfParams)290 int whal_ParamsSetTrafficParams(WhalParams_T *pWhalParams,whaCtrl_acTrafficParams_t* pTconfParams)
291 {
292 os_memoryCopy(pWhalParams->hOs,
293 (void *)&(pWhalParams->TxParams.halTrafficParams[pTconfParams->acId]),
294 (void *)pTconfParams,sizeof(whaCtrl_acTrafficParams_t));
295
296 return OK;
297 }
298
299 /****************************************************************************
300 * whal_ParamsSetTxRateClassParams()
301 ****************************************************************************
302 * DESCRIPTION: set new TxRateParams
303 ****************************************************************************/
whal_ParamsSetTxRateClassParams(WhalParams_T * pWhalParams,txRatePolicy_t * pTxRatePolicy)304 void whal_ParamsSetTxRateClassParams(WhalParams_T *pWhalParams,txRatePolicy_t *pTxRatePolicy)
305 {
306 UINT8 i;
307 txRateClass_t *pTxRateClass;
308
309 for(i = 0; i < pTxRatePolicy->numOfRateClasses; i++)
310 {
311 pTxRateClass = &pTxRatePolicy->rateClass[i];
312 os_memoryCopy(pWhalParams->hOs,(void *)&(pWhalParams->BssInfoParams.TxRateClassParams.rateClass[i]),(void *)pTxRateClass,sizeof(txRateClass_t));
313 }
314
315 pWhalParams->BssInfoParams.TxRateClassParams.numOfRateClasses = pTxRatePolicy->numOfRateClasses;
316
317 }
318
319 /****************************************************************************
320 * whal_ParamsSetTxRateClassParams()
321 ****************************************************************************
322 * DESCRIPTION: set new TxRateParams
323 ****************************************************************************/
whal_ParamsGetTxRateClassParams(WhalParams_T * pWhalParams)324 txRatePolicy_t* whal_ParamsGetTxRateClassParams(WhalParams_T *pWhalParams)
325 {
326 return &pWhalParams->BssInfoParams.TxRateClassParams;
327 }
328 /****************************************************************************
329 * whal_ParamsGetTxParams()
330 ****************************************************************************
331 * Traffic Parameters :(IE ACX_TID_CFG)
332 ****************************************************************************/
whal_ParamsGetTrafficParams(WhalParams_T * pWhalParams,UINT8 AcID)333 whaCtrl_acTrafficParams_t* whal_ParamsGetTrafficParams(WhalParams_T *pWhalParams,UINT8 AcID)
334 {
335 return (&pWhalParams->TxParams.halTrafficParams[AcID]);
336 }
337
338 /****************************************************************************
339 * whal_ParamsSetAccessCategoryParams()
340 ****************************************************************************
341 * DESCRIPTION: Access Category Parameters :(IE ACX_AC_CFG)
342 ****************************************************************************/
whal_ParamsSetAccessCategoryParams(WhalParams_T * pWhalParams,acQueuesParams_t * pAcQueuesParams)343 int whal_ParamsSetAccessCategoryParams(WhalParams_T *pWhalParams,acQueuesParams_t* pAcQueuesParams)
344 {
345
346 /* Calculate the Qid from the Ac and save in a local table */
347 whal_ParamsSetQidToAcTable(pWhalParams, pAcQueuesParams->qId, pAcQueuesParams->acId);
348
349 os_memoryCopy(pWhalParams->hOs,
350 (void *)&(pWhalParams->TxParams.halAcQueueParams[pAcQueuesParams->qId]),
351 (void *)pAcQueuesParams, sizeof(acQueuesParams_t));
352
353 return OK;
354 }
355
356
357 /****************************************************************************
358 * whal_ParamsSetAccessCategoryAckPolicy()
359 ****************************************************************************
360 * DESCRIPTION: set Ac Ack Policy according to Ac ID , No Ack = 0, Ack = 1
361 ****************************************************************************/
whal_ParamsSetAccessCategoryAckPolicy(WhalParams_T * pWhalParams,BOOL AckPolicy,UINT8 AcID)362 int whal_ParamsSetAccessCategoryAckPolicy(WhalParams_T *pWhalParams, BOOL AckPolicy,UINT8 AcID)
363 {
364 WLAN_REPORT_INFORMATION(pWhalParams->hReport, HAL_HW_CTRL_MODULE_LOG,
365 ("\n whal_ParamsSetAccessCategoryAckPolicy: Set Access Category =%d to Ack Policy = %d \n", AcID, AckPolicy));
366
367 pWhalParams->TxParams.AckPolicy[AcID] = AckPolicy;
368
369 return OK;
370 }
371
372
373 /****************************************************************************
374 * whal_ParamsSetQidToAcTable()
375 ****************************************************************************
376 * DESCRIPTION: set Qid according to Queue ID
377 ****************************************************************************/
whal_ParamsSetQidToAcTable(WhalParams_T * pWhalParams,UINT8 Qid,UINT8 AcId)378 void whal_ParamsSetQidToAcTable(WhalParams_T *pWhalParams,UINT8 Qid,UINT8 AcId)
379 {
380
381 pWhalParams->TxParams.QidToAcTable[Qid] = AcId;
382
383 }
384
385 /****************************************************************************
386 * whal_ParamsGetAcIdFromQid()
387 ****************************************************************************
388 * DESCRIPTION: Get the Ac Id according to the Queue id
389 ****************************************************************************/
whal_ParamsGetAcIdFromQid(WhalParams_T * pWhalParams,UINT8 Qid)390 UINT8 whal_ParamsGetAcIdFromQid(WhalParams_T *pWhalParams,UINT8 Qid)
391 {
392 return (pWhalParams->TxParams.QidToAcTable[Qid]);
393 }
394
395 /****************************************************************************
396 * whal_ParamsGetAtimWindow()
397 ****************************************************************************
398 * DESCRIPTION: return the ATim Window
399 ****************************************************************************/
whal_ParamsGetAtimWindow(WhalParams_T * pWhalParams)400 UINT16 whal_ParamsGetAtimWindow (WhalParams_T *pWhalParams)
401 {
402 return (pWhalParams->BssInfoParams.ATimWindow);
403 }
404
405 /****************************************************************************
406 * whal_ParamsSetAtimWindow()
407 ****************************************************************************
408 * DESCRIPTION: set the ATim Window
409 ****************************************************************************/
whal_ParamsSetAtimWindow(WhalParams_T * pWhalParams,UINT16 ATimWindow)410 void whal_ParamsSetAtimWindow(WhalParams_T *pWhalParams, UINT16 ATimWindow)
411 {
412 pWhalParams->BssInfoParams.ATimWindow = ATimWindow;
413 }
414
415 /*
416 * --------------------------------------------------------------------------
417 * Bss Info params
418 * --------------------------------------------------------------------------
419 */
420
421 #define DEFAULT_HW_GEN_PREAMBLE_TYPE CCK_LONG /* Long Preamble */
422 #define DEFAULT_HW_GEN_TX_RATE RATE_2MBPS
423 #define DEFAULT_HW_GEN_TX_RATE_DRIVER_FORMAT DRV_RATE_2M
424
genMacCopy(char * Mac2,char * Mac1)425 int genMacCopy(char *Mac2, char *Mac1)
426 {
427 register int MacSize=6;
428
429 while(MacSize--)
430 *Mac2++ = *Mac1++;
431 return OK;
432 }
433
434 /****************************************************************************
435 * whal_ParamsInitBssInfoParams()
436 ****************************************************************************
437 * DESCRIPTION: Initiate BssInfo to the default values
438 *
439 * INPUTS:
440 *
441 * OUTPUT: None
442 *
443 * RETURNS:
444 ****************************************************************************/
whal_ParamsInitBssInfoParams(WhalParams_T * pWhalParams,BOOL TxFlashEnable)445 int whal_ParamsInitBssInfoParams(WhalParams_T *pWhalParams, BOOL TxFlashEnable)
446 {
447 BssInfoParams_T *pBssInfoParams = &pWhalParams->BssInfoParams;
448
449
450 pBssInfoParams->txCtrlFrmRateDriverFormat = DEFAULT_HW_GEN_TX_RATE_DRIVER_FORMAT;
451 pBssInfoParams->txCtrlFrmModulation = DEFAULT_HW_GEN_PREAMBLE_TYPE;
452 pBssInfoParams->txCtrlFrmRate = DEFAULT_HW_GEN_TX_RATE;
453
454 pBssInfoParams->txMgmtFrmModulation = DEFAULT_HW_GEN_PREAMBLE_TYPE;
455 pBssInfoParams->txMgmtFrmRate = DEFAULT_HW_GEN_TX_RATE;
456
457 pBssInfoParams->RadioChannel = DEFAULT_HW_RADIO_CHANNEL;
458 pBssInfoParams->Ctrl = 0;
459
460 /* Intilaize the ctrl field in the BSS join structure */
461 /* Only bit_7 in the ctrl field is vurrently in use.
462 If bit_7 is on => Doing Tx flash before joining new AP */
463 if(TxFlashEnable)
464 pBssInfoParams->Ctrl |= JOIN_CMD_CTRL_TX_FLUSH;
465
466 return OK;
467 }
468
469 /****************************************************************************
470 * whal_ParamsGetBssInfoParams()
471 ****************************************************************************
472 * DESCRIPTION: return pointer to the BssInfo params
473 ****************************************************************************/
whal_ParamsGetBssInfoParams(WhalParams_T * pWhalParams)474 BssInfoParams_T *whal_ParamsGetBssInfoParams(WhalParams_T *pWhalParams)
475 {
476 return (&pWhalParams->BssInfoParams);
477 }
478
479 /****************************************************************************
480 * whal_ParamsGetRadioChannel()
481 ****************************************************************************
482 * DESCRIPTION: return the radio channel
483 ****************************************************************************/
whal_ParamsGetRadioChannel(WhalParams_T * pWhalParams)484 UINT8 whal_ParamsGetRadioChannel(WhalParams_T *pWhalParams)
485 {
486 return (pWhalParams->BssInfoParams.RadioChannel);
487 }
488
489 /****************************************************************************
490 * whal_ParamsSetRadioChannel()
491 ****************************************************************************
492 * DESCRIPTION: set the radio channel
493 ****************************************************************************/
whal_ParamsSetRadioChannel(WhalParams_T * pWhalParams,int Channel)494 void whal_ParamsSetRadioChannel(WhalParams_T *pWhalParams, int Channel)
495 {
496 pWhalParams->BssInfoParams.RadioChannel = (UINT8)Channel;
497 }
498
499 /****************************************************************************
500 * whal_ParamsGetDefaultChannel()
501 ****************************************************************************
502 * DESCRIPTION: return the default channel to start from
503 ****************************************************************************/
whal_ParamsGetDefaultChannel(WhalParams_T * pWhalParams)504 UINT8 whal_ParamsGetDefaultChannel(WhalParams_T *pWhalParams)
505 {
506 WlanParams_T *pWlanParams = &pWhalParams->WlanParams;
507
508 if (RADIO_BAND_5_0_GHZ == pWlanParams->RadioBand)
509 {
510 return pWlanParams->calibrationChannel5_0;
511 }
512 else
513 {
514 return pWlanParams->calibrationChannel2_4;
515 }
516 }
517
518 /****************************************************************************
519 * whal_ParamsSetReqBssType()
520 ****************************************************************************
521 * DESCRIPTION: set the bss type (driver enum)
522 ****************************************************************************/
whal_ParamsSetReqBssType(WhalParams_T * pWhalParams,int Val)523 void whal_ParamsSetReqBssType(WhalParams_T *pWhalParams, int Val)
524 {
525 pWhalParams->BssInfoParams.ReqBssType = Val;
526 }
527
528 /****************************************************************************
529 * whal_ParamsGetReqBssType()
530 ****************************************************************************
531 * DESCRIPTION: get the bss type (driver enum)
532 ****************************************************************************/
whal_ParamsGetReqBssType(WhalParams_T * pWhalParams)533 UINT8 whal_ParamsGetReqBssType(WhalParams_T *pWhalParams)
534 {
535 return pWhalParams->BssInfoParams.ReqBssType;
536 }
537
538 /****************************************************************************
539 * whal_ParamsSetBssType()
540 ****************************************************************************
541 * DESCRIPTION: set the bss type (public enum)
542 ****************************************************************************/
whal_ParamsSetBssType(WhalParams_T * pWhalParams,int Val)543 void whal_ParamsSetBssType(WhalParams_T *pWhalParams, int Val)
544 {
545 pWhalParams->BssInfoParams.BssType = Val;
546 }
547 /****************************************************************************
548 * whal_ParamsSetRadioBand()
549 ****************************************************************************
550 * DESCRIPTION: set the radio band
551 ****************************************************************************/
whal_ParamsSetRadioBand(WhalParams_T * pWhalParams,int RadioBand)552 void whal_ParamsSetRadioBand(WhalParams_T *pWhalParams, int RadioBand)
553 {
554 pWhalParams->WlanParams.RadioBand = (UINT8)RadioBand;
555 }
556
557 /****************************************************************************
558 * whal_ParamsGetRadioBand()
559 ****************************************************************************
560 * DESCRIPTION: get the radio band
561 ****************************************************************************/
whal_ParamsGetRadioBand(WhalParams_T * pWhalParams)562 UINT8 whal_ParamsGetRadioBand(WhalParams_T *pWhalParams)
563 {
564 return (pWhalParams->WlanParams.RadioBand);
565 }
566
567 /****************************************************************************
568 * whal_ParamsSetPowerSaveState()
569 ****************************************************************************
570 * DESCRIPTION: set the power save state
571 ****************************************************************************/
whal_ParamsSetPowerSaveState(WhalParams_T * pWhalParams,UINT8 CurrPowerSaveState)572 void whal_ParamsSetPowerSaveState(WhalParams_T *pWhalParams, UINT8 CurrPowerSaveState)
573 {
574 pWhalParams->WlanParams.CurrPowerSaveState = (UINT8)CurrPowerSaveState;
575 }
576
577 /****************************************************************************
578 * whal_ParamsGetPowerSaveState()
579 ****************************************************************************
580 * DESCRIPTION: get the power save state
581 ****************************************************************************/
whal_ParamsGetPowerSaveState(WhalParams_T * pWhalParams)582 UINT8 whal_ParamsGetPowerSaveState(WhalParams_T *pWhalParams)
583 {
584 return (pWhalParams->WlanParams.CurrPowerSaveState);
585 }
586
587
588 /****************************************************************************
589 * whal_ParamsGetBssType()
590 ****************************************************************************
591 * DESCRIPTION: return the bss type
592 ****************************************************************************/
whal_ParamsGetBssType(WhalParams_T * pWhalParams)593 UINT8 whal_ParamsGetBssType(WhalParams_T *pWhalParams)
594 {
595 return (pWhalParams->BssInfoParams.BssType);
596 }
597
598 /****************************************************************************
599 * whal_ParamsSetBeaconInterval()
600 ****************************************************************************
601 * DESCRIPTION: set the beacon interval
602 ****************************************************************************/
whal_ParamsSetBeaconInterval(WhalParams_T * pWhalParams,UINT16 Val)603 void whal_ParamsSetBeaconInterval(WhalParams_T *pWhalParams, UINT16 Val)
604 {
605 pWhalParams->BssInfoParams.BeaconInterval = Val;
606 }
607
608 /****************************************************************************
609 * whal_ParamsGetBeaconInterval()
610 ****************************************************************************
611 * DESCRIPTION: return the beacon interval
612 ****************************************************************************/
whal_ParamsGetBeaconInterval(WhalParams_T * pWhalParams)613 UINT16 whal_ParamsGetBeaconInterval(WhalParams_T *pWhalParams)
614 {
615 return (pWhalParams->BssInfoParams.BeaconInterval);
616 }
617
618 /****************************************************************************
619 * whal_ParamsSetDtimCount()
620 ****************************************************************************
621 * DESCRIPTION: set the dtim count interval
622 ****************************************************************************/
whal_ParamsSetDtimCount(WhalParams_T * pWhalParams,UINT8 Val)623 void whal_ParamsSetDtimCount(WhalParams_T *pWhalParams, UINT8 Val)
624 {
625 pWhalParams->BssInfoParams.DtimInterval = Val;
626 }
627
628 /****************************************************************************
629 * whal_ParamsGetDtimCount()
630 ****************************************************************************
631 * DESCRIPTION: return the Dtim count interval
632 ****************************************************************************/
whal_ParamsGetDtimCount(WhalParams_T * pWhalParams)633 UINT8 whal_ParamsGetDtimCount(WhalParams_T *pWhalParams)
634 {
635 return (pWhalParams->BssInfoParams.DtimInterval);
636 }
637
638 /****************************************************************************
639 * whal_ParamsGetBssId()
640 ****************************************************************************
641 * DESCRIPTION: return the Bss Id
642 ****************************************************************************/
whal_ParamsGetBssId(WhalParams_T * pWhalParams)643 UINT8 *whal_ParamsGetBssId(WhalParams_T *pWhalParams)
644 {
645 return (pWhalParams->BssInfoParams.BssId);
646 }
647
648 /****************************************************************************
649 * whal_ParamsSetBssId()
650 ****************************************************************************
651 * DESCRIPTION: set the Bss Id
652 ****************************************************************************/
whal_ParamsSetBssId(WhalParams_T * pWhalParams,char * BssId)653 void whal_ParamsSetBssId(WhalParams_T *pWhalParams, char *BssId)
654 {
655 genMacCopy((char *)pWhalParams->BssInfoParams.BssId, BssId);
656 }
657
658 /****************************************************************************
659 * whal_ParamsGetElm_Ssid()
660 ****************************************************************************
661 * DESCRIPTION: return the SSID info element
662 ****************************************************************************/
whal_ParamsGetElm_Ssid(WhalParams_T * pWhalParams)663 dot11_SSID_t *whal_ParamsGetElm_Ssid(WhalParams_T *pWhalParams)
664 {
665 return (&pWhalParams->BssInfoParams.WlanElm_Ssid);
666 }
667
668 /****************************************************************************
669 * whal_ParamsSetSsid()
670 ****************************************************************************
671 * DESCRIPTION: set the SSID
672 ****************************************************************************/
whal_ParamsSetSsid(WhalParams_T * pWhalParams,char * InputSsid,UINT8 SsidLength)673 void whal_ParamsSetSsid(WhalParams_T *pWhalParams, char *InputSsid, UINT8 SsidLength)
674 {
675 BssInfoParams_T *pBssInfoParams = &pWhalParams->BssInfoParams;
676
677 pBssInfoParams->WlanElm_Ssid.hdr.eleLen = SsidLength;
678 os_memoryZero(pWhalParams->hOs, (void *)pBssInfoParams->WlanElm_Ssid.serviceSetId,
679 sizeof(pBssInfoParams->WlanElm_Ssid.serviceSetId));
680 os_memoryCopy(pWhalParams->hOs, (void *)pBssInfoParams->WlanElm_Ssid.serviceSetId, (void *)InputSsid, SsidLength);
681 }
682
683 /****************************************************************************
684 * whal_ParamsSetBasicRates()
685 ****************************************************************************
686 * DESCRIPTION: set the basic rate set
687 ****************************************************************************/
whal_ParamsSetBasicRatesSet(WhalParams_T * pWhalParams,UINT16 BasicRateSet)688 void whal_ParamsSetBasicRatesSet(WhalParams_T *pWhalParams, UINT16 BasicRateSet)
689 {
690 pWhalParams->BssInfoParams.BasicRateSet = BasicRateSet;
691 }
692
693 /****************************************************************************
694 * whal_ParamsSetHwGenTxParams()
695 ****************************************************************************
696 * DESCRIPTION: set the hardware and firmware generated Tx rate (convert to HW coding).
697 *
698 ****************************************************************************/
whal_ParamsSetHwGenTxParams(WhalParams_T * pWhalParams,rate_e TxRate,BOOL bCtrlFrame)699 void whal_ParamsSetHwGenTxParams(WhalParams_T *pWhalParams, rate_e TxRate, BOOL bCtrlFrame)
700 {
701 /* Set The Rate & modulation for CTS, RTS, and PS-Poll frames (not including CTS-protection). */
702 if (bCtrlFrame)
703 {
704 pWhalParams->BssInfoParams.txCtrlFrmRateDriverFormat = TxRate;
705 whalUtils_ConvertAppRate(TxRate, &pWhalParams->BssInfoParams.txCtrlFrmRate);
706 whalUtils_FindHwModulationByDrvRate(TxRate, &pWhalParams->BssInfoParams.txCtrlFrmModulation, pWhalParams->WlanParams.preamble);
707 }
708 /* Set The Rate & modulation for Beacon and Probe-Response frames (IBSS). */
709 else
710 {
711 whalUtils_ConvertAppRate(TxRate, &pWhalParams->BssInfoParams.txMgmtFrmRate);
712 whalUtils_FindHwModulationByDrvRate(TxRate, &pWhalParams->BssInfoParams.txMgmtFrmModulation, pWhalParams->WlanParams.preamble);
713 }
714 }
715
716 /****************************************************************************
717 * whal_ParamsSetBasicRates()
718 ****************************************************************************
719 * DESCRIPTION: set the basic rate set
720 ****************************************************************************/
whal_ParamsSetSupportedRatesSet(WhalParams_T * pWhalParams,UINT16 SupportedRateSet)721 void whal_ParamsSetSupportedRatesSet(WhalParams_T *pWhalParams, UINT16 SupportedRateSet)
722 {
723 pWhalParams->BssInfoParams.SupportedRateSet = SupportedRateSet;
724 }
725
726
727 /****************************************************************************
728 * whal_ParamsGetMacPreambleParams()
729 ****************************************************************************
730 * DESCRIPTION: return pointer to the Mac Preamble Params
731 ****************************************************************************/
whal_ParamsGetMacPreambleParams(WhalParams_T * pWhalParams,UINT8 * earlyWakeUp)732 void whal_ParamsGetMacPreambleParams(WhalParams_T *pWhalParams, UINT8* earlyWakeUp)
733 {
734 *earlyWakeUp = pWhalParams->WlanParams.earlyWakeUp;
735 }
736
737
738 /*
739 * --------------------------------------------------------------------------
740 * wlan params
741 * --------------------------------------------------------------------------
742 */
743
744 #define DEFAULT_CW_MIN 15
745 #define DEFAULT_USE_DEVICE_ERROR_INTERRUPT 1
746
747 /****************************************************************************
748 * whal_ParamsInitWlanParams()
749 ****************************************************************************
750 * DESCRIPTION: Initiate GenParams to the default values
751 *
752 * INPUTS:
753 *
754 * OUTPUT: None
755 *
756 * RETURNS:
757 ****************************************************************************/
whal_ParamsInitWlanParams(WhalParams_T * pWhalParams)758 int whal_ParamsInitWlanParams(WhalParams_T *pWhalParams)
759 {
760 WlanParams_T *pWlanParams = &pWhalParams->WlanParams;
761
762 /*
763 * init filters as station (start/join with BssType will overwrite the values)
764 */
765 whal_ParamsSetRxFilter(pWhalParams, RX_CONFIG_OPTION_MY_DST_MY_BSS, RX_FILTER_OPTION_FILTER_ALL);
766
767 pWlanParams->UseDeviceErrorInterrupt = DEFAULT_USE_DEVICE_ERROR_INTERRUPT;
768
769 /*
770 * All other params are zero and will be set externally on the Create/Config phase
771 */
772
773 return OK;
774 }
775
776 /****************************************************************************
777 * whal_ParamsGetWlanParams()
778 ****************************************************************************
779 * DESCRIPTION: return pointer to the GenParams
780 ****************************************************************************/
whal_ParamsGetWlanParams(WhalParams_T * pWhalParams)781 WlanParams_T *whal_ParamsGetWlanParams(WhalParams_T *pWhalParams)
782 {
783 return (&pWhalParams->WlanParams);
784 }
785
786 /****************************************************************************
787 * whal_ParamsSetFragmentThreshold()
788 ****************************************************************************
789 * DESCRIPTION: set the fragmentation threshold
790 ****************************************************************************/
whal_ParamsSetFragmentThreshold(WhalParams_T * pWhalParams,int FragSize)791 void whal_ParamsSetFragmentThreshold(WhalParams_T *pWhalParams, int FragSize)
792 {
793 pWhalParams->WlanParams.FragmentThreshold = FragSize;
794 }
795
796 /****************************************************************************
797 * whal_ParamsPrintFragmentThreshold()
798 ****************************************************************************
799 * DESCRIPTION: print the fragmentation threshold
800 ****************************************************************************/
whal_ParamsPrintFragmentThreshold(WhalParams_T * pWhalParams)801 void whal_ParamsPrintFragmentThreshold(WhalParams_T *pWhalParams)
802 {
803 WLAN_REPORT_REPLY(pWhalParams->hReport, HAL_HW_CTRL_MODULE_LOG,
804 ("\n FragmentThreshold = %d\n", pWhalParams->WlanParams.FragmentThreshold));
805 }
806
807 /****************************************************************************
808 * whal_ParamsPrintFragmentThreshold()
809 ****************************************************************************
810 * DESCRIPTION: print the fragmentation threshold
811 ****************************************************************************/
whal_ParamsIsFragmentOnHal(WhalParams_T * pWhalParams)812 UINT8 whal_ParamsIsFragmentOnHal(WhalParams_T *pWhalParams)
813 {
814 return (pWhalParams->WlanParams.FragmentationOnHal);
815 }
816 /****************************************************************************
817 * whal_ParamsGetFragmentThreshold()
818 ****************************************************************************
819 * DESCRIPTION: return the fragmentation threshold
820 ****************************************************************************/
whal_ParamsGetFragmentThreshold(WhalParams_T * pWhalParams)821 UINT32 whal_ParamsGetFragmentThreshold(WhalParams_T *pWhalParams)
822 {
823 return (pWhalParams->WlanParams.FragmentThreshold);
824 }
825
826 /****************************************************************************
827 * whal_ParamsGetFragmentThreshold()
828 ****************************************************************************
829 * DESCRIPTION: return the fragmentation threshold
830 ****************************************************************************/
whal_ParamsGetMaxSitesFragCollect(WhalParams_T * pWhalParams)831 UINT8 whal_ParamsGetMaxSitesFragCollect(WhalParams_T *pWhalParams)
832 {
833 return (pWhalParams->WlanParams.maxSitesFragCollect);
834 }
835
836 /****************************************************************************
837 * whal_ParamsSetRtsThreshold()
838 ****************************************************************************
839 * DESCRIPTION: set the rts threshold
840 ****************************************************************************/
whal_ParamsSetRtsThreshold(WhalParams_T * pWhalParams,int RtsSize)841 void whal_ParamsSetRtsThreshold(WhalParams_T *pWhalParams, int RtsSize)
842 {
843 pWhalParams->WlanParams.RtsThreshold = RtsSize;
844 }
845
846 /****************************************************************************
847 * whal_ParamsSetListenInterval()
848 ****************************************************************************
849 * DESCRIPTION: set the Listen Interval
850 ****************************************************************************/
whal_ParamsSetListenInterval(WhalParams_T * pWhalParams,UINT8 Val)851 void whal_ParamsSetListenInterval(WhalParams_T *pWhalParams, UINT8 Val)
852 {
853 pWhalParams->WlanParams.ListenInterval = Val;
854 }
855
856 /****************************************************************************
857 * whal_ParamsGetListenInterval()
858 ****************************************************************************
859 * DESCRIPTION: get the Listen Interval
860 ****************************************************************************/
whal_ParamsGetListenInterval(WhalParams_T * pWhalParams)861 UINT8 whal_ParamsGetListenInterval(WhalParams_T *pWhalParams)
862 {
863 return (pWhalParams->WlanParams.ListenInterval);
864 }
865
866 /****************************************************************************
867 * whal_ParamsSetRxFilter()
868 ****************************************************************************
869 * DESCRIPTION: set the wlan hardware filters
870 ****************************************************************************/
whal_ParamsSetRxFilter(WhalParams_T * pWhalParams,UINT32 RxConfigOption,UINT32 RxFilterOption)871 void whal_ParamsSetRxFilter(WhalParams_T *pWhalParams, UINT32 RxConfigOption, UINT32 RxFilterOption)
872 {
873 pWhalParams->WlanParams.RxConfigOption = RxConfigOption;
874 pWhalParams->WlanParams.RxFilterOption = RxFilterOption;
875
876 pWhalParams->WlanParams.RxConfigOption |= RX_CFG_ENABLE_PHY_HEADER_PLCP;
877
878 #if defined (TNETW_MASTER_MODE) || defined (TNETW_USB_MODE)
879 pWhalParams->WlanParams.RxConfigOption |= RX_CFG_COPY_RX_STATUS;
880 #endif
881
882 if(pWhalParams->WlanParams.RxDisableBroadcast)
883 pWhalParams->WlanParams.RxConfigOption |= RX_CFG_DISABLE_BCAST;
884 }
885
886 /****************************************************************************
887 * whal_ParamsGetRxFilter()
888 ****************************************************************************
889 * DESCRIPTION: Get the wlan hardware filters
890 ****************************************************************************/
whal_ParamsGetRxFilter(WhalParams_T * pWhalParams,UINT32 * pRxConfigOption,UINT32 * pRxFilterOption)891 void whal_ParamsGetRxFilter(WhalParams_T *pWhalParams, UINT32* pRxConfigOption, UINT32* pRxFilterOption)
892 {
893 *pRxConfigOption = pWhalParams->WlanParams.RxConfigOption;
894 *pRxFilterOption = pWhalParams->WlanParams.RxFilterOption;
895 }
896
897
898 /****************************************************************************
899 * whal_ParamsSetarpIpAddressesTable()
900 ****************************************************************************
901 * DESCRIPTION: set the wlan hardware filters
902 ****************************************************************************/
whal_ParamsSetarpIpAddressesTable(WhalParams_T * pWhalParams,IpAddress_t * IP_addr,IPver_e IP_ver)903 void whal_ParamsSetarpIpAddressesTable(WhalParams_T * pWhalParams, IpAddress_t * IP_addr, IPver_e IP_ver)
904 {
905 pWhalParams->WlanParams.arp_IP_ver = IP_ver;
906
907 if (IP_ver == IP_VER_4)
908 {
909 os_memoryCopy(pWhalParams->hOs, (PVOID)pWhalParams->WlanParams.arp_IP_addr.addr, (PVOID)IP_addr, IP_V4_ADDR_LEN);
910 }
911 else /* IP_VER_6*/
912 {
913 os_memoryCopy(pWhalParams->hOs, (PVOID)pWhalParams->WlanParams.arp_IP_addr.addr, (PVOID)IP_addr, IP_V6_ADDR_LEN);
914 }
915 }
916
917 /****************************************************************************
918 * whal_ParamsGetarpIpAddressesTable()
919 ****************************************************************************
920 * DESCRIPTION: get the wlan hardware filters
921 ****************************************************************************/
whal_ParamsGetarpIpAddressesTable(WhalParams_T * pWhalParams,IpAddress_t * IP_addr,IPver_e * pIP_ver)922 void whal_ParamsGetarpIpAddressesTable(WhalParams_T * pWhalParams, IpAddress_t * IP_addr, IPver_e* pIP_ver)
923 {
924
925 *pIP_ver = (IPver_e)pWhalParams->WlanParams.arp_IP_ver;
926
927 if (*pIP_ver == IP_VER_4)
928 {
929 os_memoryCopy(pWhalParams->hOs, (PVOID)IP_addr, (PVOID)pWhalParams->WlanParams.arp_IP_addr.addr, IP_V4_ADDR_LEN);
930 }
931 else /* IP_VER_6*/
932 {
933 os_memoryCopy(pWhalParams->hOs, (PVOID)IP_addr, (PVOID)pWhalParams->WlanParams.arp_IP_addr.addr, IP_V6_ADDR_LEN);
934 }
935 }
936
937
938 /****************************************************************************
939 * whal_ParamsSetarpIpFilterEnabled()
940 ****************************************************************************
941 * DESCRIPTION: set the wlan hardware filters
942 ****************************************************************************/
whal_ParamsSetarpIpFilterEnabled(WhalParams_T * pWhalParams,UINT8 isEnabled)943 void whal_ParamsSetarpIpFilterEnabled(WhalParams_T * pWhalParams, UINT8 isEnabled)
944 {
945 if ( NULL != pWhalParams )
946 {
947 pWhalParams->WlanParams.isArpIpFilteringEnabled = isEnabled;
948 }
949
950 }
951
952 /****************************************************************************
953 * whal_ParamsGetarpIpFilterEnabled()
954 ****************************************************************************
955 * DESCRIPTION: set the wlan hardware filters
956 ****************************************************************************/
whal_ParamsGetarpIpFilterEnabled(WhalParams_T * pWhalParams,UINT8 * pisEnabled)957 void whal_ParamsGetarpIpFilterEnabled(WhalParams_T * pWhalParams, UINT8* pisEnabled)
958 {
959 if ( NULL != pWhalParams )
960 {
961 *pisEnabled = pWhalParams->WlanParams.isArpIpFilteringEnabled;
962 }
963 }
964
965 /****************************************************************************
966 * whal_ParamsSetGroupAddressesTable()
967 ****************************************************************************
968 * DESCRIPTION: set the Group addr table
969 ****************************************************************************/
whal_ParamsSetGroupAddressesTable(WhalParams_T * pWhalParams,UINT8 isEnabled,UINT8 numGroupAddrs,macAddress_t * Group_addr)970 void whal_ParamsSetGroupAddressesTable(WhalParams_T *pWhalParams, UINT8 isEnabled, UINT8 numGroupAddrs, macAddress_t *Group_addr)
971 {
972 int i;
973
974 pWhalParams->WlanParams.numGroupAddrs = numGroupAddrs;
975 pWhalParams->WlanParams.isMacAddrFilteringnabled = isEnabled;
976
977 for ( i=0 ; i < numGroupAddrs; i++)
978 {
979 os_memoryCopy(pWhalParams->hOs, (PVOID)&(pWhalParams->WlanParams.Group_addr[i]), (PVOID)&(Group_addr->addr[MAC_ADDR_SIZE*i]), MAC_ADDR_SIZE);
980 }
981
982 }
983
984 /****************************************************************************
985 * whal_ParamsGetGroupAddressesTable()
986 ****************************************************************************
987 * DESCRIPTION: get the Group addr table
988 ****************************************************************************/
whal_ParamsGetGroupAddressesTable(WhalParams_T * pWhalParams,UINT8 * pisEnabled,UINT8 * pnumGroupAddrs,macAddress_t * Group_addr)989 void whal_ParamsGetGroupAddressesTable(WhalParams_T *pWhalParams, UINT8* pisEnabled, UINT8* pnumGroupAddrs, macAddress_t *Group_addr)
990 {
991 int i;
992
993 *pnumGroupAddrs = pWhalParams->WlanParams.numGroupAddrs;
994 *pisEnabled = pWhalParams->WlanParams.isMacAddrFilteringnabled;
995
996 os_memoryZero(pWhalParams->hOs, Group_addr, sizeof(Group_addr));
997 for (i=0 ; i < *pnumGroupAddrs; i++)
998 {
999 os_memoryCopy(pWhalParams->hOs, (void *)&(Group_addr->addr[MAC_ADDR_SIZE*i]), &pWhalParams->WlanParams.Group_addr[i], MAC_ADDR_SIZE);
1000 }
1001
1002 }
1003
1004
1005 /****************************************************************************
1006 * whal_ParamsGetCurrAntenna()
1007 ****************************************************************************
1008 * DESCRIPTION: get the current antenna setting
1009 ****************************************************************************/
whal_ParamsGetCurrAntenna(WhalParams_T * pWhalParams)1010 UINT8 whal_ParamsGetCurrAntenna(WhalParams_T *pWhalParams)
1011 {
1012 return (pWhalParams->WlanParams.CurrAntenna);
1013 }
1014
1015 /*
1016 * --------------------------------------------------------------------------
1017 * General params
1018 * --------------------------------------------------------------------------
1019 */
1020
1021 #define DEFAULT_TRACE_ENABLE 0
1022 #define DEFAULT_TRACE_OUT 0
1023
1024 #define DEFAULT_PBCC_DYNAMIC_ENABLE_VAL 0
1025 #define DEFAULT_PBCC_DYNAMIC_INTERVAL 500 /* ticks */
1026 #define DEFAULT_PBCC_DYNAMIC_IGNORE_MCAST 0
1027
1028 /****************************************************************************
1029 * whal_ParamsInitGenParams()
1030 ****************************************************************************
1031 * DESCRIPTION: Initiate GenParams to the default values
1032 *
1033 * INPUTS:
1034 *
1035 * OUTPUT: None
1036 *
1037 * RETURNS:
1038 ****************************************************************************/
whal_ParamsInitGenParams(WhalParams_T * pWhalParams)1039 int whal_ParamsInitGenParams(WhalParams_T *pWhalParams)
1040 {
1041 GenParams_T *pGenParams = &pWhalParams->GenParams;
1042
1043 whal_ParamsSetPbccDynamicEnableVal(pWhalParams, DEFAULT_PBCC_DYNAMIC_ENABLE_VAL);
1044 pGenParams->PbccDynamicInterval = DEFAULT_PBCC_DYNAMIC_INTERVAL;
1045 pGenParams->PbccDynamicIgnoreMcast = DEFAULT_PBCC_DYNAMIC_IGNORE_MCAST;
1046
1047
1048 pGenParams->TraceEnable = DEFAULT_TRACE_ENABLE;
1049 pGenParams->TraceOut = DEFAULT_TRACE_OUT;
1050
1051 return OK;
1052 }
1053
1054 /****************************************************************************
1055 * whal_ParamsInitGenCounters()
1056 ****************************************************************************
1057 * DESCRIPTION: Initiate GenCounters to the default values
1058 *
1059 * INPUTS:
1060 *
1061 * OUTPUT: None
1062 *
1063 * RETURNS:
1064 ****************************************************************************/
whal_ParamsInitGenCounters(WhalParams_T * pWhalParams)1065 int whal_ParamsInitGenCounters(WhalParams_T *pWhalParams)
1066 {
1067 GenCounters_T *pGenCounters = &pWhalParams->GenCounters;
1068
1069 pGenCounters->FcsErrCnt = 0;
1070
1071 return OK;
1072 }
1073
1074 /****************************************************************************
1075 * whal_ParamsGetGenParams()
1076 ****************************************************************************
1077 * DESCRIPTION: return pointer to the GenParams
1078 ****************************************************************************/
whal_ParamsGetGenParams(WhalParams_T * pWhalParams)1079 GenParams_T *whal_ParamsGetGenParams(WhalParams_T *pWhalParams)
1080 {
1081 return (&pWhalParams->GenParams);
1082 }
1083
1084 /****************************************************************************
1085 * whal_ParamsGetPbccDynamicEnableVal()
1086 ****************************************************************************
1087 * DESCRIPTION: return the use of Dynamic pbcc enable
1088 ****************************************************************************/
whal_ParamsGetPbccDynamicEnableVal(WhalParams_T * pWhalParams)1089 UINT32 whal_ParamsGetPbccDynamicEnableVal(WhalParams_T *pWhalParams)
1090 {
1091 return (pWhalParams->GenParams.PbccDynamicEnable);
1092 }
1093
1094 /****************************************************************************
1095 * whal_ParamsSetPbccDynamic()
1096 ****************************************************************************
1097 * DESCRIPTION: set the use of Dynamic pbcc enable
1098 ****************************************************************************/
whal_ParamsSetPbccDynamicEnableVal(WhalParams_T * pWhalParams,int EnableVal)1099 void whal_ParamsSetPbccDynamicEnableVal(WhalParams_T *pWhalParams, int EnableVal)
1100 {
1101 pWhalParams->GenParams.PbccDynamicEnable = EnableVal;
1102
1103 if (EnableVal)
1104 whal_ParamsSetRxFilter(pWhalParams, (UINT16)RX_CONFIG_OPTION_ANY_DST_ANY_BSS, (UINT16)RX_FILTER_OPTION_DEF);
1105 else
1106 whal_ParamsSetRxFilter(pWhalParams, (UINT16)RX_CONFIG_OPTION_ANY_DST_MY_BSS, (UINT16)RX_FILTER_OPTION_DEF);
1107 }
1108
1109 /*
1110 * --------------------------------------------------------------------------
1111 * Wlan hardware Info params
1112 * --------------------------------------------------------------------------
1113 */
1114
1115 /****************************************************************************
1116 * whal_ParamsInitHwInfoParams()
1117 ****************************************************************************
1118 * DESCRIPTION: Initiate Hw info params
1119 *
1120 * INPUTS:
1121 *
1122 * OUTPUT: None
1123 *
1124 * RETURNS:
1125 ****************************************************************************/
whal_ParamsInitHwInfoParams(WhalParams_T * pWhalParams)1126 int whal_ParamsInitHwInfoParams(WhalParams_T *pWhalParams)
1127 {
1128 return OK;
1129 }
1130
1131 /****************************************************************************
1132 * whal_ParamsGetSrcMac()
1133 ****************************************************************************
1134 * DESCRIPTION: return the AP mac address
1135 ****************************************************************************/
whal_ParamsGetSrcMac(WhalParams_T * pWhalParams)1136 UINT8 *whal_ParamsGetSrcMac(WhalParams_T *pWhalParams)
1137 {
1138 return (pWhalParams->HwInfoParams.SrcMacAddr);
1139 }
1140
1141 /****************************************************************************
1142 * whal_ParamsSetSrcMac()
1143 ****************************************************************************
1144 * DESCRIPTION: set the SrcMac
1145 ****************************************************************************/
whal_ParamsSetSrcMac(WhalParams_T * pWhalParams,char * SrcMac)1146 void whal_ParamsSetSrcMac(WhalParams_T *pWhalParams, char *SrcMac)
1147 {
1148 genMacCopy((char *)pWhalParams->HwInfoParams.SrcMacAddr, SrcMac);
1149 }
1150
1151 /****************************************************************************
1152 * whal_ParamsGetRadioType()
1153 ****************************************************************************
1154 * DESCRIPTION: return the Radio type from the ConfigOptions
1155 ****************************************************************************/
whal_ParamsGetRadioType(WhalParams_T * pWhalParams)1156 char whal_ParamsGetRadioType(WhalParams_T *pWhalParams)
1157 {
1158 return (pWhalParams->WlanParams.radioType);
1159 }
1160
1161 /****************************************************************************
1162 * whal_ParamsHwNvramPrint()
1163 ****************************************************************************
1164 * DESCRIPTION: Print ConfigOptions
1165 ****************************************************************************/
whal_ParamsHwNvramPrint(WhalParams_T * pWhalParams)1166 void whal_ParamsHwNvramPrint(WhalParams_T *pWhalParams)
1167 {
1168 /* for future use */
1169 }
1170
1171 /****************************************************************************
1172 * whal_ParamsGetAcxVersion()
1173 ****************************************************************************
1174 * DESCRIPTION: return wlan hardware/software version
1175 ****************************************************************************/
whal_ParamsGetAcxVersion(WhalParams_T * pWhalParams)1176 ACXRevision_t *whal_ParamsGetAcxVersion(WhalParams_T *pWhalParams)
1177 {
1178 return (&pWhalParams->HwInfoParams.AcxVersion);
1179 }
1180
1181 /****************************************************************************
1182 * whal_ParamsGetFwVersion()
1183 ****************************************************************************
1184 * DESCRIPTION: return wlan firmware version
1185 ****************************************************************************/
whal_ParamsGetFwVersion(WhalParams_T * pWhalParams)1186 UINT8 *whal_ParamsGetFwVersion(WhalParams_T *pWhalParams)
1187 {
1188 return (UINT8 *)(pWhalParams->HwInfoParams.AcxVersion.FWVersion);
1189 }
1190
1191 /****************************************************************************
1192 * whal_ParamsPrintFwVersion()
1193 ****************************************************************************
1194 * DESCRIPTION: print the fw version
1195 ****************************************************************************/
whal_ParamsPrintFwVersion(WhalParams_T * pWhalParams)1196 void whal_ParamsPrintFwVersion(WhalParams_T *pWhalParams)
1197 {
1198 #ifdef TI_DBG
1199 UINT8 *StaId = whal_ParamsGetSrcMac(pWhalParams);
1200
1201 WLAN_REPORT_INIT (pWhalParams->hReport,
1202 HAL_HW_CTRL_MODULE_LOG,
1203 ("Firmware version: %s\n",
1204 pWhalParams->HwInfoParams.AcxVersion.FWVersion));
1205 WLAN_REPORT_INIT (pWhalParams->hReport,
1206 HAL_HW_CTRL_MODULE_LOG,
1207 ("Station Id: %02X-%02X-%02X-%02X-%02X-%02X\n",
1208 StaId[0], StaId[1], StaId[2], StaId[3], StaId[4], StaId[5]));
1209 #endif /* TI_DBG */
1210 }
1211
1212 /****************************************************************************
1213 * whal_ParamsGetTraceBufferSize()
1214 ****************************************************************************
1215 * DESCRIPTION: get trace buffer size
1216 ****************************************************************************/
whal_ParamsGetTraceBufferSize(WhalParams_T * pWhalParams)1217 UINT32 whal_ParamsGetTraceBufferSize(WhalParams_T *pWhalParams)
1218 {
1219 return pWhalParams->DmaParams.TraceBufferSize;
1220 }
1221 /*
1222 * --------------------------------------------------------------------------
1223 * Convert functions
1224 * --------------------------------------------------------------------------
1225 */
1226
whalUtils_ConvertHwRate(UINT8 HwRate,UINT8 HwModulation,rate_e * AppRate,modulationType_e * AppModulation)1227 int whalUtils_ConvertHwRate(UINT8 HwRate, UINT8 HwModulation, rate_e *AppRate, modulationType_e *AppModulation)
1228 {
1229 rate_e Rate = DRV_RATE_AUTO;
1230 modulationType_e Modulation = DRV_MODULATION_NONE;
1231 int Stt = OK;
1232
1233 switch (HwRate)
1234 {
1235 case RATE_1MBPS: Rate = DRV_RATE_1M; Modulation = DRV_MODULATION_QPSK; break;
1236 case RATE_2MBPS: Rate = DRV_RATE_2M; Modulation = DRV_MODULATION_QPSK; break;
1237 case RATE_5_5MBPS: Rate = DRV_RATE_5_5M; Modulation = DRV_MODULATION_CCK; break;
1238 case RATE_11MBPS: Rate = DRV_RATE_11M; Modulation = DRV_MODULATION_CCK; break;
1239 case RATE_22MBPS: Rate = DRV_RATE_22M; Modulation = DRV_MODULATION_PBCC; break;
1240 case RATE_6MBPS: Rate = DRV_RATE_6M; Modulation = DRV_MODULATION_OFDM; break;
1241 case RATE_9MBPS: Rate = DRV_RATE_9M; Modulation = DRV_MODULATION_OFDM; break;
1242 case RATE_18MBPS: Rate = DRV_RATE_18M; Modulation = DRV_MODULATION_OFDM; break;
1243 case RATE_24MBPS: Rate = DRV_RATE_24M; Modulation = DRV_MODULATION_OFDM; break;
1244 case RATE_36MBPS: Rate = DRV_RATE_36M; Modulation = DRV_MODULATION_OFDM; break;
1245 case RATE_48MBPS: Rate = DRV_RATE_48M; Modulation = DRV_MODULATION_OFDM; break;
1246 case RATE_54MBPS: Rate = DRV_RATE_54M; Modulation = DRV_MODULATION_OFDM; break;
1247 default: Rate = DRV_RATE_1M; Modulation = DRV_MODULATION_NONE;
1248 Stt = NOK;
1249 break;
1250 }
1251
1252 /* patch for 12M (same code as 1M) */
1253 if ((HwRate == RATE_12MBPS) && (HwModulation == HW_MODULATION_OFDM))
1254 {
1255 Rate = DRV_RATE_12M; Modulation = DRV_MODULATION_OFDM;
1256 }
1257
1258 if (Stt == OK)
1259 {
1260 *AppRate = Rate;
1261 *AppModulation = Modulation;
1262 }
1263
1264 return Stt;
1265 }
1266
1267
whalUtils_ConvertAppRate(rate_e AppRate,UINT8 * HwRate)1268 int whalUtils_ConvertAppRate (rate_e AppRate, UINT8 *HwRate)
1269 {
1270 UINT8 Rate = 0;
1271 int Stt = OK;
1272
1273 switch (AppRate)
1274 {
1275 /*
1276 * The handle for 5.5/11/22 PBCC was removed !!!
1277 */
1278
1279 case DRV_RATE_1M: Rate = RATE_1MBPS; break;
1280 case DRV_RATE_2M: Rate = RATE_2MBPS; break;
1281 case DRV_RATE_5_5M: Rate = RATE_5_5MBPS; break;
1282 case DRV_RATE_11M: Rate = RATE_11MBPS; break;
1283 case DRV_RATE_22M: Rate = RATE_22MBPS; break;
1284 case DRV_RATE_6M: Rate = RATE_6MBPS; break;
1285 case DRV_RATE_9M: Rate = RATE_9MBPS; break;
1286 case DRV_RATE_12M: Rate = RATE_12MBPS; break;
1287 case DRV_RATE_18M: Rate = RATE_18MBPS; break;
1288 case DRV_RATE_24M: Rate = RATE_24MBPS; break;
1289 case DRV_RATE_36M: Rate = RATE_36MBPS; break;
1290 case DRV_RATE_48M: Rate = RATE_48MBPS; break;
1291 case DRV_RATE_54M: Rate = RATE_54MBPS; break;
1292
1293 default:
1294 WLAN_OS_REPORT(("%s wrong app rate = %d\n",__FUNCTION__,AppRate));
1295 Stt = NOK;
1296 break;
1297 }
1298
1299 if (Stt == OK)
1300 *HwRate = Rate;
1301 else
1302 *HwRate = RATE_1MBPS;
1303
1304 return (Stt);
1305 }
1306
whalUtils_FindHwModulationByDrvRate(rate_e AppRate,UINT8 * HwModu,UINT8 preamble)1307 int whalUtils_FindHwModulationByDrvRate (rate_e AppRate, UINT8 *HwModu, UINT8 preamble)
1308 {
1309 int Stt = OK;
1310
1311
1312 switch (AppRate)
1313 {
1314 /*
1315 * The handle for 5.5/11/22 PBCC was removed !!!
1316 */
1317
1318 case DRV_RATE_1M:
1319 *HwModu = CCK_LONG;
1320 break;
1321
1322 case DRV_RATE_2M:
1323 case DRV_RATE_5_5M:
1324 case DRV_RATE_11M:
1325 if (preamble == 0) /* PREAMBLE_LONG*/
1326 *HwModu = CCK_LONG;
1327 else
1328 *HwModu = CCK_SHORT;
1329 break;
1330
1331 case DRV_RATE_22M:
1332 if (preamble == 0) /* PREAMBLE_LONG*/
1333 *HwModu = PBCC_LONG;
1334 else
1335 *HwModu = PBCC_SHORT;
1336 break;
1337
1338 case DRV_RATE_6M:
1339 case DRV_RATE_9M:
1340 case DRV_RATE_12M:
1341 case DRV_RATE_18M:
1342 case DRV_RATE_24M:
1343 case DRV_RATE_36M:
1344 case DRV_RATE_48M:
1345 case DRV_RATE_54M:
1346 *HwModu = OFDM;
1347 break;
1348 default:
1349 WLAN_OS_REPORT(("%s wrong rate = %d\n",__FUNCTION__,AppRate));
1350 *HwModu = CCK_LONG;
1351 Stt = NOK;
1352 break;
1353 }
1354
1355 return (Stt);
1356 }
1357
1358
1359
whalUtils_ConvertAppRatesBitmap(UINT32 AppRatesBitmap,UINT32 AppModulation,UINT16 * HwRatesBitmap)1360 int whalUtils_ConvertAppRatesBitmap(UINT32 AppRatesBitmap, UINT32 AppModulation, UINT16 *HwRatesBitmap)
1361 {
1362 UINT16 RatesBitmap = 0;
1363
1364 if (AppRatesBitmap & DRV_RATE_MASK_1_BARKER) RatesBitmap |= HW_BIT_RATE_1MBPS;
1365 if (AppRatesBitmap & DRV_RATE_MASK_2_BARKER) RatesBitmap |= HW_BIT_RATE_2MBPS;
1366 if (AppRatesBitmap & DRV_RATE_MASK_5_5_CCK) RatesBitmap |= HW_BIT_RATE_5_5MBPS;
1367 if (AppRatesBitmap & DRV_RATE_MASK_11_CCK) RatesBitmap |= HW_BIT_RATE_11MBPS;
1368 if (AppRatesBitmap & DRV_RATE_MASK_22_PBCC) RatesBitmap |= HW_BIT_RATE_22MBPS;
1369 if (AppRatesBitmap & DRV_RATE_MASK_6_OFDM) RatesBitmap |= HW_BIT_RATE_6MBPS;
1370 if (AppRatesBitmap & DRV_RATE_MASK_9_OFDM) RatesBitmap |= HW_BIT_RATE_9MBPS;
1371 if (AppRatesBitmap & DRV_RATE_MASK_12_OFDM) RatesBitmap |= HW_BIT_RATE_12MBPS;
1372 if (AppRatesBitmap & DRV_RATE_MASK_18_OFDM) RatesBitmap |= HW_BIT_RATE_18MBPS;
1373 if (AppRatesBitmap & DRV_RATE_MASK_24_OFDM) RatesBitmap |= HW_BIT_RATE_24MBPS;
1374 if (AppRatesBitmap & DRV_RATE_MASK_36_OFDM) RatesBitmap |= HW_BIT_RATE_36MBPS;
1375 if (AppRatesBitmap & DRV_RATE_MASK_48_OFDM) RatesBitmap |= HW_BIT_RATE_48MBPS;
1376 if (AppRatesBitmap & DRV_RATE_MASK_54_OFDM) RatesBitmap |= HW_BIT_RATE_54MBPS;
1377
1378 *HwRatesBitmap = RatesBitmap;
1379
1380 return (OK);
1381 }
1382
whalUtils_ConvertHwRatesBitmap(UINT8 HwRatesBitmap,UINT8 HwModulation,UINT32 * AppRate,UINT32 * AppModulation)1383 int whalUtils_ConvertHwRatesBitmap(UINT8 HwRatesBitmap, UINT8 HwModulation, UINT32 *AppRate, UINT32 *AppModulation)
1384 {
1385 UINT16 RatesBitmap = 0;
1386
1387 if (HwRatesBitmap & HW_BIT_RATE_1MBPS) RatesBitmap |= DRV_RATE_MASK_1_BARKER;
1388 if (HwRatesBitmap & HW_BIT_RATE_2MBPS) RatesBitmap |= DRV_RATE_MASK_2_BARKER;
1389 if (HwRatesBitmap & HW_BIT_RATE_5_5MBPS) RatesBitmap |= DRV_RATE_MASK_5_5_CCK;
1390 if (HwRatesBitmap & HW_BIT_RATE_11MBPS) RatesBitmap |= DRV_RATE_MASK_11_CCK;
1391 if (HwRatesBitmap & HW_BIT_RATE_22MBPS) RatesBitmap |= DRV_RATE_MASK_22_PBCC;
1392 if (HwRatesBitmap & HW_BIT_RATE_6MBPS) RatesBitmap |= DRV_RATE_MASK_6_OFDM;
1393 if (HwRatesBitmap & HW_BIT_RATE_9MBPS) RatesBitmap |= DRV_RATE_MASK_9_OFDM;
1394 if (HwRatesBitmap & HW_BIT_RATE_12MBPS) RatesBitmap |= DRV_RATE_MASK_12_OFDM;
1395 if (HwRatesBitmap & HW_BIT_RATE_18MBPS) RatesBitmap |= DRV_RATE_MASK_18_OFDM;
1396 if (HwRatesBitmap & HW_BIT_RATE_24MBPS) RatesBitmap |= DRV_RATE_MASK_24_OFDM;
1397 if (HwRatesBitmap & HW_BIT_RATE_36MBPS) RatesBitmap |= DRV_RATE_MASK_36_OFDM;
1398 if (HwRatesBitmap & HW_BIT_RATE_48MBPS) RatesBitmap |= DRV_RATE_MASK_48_OFDM;
1399 if (HwRatesBitmap & HW_BIT_RATE_54MBPS) RatesBitmap |= DRV_RATE_MASK_54_OFDM;
1400
1401 *AppRate = RatesBitmap;
1402
1403 return (OK);
1404 }
1405
whalUtils_ConvertBitmapToMaxRate(UINT16 HwRatesBitmap,UINT8 * HwModulation,UINT8 * HwRate)1406 void whalUtils_ConvertBitmapToMaxRate(UINT16 HwRatesBitmap, UINT8 *HwModulation, UINT8 *HwRate)
1407 {
1408 /*
1409 * !!!!!! MUST KEEP THE ORDER
1410 */
1411 if (HwRatesBitmap & HW_BIT_RATE_54MBPS)
1412 {
1413 *HwRate = RATE_54MBPS;
1414 *HwModulation = HW_MODULATION_OFDM;
1415 }
1416 else if (HwRatesBitmap & HW_BIT_RATE_48MBPS)
1417 {
1418 *HwRate = RATE_48MBPS;
1419 *HwModulation = HW_MODULATION_OFDM;
1420 }
1421 else if (HwRatesBitmap & HW_BIT_RATE_36MBPS)
1422 {
1423 *HwRate = RATE_36MBPS;
1424 *HwModulation = HW_MODULATION_OFDM;
1425 }
1426 else if (HwRatesBitmap & HW_BIT_RATE_24MBPS)
1427 {
1428 *HwRate = RATE_24MBPS;
1429 *HwModulation = HW_MODULATION_OFDM;
1430 }
1431 else if (HwRatesBitmap & HW_BIT_RATE_22MBPS)
1432 {
1433 *HwRate = RATE_22MBPS;
1434 *HwModulation = HW_MODULATION_PBCC;
1435 }
1436 else if (HwRatesBitmap & HW_BIT_RATE_18MBPS)
1437 {
1438 *HwRate = RATE_18MBPS;
1439 *HwModulation = HW_MODULATION_OFDM;
1440 }
1441 else if (HwRatesBitmap & HW_BIT_RATE_12MBPS)
1442 {
1443 *HwRate = RATE_12MBPS;
1444 *HwModulation = HW_MODULATION_OFDM;
1445 }
1446 else if (HwRatesBitmap & HW_BIT_RATE_11MBPS)
1447 {
1448 *HwRate = RATE_11MBPS;
1449 *HwModulation = HW_MODULATION_PBCC;
1450 }
1451 else if (HwRatesBitmap & HW_BIT_RATE_9MBPS)
1452 {
1453 *HwRate = RATE_9MBPS;
1454 *HwModulation = HW_MODULATION_OFDM;
1455 }
1456 else if (HwRatesBitmap & HW_BIT_RATE_6MBPS)
1457 {
1458 *HwRate = RATE_6MBPS;
1459 *HwModulation = HW_MODULATION_OFDM;
1460 }
1461 else if (HwRatesBitmap & HW_BIT_RATE_5_5MBPS)
1462 {
1463 *HwRate = RATE_5_5MBPS;
1464 *HwModulation = HW_MODULATION_PBCC;
1465 }
1466 else if (HwRatesBitmap & HW_BIT_RATE_2MBPS)
1467 {
1468 *HwRate = RATE_2MBPS;
1469 *HwModulation = HW_MODULATION_PBCC;
1470 }
1471 else
1472 {
1473 *HwRate = RATE_1MBPS;
1474 *HwModulation = HW_MODULATION_PBCC;
1475 }
1476 }
1477
1478 /* Note the difference between this function and the next one */
whalUtils_GwsiRate2DRV_RATE(UINT32 gwsiRate)1479 UINT32 whalUtils_GwsiRate2DRV_RATE (UINT32 gwsiRate)
1480 {
1481 switch (gwsiRate)
1482 {
1483 /*
1484 * The handle for 33 removed !!!
1485 */
1486
1487 case GWSI_1Mbits: return DRV_RATE_1M; /* break; */
1488 case GWSI_2Mbits: return DRV_RATE_2M; /*break; */
1489 case GWSI_5_5Mbits: return DRV_RATE_5_5M; /*break; */
1490 case GWSI_6Mbits : return DRV_RATE_6M; /* break; */
1491 case GWSI_9Mbits : return DRV_RATE_9M; /* break; */
1492 case GWSI_11Mbits: return DRV_RATE_11M; /* break; */
1493 case GWSI_12Mbits: return DRV_RATE_12M; /* break; */
1494 case GWSI_18Mbits: return DRV_RATE_18M; /* break; */
1495 case GWSI_22Mbits: return DRV_RATE_22M; /* break; */
1496 case GWSI_24Mbits: return DRV_RATE_24M; /* break; */
1497 case GWSI_36Mbits: return DRV_RATE_36M; /* break; */
1498 case GWSI_48Mbits: return DRV_RATE_48M; /* break; */
1499 case GWSI_54Mbits: return DRV_RATE_54M; /* break; */
1500
1501 default:
1502
1503 return DRV_RATE_1M;
1504 /* break; */
1505 }
1506 }
1507
whalUtils_GwsiRate2DRV_RATE_MASK(UINT32 gwsiRate)1508 rateMask_e whalUtils_GwsiRate2DRV_RATE_MASK (UINT32 gwsiRate)
1509 {
1510 switch (gwsiRate)
1511 {
1512 case GWSI_1Mbits: return DRV_RATE_MASK_1_BARKER;
1513 case GWSI_2Mbits: return DRV_RATE_MASK_2_BARKER;
1514 case GWSI_5_5Mbits: return DRV_RATE_MASK_5_5_CCK;
1515 case GWSI_6Mbits: return DRV_RATE_MASK_6_OFDM;
1516 case GWSI_9Mbits: return DRV_RATE_MASK_9_OFDM;
1517 case GWSI_11Mbits: return DRV_RATE_MASK_11_CCK;
1518 case GWSI_12Mbits: return DRV_RATE_MASK_12_OFDM;
1519 case GWSI_18Mbits: return DRV_RATE_MASK_18_OFDM;
1520 case GWSI_22Mbits: return DRV_RATE_MASK_22_PBCC;
1521 case GWSI_24Mbits: return DRV_RATE_MASK_24_OFDM;
1522 case GWSI_36Mbits: return DRV_RATE_MASK_36_OFDM;
1523 case GWSI_48Mbits: return DRV_RATE_MASK_48_OFDM;
1524 case GWSI_54Mbits: return DRV_RATE_MASK_54_OFDM;
1525
1526 default: return DRV_RATE_MASK_1_BARKER;
1527 }
1528 }
1529
whalUtils_DRV_RATE2GwsiRate(UINT32 Rate)1530 UINT32 whalUtils_DRV_RATE2GwsiRate (UINT32 Rate)
1531 {
1532 switch (Rate)
1533 {
1534 /*
1535 * The handle for 33 removed !!!
1536 */
1537
1538 case DRV_RATE_1M: return GWSI_1Mbits; /* break;*/
1539 case DRV_RATE_2M: return GWSI_2Mbits; /* break;*/
1540 case DRV_RATE_5_5M: return GWSI_5_5Mbits;/* break;*/
1541 case DRV_RATE_6M: return GWSI_6Mbits ; /* break;*/
1542 case DRV_RATE_9M: return GWSI_9Mbits ; /* break;*/
1543 case DRV_RATE_11M: return GWSI_11Mbits; /* break;*/
1544 case DRV_RATE_12M: return GWSI_12Mbits; /* break;*/
1545 case DRV_RATE_18M: return GWSI_18Mbits; /* break;*/
1546 case DRV_RATE_22M: return GWSI_22Mbits; /* break;*/
1547 case DRV_RATE_24M: return GWSI_24Mbits; /* break;*/
1548 case DRV_RATE_36M: return GWSI_36Mbits; /* break;*/
1549 case DRV_RATE_48M: return GWSI_48Mbits; /* break;*/
1550 case DRV_RATE_54M: return GWSI_54Mbits; /* break;*/
1551
1552 default:
1553 return GWSI_1Mbits;
1554 /* break; */
1555 }
1556 }
1557
whalUtils_DRV_RATE_MASK2GwsiRate(rateMask_e rateMask)1558 UINT32 whalUtils_DRV_RATE_MASK2GwsiRate (rateMask_e rateMask)
1559 {
1560 switch (rateMask)
1561 {
1562 case DRV_RATE_MASK_1_BARKER: return GWSI_1Mbits;
1563 case DRV_RATE_MASK_2_BARKER: return GWSI_2Mbits;
1564 case DRV_RATE_MASK_5_5_CCK: return GWSI_5_5Mbits;
1565 case DRV_RATE_MASK_6_OFDM: return GWSI_6Mbits;
1566 case DRV_RATE_MASK_9_OFDM: return GWSI_9Mbits;
1567 case DRV_RATE_MASK_11_CCK: return GWSI_11Mbits;
1568 case DRV_RATE_MASK_12_OFDM: return GWSI_12Mbits;
1569 case DRV_RATE_MASK_18_OFDM: return GWSI_18Mbits;
1570 case DRV_RATE_MASK_22_PBCC: return GWSI_22Mbits;
1571 case DRV_RATE_MASK_24_OFDM: return GWSI_24Mbits;
1572 case DRV_RATE_MASK_36_OFDM: return GWSI_36Mbits;
1573 case DRV_RATE_MASK_48_OFDM: return GWSI_48Mbits;
1574 case DRV_RATE_MASK_54_OFDM: return GWSI_54Mbits;
1575
1576 default: return GWSI_1Mbits;
1577 }
1578 }
1579
1580