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 /* MODULE: Ctrl.c */
38 /* PURPOSE: Control module functions */
39 /* */
40 /***************************************************************************/
41 #include "Ctrl.h"
42 #include "802_11Defs.h"
43 #include "DataCtrl_Api.h"
44 #include "osApi.h"
45 #include "report.h"
46 #include "utils.h"
47 #include "smeApi.h"
48 #include "siteMgrApi.h"
49 #include "Ethernet.h"
50 #include "tx.h"
51 #include "TrafficMonitorAPI.h"
52 #include "TI_IPC_Api.h"
53 #include "EvHandler.h"
54 #include "apConn.h"
55 #include "TNETW_Driver_api.h"
56 #include "Core_AdaptTx.h"
57 #include "whalCtrl_api.h"
58
59 static void selectRateTable(TI_HANDLE hCtrlData, UINT32 rateMask);
60 static void ctrlData_setTxRatePolicies(ctrlData_t *pCtrlData);
61 static void ctrlData_resetCounters(TI_HANDLE hCtrlData);
62
63 static void ctrlData_resetCounters(TI_HANDLE hCtrlData);
64
65 static void ctrlData_UnregisterTrafficIntensityEvents (TI_HANDLE hCtrlData);
66 static void ctrlData_RegisterTrafficIntensityEvents (TI_HANDLE hCtrlData);
67
68 static UINT32 ctrlData_buildHwBitMapFromArray(policyClassRatesArray_t *pArray);
69 static void ctrlData_storeTSRateSet(ctrlData_t *pCtrlData, txDataQosParams_t *tsrsParams);
70 static rate_e ctrlData_getClosestTSRate(ctrlData_t *pCtrlData, UINT32 ac, rate_e givenRate);
71
72 void ctrlData_TrafficThresholdCrossed(TI_HANDLE Context,UINT32 Cookie);
73
74
75 /* definitions for medium usage calculations - in uSec units*/
76 #define AVERAGE_ACK_TIME 10
77 #define AVERAGE_CTS_TIME 20
78 #define B_SIFS 10
79
80 #define SHORT_PREAMBLE_TIME 96
81 #define LONG_PREAMBLE_TIME 192
82
83 #define OFDM_PREAMBLE 12
84 #define OFDM_SIGNAL_EXT 6
85 #define OFDM_PLCP_HDR 24
86
87 #define OFDM_DURATION (B_SIFS + OFDM_PLCP_HDR + OFDM_SIGNAL_EXT)
88 #define NONOFDM_SHORT_DURATION (B_SIFS + SHORT_PREAMBLE_TIME)
89 #define NONOFDM_LONG_DURATION (B_SIFS + LONG_PREAMBLE_TIME)
90
91 /*************************************************************************
92 * ctrlData_create *
93 **************************************************************************
94 * DESCRIPTION: This function initializes the Ctrl data module.
95 *
96 * INPUT: hOs - handle to Os Abstraction Layer
97 *
98 * OUTPUT: TxCmplt_CB - call back function that return to configMngr
99 * in order to register in the Hal
100 *
101 * RETURN: Handle to the allocated Ctrl data control block
102 ************************************************************************/
ctrlData_create(TI_HANDLE hOs)103 TI_HANDLE ctrlData_create(TI_HANDLE hOs)
104 {
105 ctrlData_t* hCtrlData;
106 rateAdaptation_t* pRateAdaptation;
107 #ifdef SUPPORT_4X
108 fourX_t* pFourX;
109 #endif
110 classifier_t* pClsfr;
111
112 if( hOs == NULL )
113 {
114 WLAN_OS_REPORT(("FATAL ERROR: ctrlData_create(): OS handle Error - Aborting\n"));
115 return NULL;
116 }
117
118 /* alocate Control module control block */
119 hCtrlData = os_memoryAlloc(hOs, (sizeof(ctrlData_t)));
120 if(!hCtrlData)
121 return NULL;
122
123 /* create rate adaptation module */
124 pRateAdaptation = rateAdaptation_create(hOs);
125 #ifdef SUPPORT_4X
126 /* create 4X module */
127 pFourX = fourX_create(hOs);
128 #endif
129 /* create the classifier module */
130 pClsfr = Classifier_create(hOs);
131
132 if ( (!pRateAdaptation)
133 #ifdef SUPPORT_4X
134 || (!pFourX)
135 #endif
136 )
137 {
138 utils_nullMemoryFree(hOs, pRateAdaptation, sizeof(rateAdaptation_t));
139 #ifdef SUPPORT_4X
140 utils_nullMemoryFree(hOs, pFourX, sizeof(fourX_t));
141 #endif
142 utils_nullMemoryFree(hOs, hCtrlData, sizeof(ctrlData_t));
143
144 WLAN_OS_REPORT(("FATAL ERROR: ctrlData_create(): Error Creating Ctrl Module - Aborting\n"));
145 return(NULL);
146 }
147
148 /* reset control module control block */
149 os_memoryZero(hOs, hCtrlData, (sizeof(ctrlData_t)));
150
151 hCtrlData->pRateAdaptation = pRateAdaptation;
152 #ifdef SUPPORT_4X
153 hCtrlData->pFourX = pFourX;
154 #endif
155 hCtrlData->pClsfr = pClsfr;
156
157 hCtrlData->hOs = hOs;
158
159 return(hCtrlData);
160 }
161
162 /***************************************************************************
163 * ctrlData_config *
164 ****************************************************************************
165 * DESCRIPTION: This function configures the Ctrl Data module
166 *
167 * INPUTS: hCtrlData - The object
168 * hWhalCtrl - Handle to the Whal Ctrl object
169 * hSiteMgrHandle - Handle to the Site Mngr object
170 * hTxData - Handle to the Tx Data object
171 * hRxData - Handle to the Rx Data object
172 * hOs - Handle to the Os Abstraction Layer
173 * hReport - Handle to the Report object
174 * ctrlDataInitParams - pointer to Ctrl module init parameters
175 * OUTPUT:
176 *
177 * RETURNS: OK - Configuration succesfull
178 * NOK - Configuration unsuccesfull
179 ***************************************************************************/
ctrlData_config(TI_HANDLE hCtrlData,TI_HANDLE hWhalCtrl,TI_HANDLE hSiteMgrHandle,TI_HANDLE hTxData,TI_HANDLE hRxData,TI_HANDLE hOs,TI_HANDLE hReport,TI_HANDLE hMemMngr,TI_HANDLE hEvHandler,TI_HANDLE hAPConnection,TI_HANDLE hTrafficMonitor,disassocSentCB_t disassocSentCBFunc,TI_HANDLE disassocSentCBObj,ctrlDataInitParams_t * ctrlDataInitParams)180 TI_STATUS ctrlData_config(TI_HANDLE hCtrlData,
181 TI_HANDLE hWhalCtrl,
182 TI_HANDLE hSiteMgrHandle,
183 TI_HANDLE hTxData,
184 TI_HANDLE hRxData,
185 TI_HANDLE hOs,
186 TI_HANDLE hReport,
187 TI_HANDLE hMemMngr,
188 TI_HANDLE hEvHandler,
189 TI_HANDLE hAPConnection,
190 TI_HANDLE hTrafficMonitor,
191 disassocSentCB_t disassocSentCBFunc,
192 TI_HANDLE disassocSentCBObj,
193 ctrlDataInitParams_t *ctrlDataInitParams)
194 {
195 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
196 TI_STATUS Status = OK;
197 rateClassClients_e clientIDindex;
198 txRateClassId_e TxRateIndex;
199 UINT32 ac;
200
201 /* check parameters validity */
202 if( hCtrlData == NULL || hWhalCtrl == NULL || hSiteMgrHandle == NULL || hRxData == NULL ||
203 hTxData == NULL || hOs == NULL || hReport == NULL || hMemMngr == NULL || ctrlDataInitParams == NULL)
204 {
205 WLAN_OS_REPORT(("FATAL ERROR: ctrlData_config(): Parameters Error - Aborting\n"));
206 return NOK;
207 }
208
209 /* set objects handles */
210 pCtrlData->hWhalCtrl = hWhalCtrl;
211 pCtrlData->hSiteMgr = hSiteMgrHandle;
212 pCtrlData->hTxData = hTxData;
213 pCtrlData->hRxData = hRxData;
214 pCtrlData->hOs = hOs;
215 pCtrlData->hReport = hReport;
216 pCtrlData->hAPConn = hAPConnection;
217 pCtrlData->hEvHandler = hEvHandler;
218 pCtrlData->hTrafficMonitor = hTrafficMonitor;
219
220 pCtrlData->disassocSentCBObj = disassocSentCBObj;
221 pCtrlData->disassocSentCBFunc = disassocSentCBFunc;
222
223 /* set Control module parameters */
224 pCtrlData->ctrlDataRateControlEnable = ctrlDataInitParams->ctrlDataRateControlEnable;
225 pCtrlData->ctrlDataIbssProtectionType = ctrlDataInitParams->ctrlDataDesiredIbssProtection;
226 pCtrlData->ctrlDataRtsCtsStatus = ctrlDataInitParams->ctrlDataDesiredCtsRtsStatus;
227
228 #ifdef SUPPORT_4X
229 pCtrlData->ctrlDataFourXEnable = ctrlDataInitParams->ctrlDataFourXEnable;
230 pCtrlData->ctrlDataCerruentFourXstate = ctrlDataInitParams->ctrlDataFourXEnable;
231 #else
232 pCtrlData->ctrlDataFourXEnable = FALSE;
233 pCtrlData->ctrlDataCerruentFourXstate = FALSE;
234 #endif
235
236 MAC_COPY(pCtrlData->hOs, (&pCtrlData->ctrlDataDeviceMacAddress),
237 (&ctrlDataInitParams->ctrlDataDeviceMacAddress));
238
239 pCtrlData->ctrlDataStartStoplinkControlAlg = DEF_START_STOP_LINK_CTRL_ALG;
240 pCtrlData->ctrlDataCurrentBasicRate = DEF_BASIC_RATE;
241 pCtrlData->ctrlDataBasicRateBitMask = DEF_BASIC_RATE_MASK;
242 pCtrlData->ctrlDataCurrentBasicModulationType = DRV_MODULATION_QPSK;
243 pCtrlData->ctrlDataCurrentModulationType = DEF_CURRENT_MUDULATION_TYPE;
244 pCtrlData->ctrlDataCurrentBssType = BSS_INFRASTRUCTURE;
245 os_memoryCopy(pCtrlData->hOs, &pCtrlData->ctrlDataRateTables,
246 &ctrlDataInitParams->rateTable,
247 sizeof(rateTables_t) );
248
249 for (clientIDindex = (rateClassClients_e)0 ; clientIDindex < NUM_OF_RATE_CLASS_CLIENTS ; clientIDindex++)
250 {
251 pCtrlData->bIsClassAvailable[clientIDindex] = TRUE;
252 /* by default all clients use all available rates */
253 pCtrlData->currClientRateMask[clientIDindex] = ALL_RATES_AVAILABLE;
254 pCtrlData->nextClientRateMask[clientIDindex] = ALL_RATES_AVAILABLE;
255
256 /* Init Params are initialized for USER & SG policies only */
257 /* Set short/long retry for all ACs */
258 for (ac=0; ac < MAX_NUM_OF_AC; ac++)
259 {
260 pCtrlData->ctrlDataTxRatePolicy.rateClass[clientIDindex*MAX_NUM_OF_AC+ac].longRetryLimit = ctrlDataInitParams->ctrlDataTxRatePolicy[clientIDindex].longRetryLimit;
261 pCtrlData->ctrlDataTxRatePolicy.rateClass[clientIDindex*MAX_NUM_OF_AC+ac].shortRetryLimit = ctrlDataInitParams->ctrlDataTxRatePolicy[clientIDindex].shortRetryLimit;
262 }
263
264 for (TxRateIndex = txPolicy54; TxRateIndex < MAX_NUM_OF_TX_RATES_IN_CLASS; TxRateIndex++)
265 {
266 pCtrlData->policyClassRatesArrayCck[clientIDindex].txRate[TxRateIndex] = ctrlDataInitParams->policyClassRatesArrayCck[clientIDindex].txRate[TxRateIndex];
267 pCtrlData->policyClassRatesArrayPbcc[clientIDindex].txRate[TxRateIndex] = ctrlDataInitParams->policyClassRatesArrayPbcc[clientIDindex].txRate[TxRateIndex];
268 pCtrlData->policyClassRatesArrayOfdm[clientIDindex].txRate[TxRateIndex] = ctrlDataInitParams->policyClassRatesArrayOfdm[clientIDindex].txRate[TxRateIndex];
269 pCtrlData->policyClassRatesArrayOfdmA[clientIDindex].txRate[TxRateIndex] = ctrlDataInitParams->policyClassRatesArrayOfdmA[clientIDindex].txRate[TxRateIndex];
270 }
271 }
272 /* By default use USER_RATE_CLASS */
273 pCtrlData->currClientRateID = USER_RATE_CLASS;
274 pCtrlData->configuredClientRateID = USER_RATE_CLASS;
275
276 pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataCckRateTable;
277
278 /* reset Counters */
279 ctrlData_resetCounters(pCtrlData);
280
281 /* Configure Rate Adaptation Module */
282 rateAdaptation_config(pCtrlData->pRateAdaptation, hOs, hReport, pCtrlData, hEvHandler,
283 hAPConnection, &ctrlDataInitParams->rateAdaptationInitParam);
284
285 #ifdef SUPPORT_4X
286 /* configure fourX Module */
287 fourX_config(pCtrlData->pFourX, hOs, hReport, hMemMngr, hWhalCtrl, hTxData,
288 &ctrlDataInitParams->fourXInitParams);
289 #endif
290
291 /* configure the classifier Module */
292 Status = Classifier_config(pCtrlData->pClsfr, hOs, hReport, &ctrlDataInitParams->ClsfrInitParam);
293 if (Status != OK)
294 {
295 WLAN_OS_REPORT(("FATAL ERROR: ctrlData_config(): Classifier_config() failed - Aborting\n"));
296 return Status;
297 }
298
299 /* Initialize traffic intensity threshold parameters */
300 pCtrlData->ctrlDataTrafficIntensityEventsEnabled = ctrlDataInitParams->ctrlDataTrafficThresholdEnabled;
301 pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold = ctrlDataInitParams->ctrlDataTrafficThreshold.uHighThreshold;
302 pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold = ctrlDataInitParams->ctrlDataTrafficThreshold.uLowThreshold;
303 pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval = ctrlDataInitParams->ctrlDataTrafficThreshold.TestInterval;
304
305 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
306 ("\nTraffic Intensity parameters:\nEvents enabled = %d\nuHighThreshold = %d\nuLowThreshold = %d\nTestInterval = %d\n\n",
307 pCtrlData->ctrlDataTrafficIntensityEventsEnabled,
308 pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold,
309 pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold,
310 pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval));
311
312 /* Register the traffic intensity events with the traffic monitor */
313 ctrlData_RegisterTrafficIntensityEvents (pCtrlData);
314
315 /* If the events are enabled, start notification, if disabled - then do nothing */
316 ctrlData_ToggleTrafficIntensityNotification (pCtrlData, pCtrlData->ctrlDataTrafficIntensityEventsEnabled);
317
318 WLAN_REPORT_INIT(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
319 (".....Ctrl Data configured successfully ...\n"));
320
321 return OK;
322 }
323
324 /***************************************************************************
325 * ctrlData_unLoad *
326 ****************************************************************************
327 * DESCRIPTION: This function unload the Ctrl data module.
328 *
329 * INPUTS: hCtrlData - the object
330 *
331 * OUTPUT:
332 *
333 * RETURNS: OK - Unload succesfull
334 * NOK - Unload unsuccesfull
335 ***************************************************************************/
336
ctrlData_unLoad(TI_HANDLE hCtrlData)337 TI_STATUS ctrlData_unLoad(TI_HANDLE hCtrlData)
338 {
339 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
340
341 /* check parameters validity */
342 if( pCtrlData == NULL )
343 {
344 WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
345 (" ctrlData_unLoad() : parametrs value error \n"));
346 return NOK;
347 }
348
349
350 rateAdaptation_destroy(pCtrlData->pRateAdaptation);
351 #ifdef SUPPORT_4X
352 fourX_destroy(pCtrlData->pFourX);
353 #endif
354 Classifier_destroy(pCtrlData->pClsfr);
355
356 /* free timer */
357 /* free control module controll block */
358 os_memoryFree(pCtrlData->hOs, hCtrlData, sizeof(ctrlData_t));
359
360 return OK;
361 }
362 /***************************************************************************
363 * ctrlData_getParam *
364 ****************************************************************************
365 * DESCRIPTION: get a specific parameter
366 *
367 * INPUTS: hCtrlData - the object
368 *
369 *
370 * OUTPUT: pParamInfo - structure which include the value of
371 * the requested parameter
372 *
373 * RETURNS: OK
374 * NOK
375 ***************************************************************************/
376
ctrlData_getParam(TI_HANDLE hCtrlData,paramInfo_t * pParamInfo)377 TI_STATUS ctrlData_getParam(TI_HANDLE hCtrlData, paramInfo_t *pParamInfo)
378 {
379 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
380
381 /* WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
382 ("ctrlData_getParam() : param=0x%x \n", pParamInfo->paramType)); */
383
384 switch (pParamInfo->paramType)
385 {
386 case CTRL_DATA_RATE_CONTROL_ENABLE_PARAM:
387 pParamInfo->content.ctrlDataRateControlEnable = pCtrlData->ctrlDataRateControlEnable;
388 break;
389
390 case CTRL_DATA_FOUR_X_ENABLE_PARAM:
391 pParamInfo->content.ctrlDataFourXEnable = pCtrlData->ctrlDataFourXEnable;
392 break;
393
394 case CTRL_DATA_FOUR_X_CURRRENT_STATUS_PARAM:
395 if (pCtrlData->ctrlDataCurrentBssType == BSS_INFRASTRUCTURE)
396 {
397 pParamInfo->content.ctrlDataCerruentFourXstate = pCtrlData->ctrlDataCerruentFourXstate;
398 } else {
399 pParamInfo->content.ctrlDataCerruentFourXstate = pCtrlData->ctrlDataFourXEnable;
400 }
401
402 break;
403
404 case CTRL_DATA_CURRENT_BSSID_PARAM:
405 MAC_COPY(pCtrlData->hOs, (&pParamInfo->content.ctrlDataCurrentBSSID),
406 (&pCtrlData->ctrlDataCurrentBSSID));
407 break;
408
409 case CTRL_DATA_CURRENT_BSS_TYPE_PARAM:
410 pParamInfo->content.ctrlDataCurrentBssType = pCtrlData->ctrlDataCurrentBssType;
411 break;
412
413 case CTRL_DATA_CURRENT_MODULATION_TYPE_PARAM:
414 pParamInfo->content.ctrlDataCurrentModulationType = pCtrlData->ctrlDataCurrentModulationType;
415 break;
416
417 case CTRL_DATA_CURRENT_PREAMBLE_TYPE_PARAM:
418 pParamInfo->content.ctrlDataCurrentPreambleType = pCtrlData->ctrlDataCurrentPreambleType;
419 break;
420
421 case CTRL_DATA_MAC_ADDRESS:
422 MAC_COPY(pCtrlData->hOs, (&pParamInfo->content.ctrlDataDeviceMacAddress), (&pCtrlData->ctrlDataDeviceMacAddress));
423 break;
424
425 case CTRL_DATA_CURRENT_BASIC_RATE_PARAM:
426 pParamInfo->content.ctrlDataCurrentBasicRate = pCtrlData->ctrlDataCurrentBasicRate;
427 break;
428
429 case CTRL_DATA_CURRENT_BASIC_RATE_MASK_PARAM:
430 pParamInfo->content.ctrlDataBasicRateBitMask = pCtrlData->ctrlDataBasicRateBitMask;
431 break;
432
433 case CTRL_DATA_CURRENT_BASIC_MODULATION_PARAM:
434 pParamInfo->content.ctrlDataCurrentBasicModulationType = pCtrlData->ctrlDataCurrentBasicModulationType;
435 break;
436
437 case CTRL_DATA_COUNTERS_PARAM:
438 os_memoryCopy(pCtrlData->hOs,&pParamInfo->content.ctrlDataCounters,
439 &pCtrlData->ctrlDataCounters, sizeof(ctrlDataCounters_t));
440 break;
441
442 case CTRL_DATA_CURRENT_SUPPORTED_RATE_MASK_PARAM:
443 pParamInfo->content.ctrlDataCurrentRateMask = pCtrlData->ctrlDataCurrentRateMask;
444 break;
445
446 case CTRL_DATA_CURRENT_PROTECTION_STATUS_PARAM:
447 pParamInfo->content.ctrlDataProtectionEnabled = pCtrlData->ctrlDataProtectionEnabled;
448 break;
449
450 case CTRL_DATA_CURRENT_IBSS_PROTECTION_PARAM:
451 pParamInfo->content.ctrlDataIbssProtecionType = pCtrlData->ctrlDataIbssProtectionType;
452 break;
453
454 case CTRL_DATA_CURRENT_RTS_CTS_STATUS_PARAM:
455 pParamInfo->content.ctrlDataRtsCtsStatus = pCtrlData->ctrlDataRtsCtsStatus;
456 break;
457
458 case CTRL_DATA_CLSFR_TYPE:
459 Classifier_getClsfrType (pCtrlData->pClsfr,&pParamInfo->content.ctrlDataClsfrType);
460 break;
461 /*
462 * NOTE: currently supporting only USER_RATE_CLASS!!!!!!!!!
463 */
464 case CTRL_DATA_SHORT_RETRY_LIMIT_PARAM:
465 pParamInfo->content.TxRatePolicy.rateClass[USER_RATE_CLASS].shortRetryLimit = pCtrlData->ctrlDataTxRatePolicy.rateClass[USER_RATE_CLASS].shortRetryLimit;
466 break;
467
468 /*
469 * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
470 */
471 case CTRL_DATA_LONG_RETRY_LIMIT_PARAM:
472 pParamInfo->content.TxRatePolicy.rateClass[USER_RATE_CLASS].longRetryLimit = pCtrlData->ctrlDataTxRatePolicy.rateClass[USER_RATE_CLASS].longRetryLimit;
473 break;
474
475
476 case CTRL_DATA_TRAFFIC_INTENSITY_THRESHOLD:
477 pParamInfo->content.ctrlDataTrafficIntensityThresholds.uHighThreshold = pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold;
478 pParamInfo->content.ctrlDataTrafficIntensityThresholds.uLowThreshold = pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold;
479 pParamInfo->content.ctrlDataTrafficIntensityThresholds.TestInterval = pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval;
480 break;
481
482 default:
483 return (PARAM_NOT_SUPPORTED);
484 /* WLAN_REPORT_ERROR(pCtrlData->hReport, TX_DATA_MODULE_LOG,
485 (" ctrlData_getParam() : PARAMETER NOT SUPPORTED \n"));
486 return NOK;
487 break; - unreachable */
488 }
489
490 return (OK);
491 }
492
493
494 /***************************************************************************
495 * ctrlData_getParam *
496 ****************************************************************************
497 * DESCRIPTION: get a specific parameter
498 *
499 * INPUTS: hCtrlData - the object
500 *
501 *
502 * OUTPUT: pParamInfo - structure which include the value of
503 * the requested parameter
504 *
505 * RETURNS: OK
506 * NOK
507 ***************************************************************************/
508 /* note: ctrlData_getParamPartial() is part of ctrlData_getParam() it was implemented to reduce Stack usage */
ctrlData_getParamPartial(TI_HANDLE hCtrlData,paramInfoPartial_t * pParamInfo)509 TI_STATUS ctrlData_getParamPartial(TI_HANDLE hCtrlData, paramInfoPartial_t *pParamInfo)
510 {
511 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
512
513 switch (pParamInfo->paramType)
514 {
515 case CTRL_DATA_CURRENT_PREAMBLE_TYPE_PARAM:
516 pParamInfo->content.ctrlDataCurrentPreambleType = pCtrlData->ctrlDataCurrentPreambleType;
517 break;
518
519 default:
520 return (PARAM_NOT_SUPPORTED);
521 }
522
523 return (OK);
524 }
525
526 /***************************************************************************
527 * ctrlData_buildSupportedHwRates *
528 ****************************************************************************
529 * DESCRIPTION: builds HwRatesBitMap (supported rates) for txRatePolicy using 4 elements :
530 * 1) AP support
531 * 2) Driver support
532 * 3) Client support (using currClientRateMask[clientIDindex] )
533 * 4) Policy rates (retries per client)
534 *
535 * OUTPUT:
536 *
537 * RETURNS: OK
538 * NOK
539 ***************************************************************************/
ctrlData_buildSupportedHwRates(ctrlData_rateAdapt_t * pDriverTable,UINT32 APsupport,UINT32 clientSupport,UINT32 policySupport)540 static UINT32 ctrlData_buildSupportedHwRates(ctrlData_rateAdapt_t *pDriverTable,
541 UINT32 APsupport,
542 UINT32 clientSupport,
543 UINT32 policySupport)
544 {
545 UINT16 AppRateBitMap = 0;
546 UINT32 HwRatesBitMap, DriverTableBitMap = 0;
547 UINT32 i = 0;
548
549 /* 1. Convert Rates table into bit mask */
550 while (i <= pDriverTable->len)
551 {
552 DriverTableBitMap |= (1 << (pDriverTable->rateAdaptRatesTable[i++] - 1));
553 }
554
555 /* 2. AND with other masks */
556 AppRateBitMap = (UINT16)(DriverTableBitMap & APsupport & clientSupport & policySupport);
557
558 /* In case there are no mutual rates, try to ignore policy settings */
559 if (AppRateBitMap == 0)
560 {
561 AppRateBitMap = (UINT16)(DriverTableBitMap & APsupport);
562 }
563
564 /* 3. Set total supported rates bit map for txRatePolicy */
565 ConvertAppRatesToBitmap(AppRateBitMap, &HwRatesBitMap);
566
567 return HwRatesBitMap;
568 }
569
570
571 /***************************************************************************
572 * ctrlData_setTxRatePolicies *
573 ****************************************************************************
574 * DESCRIPTION: This function sets rate fallback policies to be configured to FW
575 * If TSRS is defined to specific AC, the policy is derived from it,
576 * otherwise it is derived from pre-defined map
577 *
578 * INPUTS: pCtrlData - the object
579 *
580 * RETURNS: -
581 *
582 ***************************************************************************/
ctrlData_setTxRatePolicies(ctrlData_t * pCtrlData)583 static void ctrlData_setTxRatePolicies(ctrlData_t *pCtrlData)
584 {
585 UINT32 ac, policyClassRateMask, supportedHwRatesBitMap, clientIDindex, hwRateIndex;
586 UINT32 fwPolicyID;
587 UINT8 shortRetryLimit, longRetryLimit;
588 txRateClassId_e txRateIndex;
589 whalParamInfo_t param;
590
591 pCtrlData->currClientRateID = pCtrlData->configuredClientRateID;
592
593 for (clientIDindex = 0, fwPolicyID = 0; clientIDindex < NUM_OF_RATE_CLASS_CLIENTS; clientIDindex++)
594 {
595 /* Retrieve retry limits stored in first AC of current class */
596 shortRetryLimit = pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].shortRetryLimit;
597 longRetryLimit = pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].longRetryLimit;
598
599 /* By default assume that this class can be enabled */
600 pCtrlData->bIsClassAvailable[clientIDindex] = TRUE;
601
602 /* Update the rate mask from nextClientRateMask, where it was stored untill now */
603 pCtrlData->currClientRateMask[clientIDindex] = pCtrlData->nextClientRateMask[clientIDindex];
604
605 for (ac = 0; ac < MAX_NUM_OF_AC; ac++)
606 {
607 /* 1. Check if there is special rate set defined for this access category, */
608 /* then verify that at least one rate is mutual between TSRS and class policy, */
609 /* otherwise use default settings for this class */
610 if (pCtrlData->tsrsParameters[ac].supportedRatesMask[clientIDindex] != 0)
611 {
612 /* Check if at least one rate is mutual between TSRS and current class policy, */
613 /* otherwise use default for this class */
614 policyClassRateMask = pCtrlData->tsrsParameters[ac].policyClassRateMask[clientIDindex];
615 }
616 else
617 {
618 policyClassRateMask = ctrlData_buildHwBitMapFromArray(&(pCtrlData->pCurrPolicyClassRatesArray[clientIDindex]));
619 }
620
621 /* 2. Build a bitMap for the supported rates */
622 supportedHwRatesBitMap = ctrlData_buildSupportedHwRates(
623 pCtrlData->ctrlDataCurrentRateTable, /* according to radio mode */
624 pCtrlData->ctrlDataCurrentRateMask, /* AP supported rates */
625 pCtrlData->currClientRateMask[clientIDindex], /* STA supported rates */
626 policyClassRateMask); /* requested by class policy rates */
627
628 if (supportedHwRatesBitMap == 0)
629 {
630 WLAN_REPORT_ERROR(pCtrlData->hReport,CTRL_DATA_MODULE_LOG,
631 ("%s No supported rates for client %d, ac %d \n", __FUNCTION__, clientIDindex, ac));
632 pCtrlData->bIsClassAvailable[clientIDindex] = FALSE;
633 pCtrlData->currClientRateID = USER_RATE_CLASS;
634 }
635
636 /* 3. Configure retransmission for the rates */
637 for (hwRateIndex = HW_BIT_RATE_54MBPS, txRateIndex = txPolicy54;
638 txRateIndex < MAX_NUM_OF_TX_RATES_IN_CLASS;
639 hwRateIndex >>= 1, txRateIndex++)
640 {
641 /* if supported rate */
642 if (supportedHwRatesBitMap & hwRateIndex)
643 {
644 /* if rate fall back is enabled */
645 if (pCtrlData->ctrlDataRateControlEnable)
646 {
647 /* Set retries as they were configured in ini file for this class; */
648 /* make sure at least one retransmission is defined, */
649 /* to take care of cases in which we ignored pre-defined policy */
650 pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].txRate[txRateIndex] =
651 (pCtrlData->pCurrPolicyClassRatesArray[clientIDindex].txRate[txRateIndex] > 1) ?
652 pCtrlData->pCurrPolicyClassRatesArray[clientIDindex].txRate[txRateIndex] : 1;
653 }
654 else /* no rate fallback */
655 {
656 /* set max reties because no fall back is implemented */
657 pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].txRate[txRateIndex] =
658 (shortRetryLimit > longRetryLimit) ? shortRetryLimit : longRetryLimit;
659 pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].flags |= TX_POLICY_FLAGS_TRUNCATE;
660 }
661 }
662 else
663 {
664 pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].txRate[txRateIndex] = 0;
665 }
666
667 WLAN_REPORT_INFORMATION(pCtrlData->hReport,CTRL_DATA_MODULE_LOG,
668 ("%s: AC %d, class %d, rate 0x%x[%d]\n", __FUNCTION__, ac, clientIDindex, hwRateIndex, pCtrlData->ctrlDataTxRatePolicy.rateClass[fwPolicyID].txRate[txRateIndex]));
669 }
670
671 /* Note that Long/Short retries are pre-set during configuration stage */
672
673 /* 4. Finally, increase total number of policies */
674 pCtrlData->tsrsParameters[ac].fwPolicyID[clientIDindex] = fwPolicyID++;
675 }
676 }
677
678 /* Download policies to the FW. Num of policies is 8 - one for each AC for every class */
679 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
680 ("%s: num of Rate policies: %d\n", __FUNCTION__, fwPolicyID));
681
682 pCtrlData->ctrlDataTxRatePolicy.numOfRateClasses = fwPolicyID;
683 param.paramType = HAL_CTRL_TX_RATE_CLASS_PARAMS;
684 param.content.pTxRatePlicy = &pCtrlData->ctrlDataTxRatePolicy;
685
686 whalCtrl_SetParam(pCtrlData->hWhalCtrl, ¶m);
687 }
688
689
690 /***************************************************************************
691 * ctrlData_setParam *
692 ****************************************************************************
693 * DESCRIPTION: set a specific parameter
694 *
695 * INPUTS: hCtrlData - the object
696 * pParamInfo - structure which include the value to set for
697 * the requested parameter
698 *
699 * OUTPUT:
700 *
701 * RETURNS: OK
702 * NOK
703 ***************************************************************************/
704
ctrlData_setParam(TI_HANDLE hCtrlData,paramInfo_t * pParamInfo)705 TI_STATUS ctrlData_setParam(TI_HANDLE hCtrlData, paramInfo_t *pParamInfo)
706 {
707 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
708 whalParamInfo_t param;
709 rateClassClients_e clientID;
710
711 /* WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
712 ("ctrlData_setParam() : param=0x%x \n", pParamInfo->paramType)); */
713
714 switch (pParamInfo->paramType)
715 {
716 case CTRL_DATA_RATE_CONTROL_ENABLE_PARAM:
717 pCtrlData->ctrlDataRateControlEnable = pParamInfo->content.ctrlDataRateControlEnable;
718 selectRateTable(pCtrlData, pCtrlData->ctrlDataCurrentRateMask);
719
720 ctrlData_setTxRatePolicies(pCtrlData);
721
722 rateAdaptation_buildRateMapTable(pCtrlData->pRateAdaptation,
723 pCtrlData->ctrlDataCurrentRateTable,
724 pCtrlData->ctrlDataCurrentRateMask,
725 pCtrlData->currClientRateMask[pCtrlData->currClientRateID],
726 pCtrlData->ctrlDataCurrentModulationType,
727 pCtrlData->ctrlDataCerruentFourXstate,
728 pCtrlData->ctrlDataCurrentBssType);
729
730
731
732
733
734 if(pCtrlData->ctrlDataRateControlEnable == TRUE )
735 {
736 /* start rate adaptation algorithm */
737
738 if( pCtrlData->ctrlDataStartStoplinkControlAlg == TRUE)
739 {
740
741 rateAdaptation_start(pCtrlData->pRateAdaptation);
742 }
743 else
744 {
745 /* stop rate adaptation algorithm */
746 rateAdaptation_stop(pCtrlData->pRateAdaptation);
747 }
748 }
749 else
750 {
751 rateAdaptation_stopTimer(pCtrlData->pRateAdaptation);
752 }
753 break;
754
755 case CTRL_DATA_FOUR_X_ENABLE_PARAM:
756 #ifdef SUPPORT_4X
757 pCtrlData->ctrlDataFourXEnable = pParamInfo->content.ctrlDataFourXEnable;
758 if(pCtrlData->ctrlDataStartStoplinkControlAlg == TRUE)
759 {
760 if(pCtrlData->ctrlDataFourXEnable == TRUE)
761 {
762 pCtrlData->ctrlDataCerruentFourXstate = TRUE;
763 }
764 else
765 {
766 pCtrlData->ctrlDataCerruentFourXstate = FALSE;
767 }
768 }
769 rateAdaptation_update4xEnable(pCtrlData->pRateAdaptation,
770 pCtrlData->ctrlDataCerruentFourXstate,
771 pCtrlData->ctrlDataCurrentBssType );
772
773 #else
774 pCtrlData->ctrlDataFourXEnable = FALSE;
775 pCtrlData->ctrlDataCerruentFourXstate = FALSE;
776 #endif
777 break;
778
779 case CTRL_DATA_CURRENT_RATE_CLASS_CLIENT:
780 /* set a new rate class client to be used on data packets */
781 clientID = pParamInfo->content.ctrlDataRateClassID;
782 /* always save the wanted configuration , even when not enabled */
783 pCtrlData->configuredClientRateID = clientID;
784
785 if (clientID == pCtrlData->currClientRateID)
786 {
787 /* Do nothing - already configured */
788 break;
789 }
790 else
791 {
792 if (TRUE == pCtrlData->bIsClassAvailable[clientID])
793 {
794 /* use the new clientID + reset rateAdaptation tables */
795 pCtrlData->currClientRateID = clientID;
796 selectRateTable(pCtrlData, pCtrlData->ctrlDataCurrentRateMask);
797 rateAdaptation_buildRateMapTable(pCtrlData->pRateAdaptation,
798 pCtrlData->ctrlDataCurrentRateTable,
799 pCtrlData->ctrlDataCurrentRateMask,
800 pCtrlData->currClientRateMask[pCtrlData->currClientRateID],
801 pCtrlData->ctrlDataCurrentModulationType,
802 pCtrlData->ctrlDataCerruentFourXstate,
803 pCtrlData->ctrlDataCurrentBssType);
804 break;
805
806 }
807 else
808 {
809 /* The class could not be configured due to no rate support - don't use it */
810 WLAN_REPORT_ERROR(pCtrlData->hReport,CTRL_DATA_MODULE_LOG,
811 ("%s: Can't enable rate class ID %d\n",__FUNCTION__,clientID));
812 break;
813 }
814 }
815
816 case CTRL_DATA_NEXT_RATE_MASK_FOR_CLIENT:
817 /* configure the next rate mask to be used for a specific client on the next connection */
818 /* NOTE : changing USER_RATE_CLASS configuration is not advisable */
819 pCtrlData->nextClientRateMask[pParamInfo->content.ctrlDataRateClassMask.clientID] =
820 pParamInfo->content.ctrlDataRateClassMask.clientRateMask;
821 break;
822
823 case CTRL_DATA_FOUR_X_CURRRENT_STATUS_PARAM:
824 #ifdef SUPPORT_4X
825 if((pCtrlData->ctrlDataFourXEnable == TRUE) &&
826 (pCtrlData->ctrlDataCurrentBssType == BSS_INFRASTRUCTURE))
827 pCtrlData->ctrlDataCerruentFourXstate = pParamInfo->content.ctrlDataCerruentFourXstate;
828 else
829 pCtrlData->ctrlDataCerruentFourXstate = FALSE;
830 #else
831 pCtrlData->ctrlDataCerruentFourXstate = FALSE;
832 #endif
833 break;
834
835 case CTRL_DATA_CURRENT_BSSID_PARAM:
836 MAC_COPY(pCtrlData->hOs, (&pCtrlData->ctrlDataCurrentBSSID),
837 (&pParamInfo->content.ctrlDataCurrentBSSID));
838 break;
839
840 case CTRL_DATA_CURRENT_BSS_TYPE_PARAM:
841 if( pParamInfo->content.ctrlDataCurrentBssType != BSS_INFRASTRUCTURE &&
842 pParamInfo->content.ctrlDataCurrentBssType != BSS_INDEPENDENT )
843 return(PARAM_VALUE_NOT_VALID);
844
845 pCtrlData->ctrlDataCurrentBssType = pParamInfo->content.ctrlDataCurrentBssType;
846 break;
847
848 case CTRL_DATA_CURRENT_MODULATION_TYPE_PARAM:
849 pCtrlData->ctrlDataCurrentModulationType = pParamInfo->content.ctrlDataCurrentModulationType;
850 /* update rate modulatin table for Rate adaptation algorithm */
851
852 rateAdaptation_updateModulation(pCtrlData->pRateAdaptation,
853 pCtrlData->ctrlDataCurrentModulationType,
854 pCtrlData->ctrlDataCurrentBssType);
855
856 break;
857
858 case CTRL_DATA_CURRENT_PREAMBLE_TYPE_PARAM:
859 if( pParamInfo->content.ctrlDataCurrentPreambleType != PREAMBLE_LONG &&
860 pParamInfo->content.ctrlDataCurrentPreambleType != PREAMBLE_SHORT )
861 return(PARAM_VALUE_NOT_VALID);
862
863 pCtrlData->ctrlDataCurrentPreambleType = pParamInfo->content.ctrlDataCurrentPreambleType;
864
865 break;
866
867 case CTRL_DATA_MAC_ADDRESS:
868 {
869 int status;
870 status = whalCtrl_SetMacAddress(pCtrlData->hWhalCtrl, &pParamInfo->content.ctrlDataDeviceMacAddress);
871 WLAN_REPORT_ERROR(pCtrlData->hReport, TX_DATA_MODULE_LOG,
872 (" ctrlData_setParam() : MAC ADDRESS SET STATUS: %d \n",status));
873 if(status == OK)
874 MAC_COPY(pCtrlData->hOs, (&pCtrlData->ctrlDataDeviceMacAddress),
875 (&pParamInfo->content.ctrlDataDeviceMacAddress));
876
877 }
878 break;
879
880 case CTRL_DATA_CURRENT_BASIC_RATE_PARAM:
881
882 pCtrlData->ctrlDataCurrentBasicRate = pParamInfo->content.ctrlDataCurrentBasicRate;
883 /* for Basic Rate Set use the USER_RATE_CLASS (otherwise we could get 0 rates) */
884 pCtrlData->ctrlDataBasicRateBitMask = rateAdaptation_Utils_buildRateBitMap(pCtrlData->pRateAdaptation,
885 pCtrlData->ctrlDataCurrentRateTable,
886 pCtrlData->ctrlDataCurrentBasicRate,
887 pCtrlData->ctrlDataCurrentRateMask,
888 pCtrlData->currClientRateMask[USER_RATE_CLASS]);
889 break;
890
891 case CTRL_DATA_CURRENT_BASIC_RATE_MASK_PARAM:
892 pCtrlData->ctrlDataBasicRateBitMask = pParamInfo->content.ctrlDataBasicRateBitMask;
893 break;
894
895 case CTRL_DATA_CURRENT_BASIC_MODULATION_PARAM:
896 pCtrlData->ctrlDataCurrentBasicModulationType = pParamInfo->content.ctrlDataCurrentBasicModulationType;
897 break;
898
899
900 case CTRL_DATA_CURRENT_SUPPORTED_RATE_MASK_PARAM:
901 pCtrlData->ctrlDataCurrentRateMask = pParamInfo->content.ctrlDataCurrentRateMask;
902 selectRateTable(pCtrlData, pCtrlData->ctrlDataCurrentRateMask);
903 rateAdaptation_buildRateMapTable(pCtrlData->pRateAdaptation,
904 pCtrlData->ctrlDataCurrentRateTable,
905 pCtrlData->ctrlDataCurrentRateMask,
906 pCtrlData->currClientRateMask[pCtrlData->currClientRateID],
907 (modulationType_e)pCtrlData->ctrlDataCerruentFourXstate,
908 pCtrlData->ctrlDataCurrentModulationType,
909 pCtrlData->ctrlDataCurrentBssType);
910
911
912 break;
913
914 case CTRL_DATA_CURRENT_ACTIVE_RATE_PARAM:
915 rateAdaptation_setCurrentRate(pCtrlData->pRateAdaptation, pParamInfo->content.ctrlDataCurrentActiveRate);
916
917 break;
918
919 case CTRL_DATA_TSRS_PARAM:
920 ctrlData_storeTSRateSet(pCtrlData, &pParamInfo->content.txDataQosParams);
921
922 break;
923
924 case CTRL_DATA_CURRENT_PROTECTION_STATUS_PARAM:
925 if (pCtrlData->ctrlDataProtectionEnabled != pParamInfo->content.ctrlDataProtectionEnabled)
926 {
927 pCtrlData->ctrlDataProtectionEnabled = pParamInfo->content.ctrlDataProtectionEnabled;
928
929 /* set indication also to TNET */
930 param.paramType = HAL_CTRL_CTS_TO_SELF_PARAM;
931 if(pCtrlData->ctrlDataProtectionEnabled == TRUE)
932 param.content.halCtrlCtsToSelf = CTS_TO_SELF_ENABLE;
933 else
934 param.content.halCtrlCtsToSelf = CTS_TO_SELF_DISABLE;
935
936 whalCtrl_SetParam(pCtrlData->hWhalCtrl,¶m);
937
938
939 /* In case of using protection fragmentation should be disabled */
940 param.paramType = HAL_CTRL_FRAG_THRESHOLD_PARAM;
941 if(pCtrlData->ctrlDataProtectionEnabled == TRUE)
942 {
943 /* save last non-protection mode fragmentation threshold */
944 whalCtrl_GetParam(pCtrlData->hWhalCtrl,¶m);
945 pCtrlData->lastFragmentThreshold = param.content.halCtrlFragThreshold;
946 /* set fragmentation threshold to max (disable) */
947 param.content.halCtrlFragThreshold = HAL_CTRL_FRAG_THRESHOLD_MAX;
948 }
949 else
950 param.content.halCtrlFragThreshold = pCtrlData->lastFragmentThreshold;
951
952 whalCtrl_SetParam(pCtrlData->hWhalCtrl,¶m);
953 }
954
955 break;
956
957 case CTRL_DATA_CURRENT_IBSS_PROTECTION_PARAM:
958 pCtrlData->ctrlDataIbssProtectionType = pParamInfo->content.ctrlDataIbssProtecionType;
959
960 /* set indication also to TNET */
961 param.paramType = HAL_CTRL_CTS_TO_SELF_PARAM;
962 if(pCtrlData->ctrlDataIbssProtectionType != ERP_PROTECTION_NONE)
963 param.content.halCtrlCtsToSelf = CTS_TO_SELF_ENABLE;
964 else
965 param.content.halCtrlCtsToSelf = CTS_TO_SELF_DISABLE;
966
967 whalCtrl_SetParam(pCtrlData->hWhalCtrl,¶m);
968
969 break;
970
971 case CTRL_DATA_CURRENT_RTS_CTS_STATUS_PARAM:
972 pCtrlData->ctrlDataRtsCtsStatus = pParamInfo->content.ctrlDataRtsCtsStatus;
973 break;
974 case CTRL_DATA_CLSFR_TYPE:
975 ctrlData_clsfrSetClsfrType (pCtrlData->pClsfr,pParamInfo->content.ctrlDataClsfrType);
976 break;
977
978 case CTRL_DATA_CLSFR_CONFIG:
979 Classifier_InsertClsfrEntry(pCtrlData->pClsfr, 1, &pParamInfo->content.ctrlDataClsfrInsertTable);
980 break;
981
982 case CTRL_DATA_CLSFR_REMOVE_ENTRY:
983 classifier_RemoveClsfrEntry(pCtrlData->pClsfr, &pParamInfo->content.ctrlDataClsfrInsertTable);
984 break;
985
986 case CTRL_DATA_GET_USER_PRIORITY_OF_STREAM:
987 Classifier_deriveUserPriorityFromStream (pCtrlData->pClsfr,&pParamInfo->content.ctrlDataUpOfStream);
988 break;
989 /*
990 * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
991 */
992 case CTRL_DATA_SHORT_RETRY_LIMIT_PARAM:
993 pCtrlData->ctrlDataTxRatePolicy.rateClass[USER_RATE_CLASS].shortRetryLimit = pParamInfo->content.TxRatePolicy.rateClass[USER_RATE_CLASS].shortRetryLimit;
994 break;
995
996 /*
997 * NOTE: currently supporting only ONE txRatePolicy!!!!!!!!!
998 */
999 case CTRL_DATA_LONG_RETRY_LIMIT_PARAM:
1000 pCtrlData->ctrlDataTxRatePolicy.rateClass[USER_RATE_CLASS].longRetryLimit = pParamInfo->content.TxRatePolicy.rateClass[USER_RATE_CLASS].longRetryLimit;
1001 break;
1002
1003 case CTRL_DATA_TOGGLE_TRAFFIC_INTENSITY_EVENTS:
1004
1005 /* Enable or disable events according to flag */
1006 ctrlData_ToggleTrafficIntensityNotification (pCtrlData, (BOOL)pParamInfo->content.ctrlDataTrafficIntensityEventsFlag);
1007
1008 break;
1009
1010 case CTRL_DATA_TRAFFIC_INTENSITY_THRESHOLD:
1011 {
1012 OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS *localParams = &pParamInfo->content.ctrlDataTrafficIntensityThresholds;
1013 BOOL savedEnableFlag; /* Used to save previous enable/disable flag - before stopping/starting events for change in params */
1014
1015 /* If any of the parameters has changed, we need to re-register with the Traffic Monitor */
1016 if ((localParams->uHighThreshold != pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold) ||
1017 (localParams->uLowThreshold != pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold) ||
1018 (localParams->TestInterval != pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval))
1019 {
1020
1021 os_memoryCopy(pCtrlData->hOs, &pCtrlData->ctrlDataTrafficIntensityThresholds,
1022 localParams,
1023 sizeof(OS_802_11_TRAFFIC_INTENSITY_THRESHOLD_PARAMS));
1024
1025 savedEnableFlag = pCtrlData->ctrlDataTrafficIntensityEventsEnabled;
1026
1027 /* Turn off traffic events */
1028 ctrlData_ToggleTrafficIntensityNotification (pCtrlData, FALSE);
1029
1030 /* Unregister current events */
1031 ctrlData_UnregisterTrafficIntensityEvents (pCtrlData);
1032
1033 /* And re-register with new thresholds */
1034 ctrlData_RegisterTrafficIntensityEvents (pCtrlData);
1035
1036 /* Enable events if they were enabled */
1037 ctrlData_ToggleTrafficIntensityNotification (pCtrlData, savedEnableFlag);
1038
1039 }
1040 }
1041
1042 break;
1043
1044 default:
1045 WLAN_REPORT_ERROR(pCtrlData->hReport, TX_DATA_MODULE_LOG,
1046 (" ctrlData_setParam() : PARAMETER NOT SUPPORTED \n"));
1047 return (PARAM_NOT_SUPPORTED);
1048 /* break; - unrechable */
1049 }
1050
1051 return (OK);
1052 }
1053
1054 /***************************************************************************
1055 * ctrlData_getTspecsRateThresholds *
1056 ****************************************************************************
1057 * DESCRIPTION: The function retrieves the current low/high phy rate thresholds.
1058 *
1059 * INPUTS: hCtrlData - the object
1060 * uAC - The AC number.
1061 *
1062 * OUTPUT: pHighThreshold - The current phy rate high threshold
1063 * pHighThreshold - The current phy rate low threshold
1064 *
1065 * RETURNS:
1066 ***************************************************************************/
ctrlData_getTspecsRateThresholds(TI_HANDLE hCtrlData,UINT8 uAC,UINT32 * pHighThreshold,UINT32 * pLowThreshold)1067 void ctrlData_getTspecsRateThresholds(TI_HANDLE hCtrlData, UINT8 uAC, UINT32* pHighThreshold, UINT32* pLowThreshold)
1068 {
1069 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1070 rateAdaptation_t* pRateAdaptation = (rateAdaptation_t*)pCtrlData->pRateAdaptation;
1071
1072 *pHighThreshold = hostToUtilityRate(RateNumberToHost(pRateAdaptation->tspecsRateParameters[uAC].highRateThreshold));
1073 *pLowThreshold = hostToUtilityRate(RateNumberToHost(pRateAdaptation->tspecsRateParameters[uAC].lowRateThreshold));
1074 }
1075
1076 /***************************************************************************
1077 * selectRateTable *
1078 ****************************************************************************
1079 * DESCRIPTION:
1080 *
1081 * INPUTS: hCtrlData - the object
1082 *
1083 * OUTPUT:
1084 *
1085 * RETURNS:
1086 ***************************************************************************/
1087
selectRateTable(TI_HANDLE hCtrlData,UINT32 rateMask)1088 static void selectRateTable(TI_HANDLE hCtrlData, UINT32 rateMask)
1089 {
1090 paramInfo_t param;
1091 rate_e rate;
1092
1093 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1094
1095 rate = getMaxRatefromBitmap(rateMask);
1096
1097 param.paramType = SITE_MGR_OPERATIONAL_MODE_PARAM;
1098 siteMgr_getParam(pCtrlData->hSiteMgr, ¶m);
1099
1100 switch(param.content.siteMgrDot11OperationalMode)
1101 {
1102 case DOT11_B_MODE:
1103 {
1104 if(rate == DRV_RATE_22M)
1105 {
1106 pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataPbccRateTable;
1107 pCtrlData->pCurrPolicyClassRatesArray = pCtrlData->policyClassRatesArrayPbcc;
1108 }
1109 else
1110 {
1111 pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataCckRateTable;
1112 pCtrlData->pCurrPolicyClassRatesArray = pCtrlData->policyClassRatesArrayCck;
1113
1114 }
1115 }
1116 break;
1117
1118 case DOT11_G_MODE:
1119 if( (rate == DRV_RATE_22M) ||
1120 (rate == DRV_RATE_11M) ||
1121 (rate == DRV_RATE_5_5M)||
1122 (rate == DRV_RATE_2M) ||
1123 (rate == DRV_RATE_1M) )
1124 {
1125 pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataPbccRateTable;
1126 pCtrlData->pCurrPolicyClassRatesArray = pCtrlData->policyClassRatesArrayPbcc;
1127 }
1128 else
1129 {
1130 pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataOfdmRateTable ;
1131 pCtrlData->pCurrPolicyClassRatesArray = pCtrlData->policyClassRatesArrayOfdm;
1132 }
1133 break;
1134
1135 case DOT11_A_MODE:
1136 pCtrlData->ctrlDataCurrentRateTable = &pCtrlData->ctrlDataRateTables.ctrlDataOfdmARateTable;
1137 pCtrlData->pCurrPolicyClassRatesArray = pCtrlData->policyClassRatesArrayOfdmA;
1138
1139 break;
1140 case DOT11_DUAL_MODE:
1141 case DOT11_MAX_MODE:
1142 WLAN_REPORT_ERROR(pCtrlData->hReport,CTRL_DATA_MODULE_LOG,
1143 ("%s ctrlDataCurrentRateTable not configured !!!",__FUNCTION__));
1144 break;
1145
1146 }
1147
1148
1149
1150 }
1151
1152 /***************************************************************************
1153 * ctrlData_start *
1154 ****************************************************************************
1155 * DESCRIPTION: This function start the link control algorithms. It start
1156 * each algorithm (Rate Adaptation) if needed.
1157 *
1158 * INPUTS: hCtrlData - the object
1159 *
1160 * OUTPUT:
1161 *
1162 * RETURNS: OK
1163 * NOK
1164 ***************************************************************************/
1165
ctrlData_start(TI_HANDLE hCtrlData)1166 TI_STATUS ctrlData_start(TI_HANDLE hCtrlData)
1167 {
1168 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1169
1170 pCtrlData->ctrlDataStartStoplinkControlAlg = TRUE;
1171
1172
1173 /* start Rate Adaptation if needed */
1174 if(pCtrlData->ctrlDataRateControlEnable == TRUE)
1175 {
1176 rateAdaptation_start(pCtrlData->pRateAdaptation);
1177 }
1178
1179
1180 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1181 (" ctrlData_start() : Link control algorithms started successfully \n"));
1182
1183 return OK;
1184 }
1185
1186 /***************************************************************************
1187 * ctrlData_stop *
1188 ****************************************************************************
1189 * DESCRIPTION: This function stop the link control algorithms.
1190 *
1191 * INPUTS: hCtrlData - the object
1192 *
1193 * OUTPUT:
1194 *
1195 * RETURNS: OK
1196 * NOK
1197 ***************************************************************************/
1198
ctrlData_stop(TI_HANDLE hCtrlData)1199 TI_STATUS ctrlData_stop(TI_HANDLE hCtrlData)
1200 {
1201 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1202
1203 /* stop link control algorithm */
1204 pCtrlData->ctrlDataStartStoplinkControlAlg = FALSE;
1205
1206 /* set modulation option to default value*/
1207 pCtrlData->ctrlDataCurrentModulationType = DEF_CURRENT_MUDULATION_TYPE;
1208
1209 /* set Preamble length option to default value*/
1210 pCtrlData->ctrlDataCurrentPreambleType = DEF_CURRENT_PREAMBLE;
1211
1212 /* set mgmt rate to default value */
1213 pCtrlData->ctrlDataCurrentBasicRate = DEF_BASIC_RATE;
1214 pCtrlData->ctrlDataBasicRateBitMask = DEF_BASIC_RATE_MASK;
1215 pCtrlData->ctrlDataCurrentBasicModulationType = DRV_MODULATION_QPSK;
1216
1217 os_memoryZero(pCtrlData->hOs,
1218 &pCtrlData->tsrsParameters,
1219 sizeof(pCtrlData->tsrsParameters));
1220
1221 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1222 (" ctrlData_stop() : Link control algorithms stoped \n"));
1223
1224 rateAdaptation_stop(pCtrlData->pRateAdaptation);
1225
1226 return OK;
1227 }
1228
1229 /***************************************************************************
1230 * ctrlData_receiveParamFromRx *
1231 ****************************************************************************
1232 * DESCRIPTION: This function receive Msdu Rx parameters from the Rx data
1233 * module, update counters.
1234 *
1235 * INPUTS: hCtrlData - the object
1236 * pRxMsduInfo - Information about the receive msdu
1237 * OUTPUT:
1238 *
1239 * RETURNS: OK
1240 * NOK
1241 ***************************************************************************/
1242 #ifdef SUPPORT_4X
ctrlData_rxMsdu(TI_HANDLE hCtrlData,mem_MSDU_T ** pRxMsdu)1243 TI_STATUS ctrlData_rxMsdu(TI_HANDLE hCtrlData,
1244 mem_MSDU_T **pRxMsdu)
1245 {
1246 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1247
1248 if(pCtrlData->ctrlDataStartStoplinkControlAlg == FALSE)
1249 return OK;
1250
1251 if((pCtrlData->ctrlDataFourXEnable == TRUE) &&
1252 (pCtrlData->ctrlDataCurrentBssType == BSS_INFRASTRUCTURE))
1253 {
1254 /* Call fourX function */
1255 if(fourX_rxMsdu(pCtrlData->pFourX, pRxMsdu) != OK)
1256 {
1257 WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1258 (" failed in fourX_rxMsdu\n"));
1259 return NOK;
1260 }
1261 }
1262
1263 return OK;
1264 }
1265 #endif
1266 /***************************************************************************
1267 * ctrlData_getTxAttributes *
1268 ****************************************************************************
1269 * DESCRIPTION: This function set the transmited parameters for a
1270 * specific msdu
1271 *
1272 * INPUTS: hCtrlData - the object
1273 * txFlags - Information about the msdu
1274 *
1275 * OUTPUT: pTxAttr - pointer to the tx parameters structure
1276 *
1277 * RETURNS: OK
1278 * NOK
1279 ***************************************************************************/
1280
ctrlData_getTxAttributes(TI_HANDLE hCtrlData,UINT32 txFlags,txData_attr_t * pTxAttr,UINT32 ac)1281 TI_STATUS ctrlData_getTxAttributes(TI_HANDLE hCtrlData, UINT32 txFlags,
1282 txData_attr_t *pTxAttr, UINT32 ac)
1283 {
1284 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1285 rateModulation4x_table_t* pRateModulation;
1286
1287 os_memoryZero(pCtrlData->hOs, pTxAttr, sizeof(txData_attr_t));
1288
1289
1290 if( ((txFlags & TX_DATA_MULTICAST_FRAME) && (pCtrlData->ctrlDataCurrentBssType == BSS_INDEPENDENT)) ||
1291 (txFlags & TX_DATA_MGMT_MSDU) )
1292 {
1293 /* BCAST packets in IBSS should be sent at 2M and not in the highest basic rate. */
1294 if (pCtrlData->ctrlDataCurrentRateMask & DRV_RATE_MASK_2_BARKER)
1295 {
1296 pTxAttr->Rate = DRV_RATE_2M;
1297 }
1298 else
1299 {
1300 pTxAttr->Rate = ctrlData_getClosestTSRate(pCtrlData, ac, pCtrlData->ctrlDataCurrentBasicRate);
1301 }
1302
1303 /* by default use USER_RATE_CLASS for this kind of packets */
1304 pTxAttr->txRatePolicyId = pCtrlData->tsrsParameters[ac].fwPolicyID[USER_RATE_CLASS];
1305 }
1306 /* For regular data packets use the rate-adaptation rates. */
1307 else
1308 {
1309 pRateModulation = rateAdaptation_getCurrent(pCtrlData->pRateAdaptation);
1310 pTxAttr->Rate = ctrlData_getClosestTSRate(pCtrlData, ac, pRateModulation->rate);
1311
1312 /* rate class Id ( retries profile per rate) */
1313 pTxAttr->txRatePolicyId = pCtrlData->tsrsParameters[ac].fwPolicyID[pCtrlData->currClientRateID];
1314
1315 /* For voice delivery PSPoll, use only basic rates */
1316 if (txFlags & TX_DATA_PS_POLL)
1317 {
1318 paramInfo_t param;
1319 modulationType_e tempModulation;
1320
1321 param.paramType = SITE_MGR_OPERATIONAL_MODE_PARAM;
1322 siteMgr_getParam(pCtrlData->hSiteMgr, ¶m);
1323
1324 /* Get the max rate and modulation from the BasicRateBitMask. */
1325 getMaxRate(pCtrlData->ctrlDataBasicRateBitMask,
1326 &pTxAttr->Rate,
1327 &tempModulation,
1328 param.content.siteMgrDot11OperationalMode);
1329 }
1330
1331
1332 }
1333
1334 /* convert Application rate to HW rate */
1335 ConvertAppRateToHwBitMapRate(pTxAttr->Rate, &(pTxAttr->HwRate));
1336
1337 WLAN_REPORT_DEBUG_TX(pCtrlData->hReport,
1338 ("%s: Rate = %d, HwRate = 0x%x\n",
1339 __FUNCTION__,
1340 pTxAttr->Rate,
1341 pTxAttr->HwRate));
1342
1343 return OK;
1344 }
1345
1346 /***************************************************************************
1347 * ctrlData_txCompleteStatus *
1348 ****************************************************************************
1349 * DESCRIPTION: This function is called by the Hal for every Tx supportedBitMap
1350 * Interrupt - it update the rate adaptation algorithm about
1351 * the status of the last transmission and used as a trigger
1352 * for the Tx scheduler.
1353 *
1354 * INPUTS: hCtrlData - the object
1355 * CmpltTxAttr - Information structure about the last
1356 * transmission
1357 *
1358 * OUTPUT:
1359 *
1360 * RETURNS: void
1361 ***************************************************************************/
ctrlData_txCompleteStatus(TI_HANDLE hCtrlData,txCompleteAttr_t * pTxCompleteAttr)1362 void ctrlData_txCompleteStatus( TI_HANDLE hCtrlData,
1363 txCompleteAttr_t *pTxCompleteAttr )
1364 {
1365 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1366 UINT8 txCompleteFlags;
1367 BOOL frameDataType = 0;
1368 rate_e txActualRate;
1369 rate_e txRequestRate;
1370 UINT8 qId;
1371 txPacketIdAttr_t *pPacketId = (txPacketIdAttr_t*)pTxCompleteAttr->packetId;
1372
1373
1374 /*
1375 * perform rate adaptation algorithm if host processes packets
1376 * and not TNET.
1377 * NOTE: MSDU was already freed in sendPacketTransfer
1378 */
1379 frameDataType = pPacketId->bDataMsdu;
1380 qId = pPacketId->txQid;
1381
1382 ConvertHwBitRateToAppRate(pTxCompleteAttr->rate, &txActualRate);
1383 ConvertHwBitRateToAppRate(pPacketId->maxTransmitRate, &txRequestRate);
1384
1385 /* perform rate adaptation algorithm if needed */
1386 if((pCtrlData->ctrlDataRateControlEnable == TRUE ) &&
1387 (pCtrlData->ctrlDataStartStoplinkControlAlg == TRUE) &&
1388 (frameDataType))
1389
1390 {
1391 rateAdaptation_updateRateAdaptation(pCtrlData->pRateAdaptation, txActualRate,
1392 txRequestRate,pTxCompleteAttr->status, 0);
1393 }
1394 txCompleteFlags = pPacketId->txCompleteFlags;
1395
1396 if(txCompleteFlags & TX_DATA_DISASSOC_SYNC_TRIG)
1397 {
1398 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,("Call disconnect test upon NULL data"));
1399 pCtrlData->disassocSentCBFunc( pCtrlData->disassocSentCBObj );
1400 }
1401
1402
1403 if(txCompleteFlags & TX_DATA_DEAUTH_SYNC_TRIG)
1404 {
1405 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1406 ("De Auth TxCmplt: txStatus = %d, txActualRate = %d \n",pTxCompleteAttr->status,pTxCompleteAttr->rate));
1407 pCtrlData->disassocSentCBFunc( pCtrlData->disassocSentCBObj );
1408 }
1409
1410 if(txData_isQueueUseMediumTime(pCtrlData->hTxData , qId) == TRUE )
1411 {
1412 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1413 (" ctrlData_txCompleteStatus() :usedTime = %d qNum = %d\n",
1414 pTxCompleteAttr->actualDurationInAir, qId));
1415
1416 txData_updateUsedTime(pCtrlData->hTxData,
1417 qId,
1418 pTxCompleteAttr->actualDurationInAir);
1419 }
1420 /*
1421 * update tx complete status to txData (which schedule another packet also );
1422 */
1423 txData_txCompleteUpdate( pCtrlData->hTxData, pTxCompleteAttr );
1424
1425 }
1426
1427 /***************************************************************************
1428 * ctrlData_resetCounters *
1429 ****************************************************************************
1430 * DESCRIPTION: This function reset the Ctrl Data module counters
1431 *
1432 * INPUTS: hCtrlData - the object
1433 *
1434 * OUTPUT:
1435 *
1436 * RETURNS: void
1437 ***************************************************************************/
ctrlData_resetCounters(TI_HANDLE hCtrlData)1438 static void ctrlData_resetCounters(TI_HANDLE hCtrlData)
1439 {
1440 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1441
1442 os_memoryZero(pCtrlData->hOs,&pCtrlData->ctrlDataCounters,
1443 sizeof(ctrlDataCounters_t));
1444 }
1445
1446 /***************************************************************************
1447 * ctrlData_getCurrBssTypeAndCurrBssId *
1448 ****************************************************************************
1449 * DESCRIPTION: This function return the current BSSID and the
1450 * current BSS Type
1451 *
1452 * INPUTS: hCtrlData - the object
1453 *
1454 * OUTPUT: pCurrBssid - pointer to return the current bssid
1455 * pCurrBssType - pointer to return the current bss type
1456 *
1457 * RETURNS: void
1458 ***************************************************************************/
ctrlData_getCurrBssTypeAndCurrBssId(TI_HANDLE hCtrlData,macAddress_t * pCurrBssid,bssType_e * pCurrBssType)1459 void ctrlData_getCurrBssTypeAndCurrBssId(TI_HANDLE hCtrlData, macAddress_t *pCurrBssid,
1460 bssType_e *pCurrBssType)
1461 {
1462 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1463
1464 MAC_COPY(pCtrlData->hOs, (pCurrBssid), (&pCtrlData->ctrlDataCurrentBSSID));
1465 *pCurrBssType = pCtrlData->ctrlDataCurrentBssType;
1466
1467 }
1468
1469 #ifdef SUPPORT_4X
1470 /***************************************************************************
1471 * ctrlData_get4xInfoElemnt *
1472 ****************************************************************************
1473 * DESCRIPTION:
1474 *
1475 * INPUTS: hCtrlData - the object
1476 *
1477 * OUTPUT:
1478 *
1479 * RETURNS:
1480 ***************************************************************************/
ctrlData_get4xInfoElemnt(TI_HANDLE hCtrlData,dot11_4X_t * fourXInfoElemnt)1481 TI_STATUS ctrlData_get4xInfoElemnt(TI_HANDLE hCtrlData,
1482 dot11_4X_t* fourXInfoElemnt)
1483 {
1484 TI_STATUS Status = NOK;
1485
1486 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1487
1488 if((pCtrlData->ctrlDataFourXEnable == TRUE) &&
1489 (pCtrlData->ctrlDataCurrentBssType == BSS_INFRASTRUCTURE))
1490 {
1491 Status = fourXManager_get4xInfoElemnt(pCtrlData->pFourX, fourXInfoElemnt);
1492 }
1493
1494 return Status;
1495 }
1496 #endif
1497 /***************************************************************************
1498 * ctrlData_get4xStatus *
1499 ****************************************************************************
1500 * DESCRIPTION:
1501 *
1502 * INPUTS: hCtrlData - the object
1503 *
1504 * OUTPUT:
1505 *
1506 * RETURNS:
1507 ***************************************************************************/
ctrlData_get4xStatus(TI_HANDLE hCtrlData,BOOL * fourXEnable)1508 TI_STATUS ctrlData_get4xStatus(TI_HANDLE hCtrlData,BOOL* fourXEnable)
1509 {
1510 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1511
1512 *fourXEnable = pCtrlData->ctrlDataCerruentFourXstate;
1513 return OK;
1514 }
1515 #ifdef SUPPORT_4X
1516 /***************************************************************************
1517 * ctrlData_evalSite *
1518 ****************************************************************************
1519 * DESCRIPTION:
1520 *
1521 * INPUTS: hCtrlData - the object
1522 *
1523 * OUTPUT:
1524 *
1525 * RETURNS:
1526 ***************************************************************************/
ctrlData_evalSite(TI_HANDLE hCtrlData,dot11_4X_t * site4xParams,UINT32 * matchingLevel)1527 TI_STATUS ctrlData_evalSite(TI_HANDLE hCtrlData,
1528 dot11_4X_t* site4xParams,
1529 UINT32 *matchingLevel)
1530 {
1531 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1532
1533 if((pCtrlData->ctrlDataFourXEnable == TRUE) &&
1534 (pCtrlData->ctrlDataCurrentBssType == BSS_INFRASTRUCTURE))
1535 {
1536 return (fourXManager_evalSite(pCtrlData->pFourX, site4xParams, matchingLevel));
1537 }
1538
1539 return OK;
1540 }
1541 #endif
1542 /***************************************************************************
1543 * ctrlData_setSite *
1544 ****************************************************************************
1545 * DESCRIPTION:
1546 *
1547 * INPUTS: hCtrlData - the object
1548 *
1549 * OUTPUT:
1550 *
1551 * RETURNS:
1552 ***************************************************************************/
1553
ctrlData_setSite(TI_HANDLE hCtrlData,dot11_4X_t * site4xParams)1554 TI_STATUS ctrlData_setSite(TI_HANDLE hCtrlData,
1555 dot11_4X_t* site4xParams)
1556 {
1557 TI_STATUS status = NOK;
1558 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1559 #ifdef SUPPORT_4X
1560 if((pCtrlData->ctrlDataFourXEnable == TRUE) &&
1561 (pCtrlData->ctrlDataCurrentBssType == BSS_INFRASTRUCTURE))
1562 {
1563 status = fourXManager_setSite(pCtrlData->pFourX, site4xParams);
1564 }
1565 #endif
1566 if(status != OK)
1567 pCtrlData->ctrlDataCerruentFourXstate = FALSE;
1568 else
1569 pCtrlData->ctrlDataCerruentFourXstate = TRUE;
1570
1571 return status;
1572 }
1573
1574 #ifdef SUPPORT_4X
1575 /***************************************************************************
1576 * ctrlData_txDequeueMsdu *
1577 ****************************************************************************
1578 * DESCRIPTION:
1579 *
1580 * INPUTS: hCtrlData - the object
1581 *
1582 * OUTPUT:
1583 *
1584 * RETURNS:
1585 ***************************************************************************/
ctrlData_txDequeueMsdu(TI_HANDLE hCtrlData,mem_MSDU_T ** buildMsduPtr,MsduList_t * pMsduList,whalTx_attr_t * pWhalTx_attr,hwTxInformation_t * pHwTxInformation)1586 TI_STATUS ctrlData_txDequeueMsdu(TI_HANDLE hCtrlData,
1587 mem_MSDU_T** buildMsduPtr,
1588 MsduList_t* pMsduList,
1589 whalTx_attr_t* pWhalTx_attr,
1590 hwTxInformation_t* pHwTxInformation)
1591 {
1592 TI_STATUS status;
1593 UINT32 currNumOfMsdu;
1594
1595 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1596
1597 *buildMsduPtr = NULL;
1598
1599 currNumOfMsdu = msduList_getCurrNumOfMsdu(pMsduList);
1600 if(currNumOfMsdu == 0)
1601 return DO_NOT_SEND_MSDU;
1602
1603 if(pCtrlData->ctrlDataCerruentFourXstate == TRUE)
1604 {
1605 /* call 4x */
1606 status = fourX_txMsduDeQueue(pCtrlData->pFourX, buildMsduPtr, pMsduList, pHwTxInformation);
1607 if(status != OK)
1608 {
1609 return DO_NOT_SEND_MSDU;
1610 }
1611
1612 ctrlData_getTxAttributes(pCtrlData, (*buildMsduPtr)->txFlags, pWhalTx_attr, QOS_AC_BE); /* stub */
1613 return SEND_ONE_MSDU;
1614
1615 }
1616 return FOUR_X_DISABLE;
1617
1618 }
1619
1620 /***************************************************************************
1621 * ctrlData_txMsdu *
1622 ****************************************************************************
1623 * DESCRIPTION:
1624 *
1625 * INPUTS: hCtrlData - the object
1626 *
1627 * OUTPUT:
1628 *
1629 * RETURNS:
1630 ***************************************************************************/
ctrlData_txMsdu(TI_HANDLE hCtrlData,mem_MSDU_T ** msduPtr)1631 TI_STATUS ctrlData_txMsdu(TI_HANDLE hCtrlData,
1632 mem_MSDU_T** msduPtr)
1633 {
1634 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1635
1636 if(pCtrlData->ctrlDataCerruentFourXstate == TRUE)
1637 {
1638 fourX_txMsduBeforInsertToQueue(pCtrlData->pFourX, msduPtr);
1639 }
1640
1641 return OK;
1642 }
1643 #endif /* SUPPORT_4X */
1644
1645 /***************************************************************************
1646 * ctrlData_setTspecsRateEvent *
1647 ****************************************************************************
1648 * DESCRIPTION:
1649 *
1650 * INPUTS: hCtrlData - the object
1651 *
1652 * OUTPUT:
1653 *
1654 * RETURNS:
1655 ***************************************************************************/
1656
ctrlData_setTspecsRateEvent(TI_HANDLE hCtrlData,UINT8 acID,BOOL enableEvent)1657 void ctrlData_setTspecsRateEvent(TI_HANDLE hCtrlData,
1658 UINT8 acID,
1659 BOOL enableEvent)
1660 {
1661 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1662
1663 rateAdaptation_setTspecsRateEvent(pCtrlData->pRateAdaptation, acID, enableEvent);
1664
1665 }
1666
1667 /***************************************************************************
1668 * ctrlData_setTspecsRateThresholds *
1669 ****************************************************************************
1670 * DESCRIPTION:
1671 *
1672 * INPUTS: hCtrlData - the object
1673 *
1674 * OUTPUT:
1675 *
1676 * RETURNS:
1677 ***************************************************************************/
1678
ctrlData_setTspecsRateThresholds(TI_HANDLE hCtrlData,UINT8 acID,UINT8 highRateThreshold,UINT8 lowRateThreshold)1679 void ctrlData_setTspecsRateThresholds(TI_HANDLE hCtrlData,
1680 UINT8 acID,
1681 UINT8 highRateThreshold,
1682 UINT8 lowRateThreshold)
1683 {
1684 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1685
1686 rateAdaptation_setTspecsRateThresholds(pCtrlData->pRateAdaptation, acID, highRateThreshold, lowRateThreshold);
1687 }
1688
1689 /************************************************************************
1690 * Classifier functions
1691 ************************************************************************ */
1692
1693 /************************************************************************
1694 * ctrlData_clsfrClassifyTxMSDU
1695 ************************************************************************
1696
1697 Input:
1698
1699 * hCtrlData: hCtrlData - the object
1700 * pMsdu: pointer to the MSDU
1701 * packet_DTag: NDIS Packet 802.1 user priority (UP)
1702
1703 Output:
1704
1705 OK on success and PARAM_VALUE_NOT_VALID in case of input parameters problems.
1706 If the value PARAM_VALUE_NOT_VALID is returned, the MSDU qosTag field is zero.
1707
1708 Description:
1709
1710 This function performs the classification algorithm on the MSDU by calling the
1711 Classifier_classifyTxMSDU API.
1712
1713 ************************************************************************/
1714
ctrlData_ClsfrClassifyTxMSDU(TI_HANDLE hCtrlData,mem_MSDU_T * pMsdu,UINT8 packet_DTag)1715 TI_STATUS ctrlData_ClsfrClassifyTxMSDU(TI_HANDLE hCtrlData,
1716 mem_MSDU_T *pMsdu,
1717 UINT8 packet_DTag)
1718 {
1719 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1720
1721 /* check parameters validity */
1722 if(!hCtrlData)
1723 return NOK;
1724
1725 if (pMsdu == NULL)
1726 {
1727 WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1728 (" ctrlData_ClsfrClassifyTxMSDU() : parametrs value error (the MSDU's qosTag is not updated) \n"));
1729 return PARAM_VALUE_NOT_VALID;
1730 }
1731
1732 return (Classifier_classifyTxMSDU(pCtrlData->pClsfr, pMsdu, packet_DTag));
1733
1734 }
1735
1736
1737
1738 /************************************************************************
1739 * ctrlData_clsfrSetClsfrType
1740 ************************************************************************
1741
1742 Input:
1743
1744 * hCtrlData: hCtrlData - the object
1745 * newClsfrType: the new classifier type
1746
1747 Output:
1748
1749 OK on success and PARAM_VALUE_NOT_VALID in case of input parameters problems.
1750 If the value PARAM_VALUE_NOT_VALID is returned, the classifier type is not updated.
1751
1752 Description:
1753
1754 This function changes the active classifier type by calling the
1755 Classifier_setClsfrType API.
1756
1757 ************************************************************************/
1758
1759
ctrlData_clsfrSetClsfrType(TI_HANDLE hCtrlData,clsfrTypeAndSupport newClsfrType)1760 TI_STATUS ctrlData_clsfrSetClsfrType(TI_HANDLE hCtrlData,
1761 clsfrTypeAndSupport newClsfrType)
1762 {
1763 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1764 /* check parameters validity */
1765 if(!hCtrlData)
1766 return PARAM_VALUE_NOT_VALID;
1767
1768 return (Classifier_setClsfrType(pCtrlData->pClsfr, (clsfr_type_e)newClsfrType.ClsfrType));
1769
1770 }
1771
1772
1773 /*-----------------------------------------------------------------------------
1774 Routine Name: ctrlData_ToggleTrafficIntensityNotification
1775 Routine Description: turns ON/OFF traffic intensity notification events
1776 from Traffic Monitor module
1777 Arguments:
1778 Return Value:
1779 -----------------------------------------------------------------------------*/
ctrlData_ToggleTrafficIntensityNotification(TI_HANDLE hCtrlData,BOOL enabledFlag)1780 void ctrlData_ToggleTrafficIntensityNotification (TI_HANDLE hCtrlData, BOOL enabledFlag)
1781 {
1782 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1783 UINT8 idx;
1784
1785 if (enabledFlag)
1786 {
1787 for (idx=0; idx < CTRL_DATA_TRAFFIC_INTENSITY_MAX_EVENTS; idx++)
1788 {
1789 TrafficMonitor_StartEventNotif (pCtrlData->hTrafficMonitor,pCtrlData->ctrlDataTrafficThresholdEvents[idx]);
1790 }
1791 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1792 ("ctrlData_ToggleTrafficIntensityNotification (TRUE)\n"));
1793 }
1794 else
1795 {
1796 for (idx=0; idx < CTRL_DATA_TRAFFIC_INTENSITY_MAX_EVENTS; idx++)
1797 {
1798 TrafficMonitor_StopEventNotif (pCtrlData->hTrafficMonitor,pCtrlData->ctrlDataTrafficThresholdEvents[idx]);
1799 }
1800 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1801 ("ctrlData_ToggleTrafficIntensityNotification (FALSE)\n"));
1802 }
1803 pCtrlData->ctrlDataTrafficIntensityEventsEnabled = enabledFlag;
1804
1805 }
1806
1807 /*-----------------------------------------------------------------------------
1808 Routine Name: ctrlData_UnregisterTrafficIntensityEvents
1809 Routine Description: unregisters existing events from traffic monitor
1810 Arguments:
1811 Return Value:
1812 -----------------------------------------------------------------------------*/
ctrlData_UnregisterTrafficIntensityEvents(TI_HANDLE hCtrlData)1813 static void ctrlData_UnregisterTrafficIntensityEvents (TI_HANDLE hCtrlData)
1814 {
1815 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1816 UINT8 idx;
1817
1818 /* Loop through events and unregister them */
1819 for (idx=0; idx < CTRL_DATA_TRAFFIC_INTENSITY_MAX_EVENTS; idx++)
1820 {
1821 TrafficMonitor_UnregEvent (pCtrlData->hTrafficMonitor,pCtrlData->ctrlDataTrafficThresholdEvents[idx]);
1822 }
1823
1824 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1825 ("ctrlData_UnregisterTrafficIntensityEvents: Unregistered all events\n"));
1826
1827 }
1828
1829
1830 /*-----------------------------------------------------------------------------
1831 Routine Name: ctrlData_RegisterTrafficIntensityEvents
1832 Routine Description: Registers traffic intensity threshold events through traffic monitor
1833 Arguments:
1834 Return Value:
1835 -----------------------------------------------------------------------------*/
ctrlData_RegisterTrafficIntensityEvents(TI_HANDLE hCtrlData)1836 static void ctrlData_RegisterTrafficIntensityEvents (TI_HANDLE hCtrlData)
1837 {
1838 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
1839 TrafficAlertRegParm_t TrafficAlertRegParm;
1840 TI_STATUS status;
1841
1842 /* Register high threshold "direction up" event */
1843 TrafficAlertRegParm.CallBack = ctrlData_TrafficThresholdCrossed;
1844 TrafficAlertRegParm.Context = hCtrlData;
1845 TrafficAlertRegParm.Cookie = CTRL_DATA_TRAFFIC_INTENSITY_HIGH_CROSSED_ABOVE;
1846 TrafficAlertRegParm.Direction = TRAFF_UP;
1847 TrafficAlertRegParm.Trigger = TRAFF_EDGE;
1848 TrafficAlertRegParm.TimeIntervalMs = pCtrlData->ctrlDataTrafficIntensityThresholds.TestInterval;
1849 TrafficAlertRegParm.Threshold = pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold;
1850 TrafficAlertRegParm.MonitorType = TX_RX_DIRECTED_FRAMES;
1851 pCtrlData->ctrlDataTrafficThresholdEvents[0] = TrafficMonitor_RegEvent(pCtrlData->hTrafficMonitor,&TrafficAlertRegParm,FALSE);
1852
1853 if (pCtrlData->ctrlDataTrafficThresholdEvents[0] == NULL)
1854 {
1855 WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1856 (" ctrlData_RegisterTrafficIntensityEvents() : Failed to register high treshold event (TRAFF_UP) \n"));
1857 return;
1858 }
1859
1860 /* Register high threshold "direction down" event*/
1861 TrafficAlertRegParm.Cookie = CTRL_DATA_TRAFFIC_INTENSITY_HIGH_CROSSED_BELOW;
1862 TrafficAlertRegParm.Direction = TRAFF_DOWN;
1863 TrafficAlertRegParm.Trigger = TRAFF_EDGE;
1864 TrafficAlertRegParm.Threshold = pCtrlData->ctrlDataTrafficIntensityThresholds.uHighThreshold;
1865 pCtrlData->ctrlDataTrafficThresholdEvents[1] = TrafficMonitor_RegEvent(pCtrlData->hTrafficMonitor,&TrafficAlertRegParm,FALSE);
1866
1867 if (pCtrlData->ctrlDataTrafficThresholdEvents[1] == NULL)
1868 {
1869 WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1870 (" ctrlData_RegisterTrafficIntensityEvents() : Failed to register high treshold event (TRAFF_DOWN) \n"));
1871 return;
1872 }
1873
1874 /* Define the "direction below" and "direction above" events as opposites (events that reset eachother)*/
1875 status = TrafficMonitor_SetRstCondition(pCtrlData->hTrafficMonitor,
1876 pCtrlData->ctrlDataTrafficThresholdEvents[0],
1877 pCtrlData->ctrlDataTrafficThresholdEvents[1],
1878 TRUE);
1879
1880 if (status != OK)
1881 {
1882 WLAN_REPORT_ERROR (pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1883 ("ctrlData_RegisterTrafficIntensityEvents: TrafficMonitor_SetRstCondition returned status = %d\n",status));
1884 }
1885
1886 /* Register low threshold "direction up" event */
1887 TrafficAlertRegParm.Cookie = CTRL_DATA_TRAFFIC_INTENSITY_LOW_CROSSED_ABOVE;
1888 TrafficAlertRegParm.Direction = TRAFF_UP;
1889 TrafficAlertRegParm.Trigger = TRAFF_EDGE;
1890 TrafficAlertRegParm.Threshold = pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold;
1891 pCtrlData->ctrlDataTrafficThresholdEvents[2] = TrafficMonitor_RegEvent(pCtrlData->hTrafficMonitor,&TrafficAlertRegParm,FALSE);
1892
1893 if (pCtrlData->ctrlDataTrafficThresholdEvents[2] == NULL)
1894 {
1895 WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1896 (" ctrlData_RegisterTrafficIntensityEvents() : Failed to register low treshold event (TRAFF_UP) \n"));
1897 return;
1898 }
1899
1900 /* Register low threshold "direction below" event */
1901 TrafficAlertRegParm.Cookie = CTRL_DATA_TRAFFIC_INTENSITY_LOW_CROSSED_BELOW;
1902 TrafficAlertRegParm.Direction = TRAFF_DOWN;
1903 TrafficAlertRegParm.Trigger = TRAFF_EDGE;
1904 TrafficAlertRegParm.Threshold = pCtrlData->ctrlDataTrafficIntensityThresholds.uLowThreshold;
1905 pCtrlData->ctrlDataTrafficThresholdEvents[3] = TrafficMonitor_RegEvent(pCtrlData->hTrafficMonitor,&TrafficAlertRegParm,FALSE);
1906
1907 if (pCtrlData->ctrlDataTrafficThresholdEvents[3] == NULL)
1908 {
1909 WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1910 (" ctrlData_RegisterTrafficIntensityEvents() : Failed to register low treshold event (TRAFF_DOWN) \n"));
1911 return;
1912 }
1913
1914 /* Define the "direction below" and "direction above" events as opposites (events that reset eachother)*/
1915 status = TrafficMonitor_SetRstCondition(pCtrlData->hTrafficMonitor,
1916 pCtrlData->ctrlDataTrafficThresholdEvents[2],
1917 pCtrlData->ctrlDataTrafficThresholdEvents[3],
1918 TRUE);
1919
1920 if (status != OK)
1921 {
1922 WLAN_REPORT_ERROR (pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1923 ("ctrlData_RegisterTrafficIntensityEvents: TrafficMonitor_SetRstCondition returned status = %d\n",status));
1924 }
1925
1926 WLAN_REPORT_INFORMATION(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1927 (" ctrlData_RegisterTrafficIntensityEvents() : finished registering all events \n"));
1928
1929 }
1930
1931
1932 /*-----------------------------------------------------------------------------
1933 Routine Name: ctrlData_TrafficThresholdCrossed
1934 Routine Description: called whenever traffic intensity threshold is crossed.
1935 notifies event handler to send appropriate event with threshold parameters.
1936 Arguments:
1937 Return Value:
1938 -----------------------------------------------------------------------------*/
ctrlData_TrafficThresholdCrossed(TI_HANDLE Context,UINT32 Cookie)1939 void ctrlData_TrafficThresholdCrossed(TI_HANDLE Context,UINT32 Cookie)
1940 {
1941 ctrlData_t *pCtrlData = (ctrlData_t *)Context;
1942 trafficIntensityThresholdCross_t crossInfo;
1943
1944 switch(Cookie)
1945 {
1946 case CTRL_DATA_TRAFFIC_INTENSITY_HIGH_CROSSED_ABOVE:
1947 crossInfo.thresholdCross = (UINT32)HIGH_THRESHOLD_CROSS;
1948 crossInfo.thresholdCrossDirection = (UINT32)CROSS_ABOVE;
1949 EvHandlerSendEvent(pCtrlData->hEvHandler, IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED, (UINT8 *)&crossInfo,sizeof(trafficIntensityThresholdCross_t));
1950 break;
1951
1952 case CTRL_DATA_TRAFFIC_INTENSITY_HIGH_CROSSED_BELOW:
1953 crossInfo.thresholdCross = (UINT32)HIGH_THRESHOLD_CROSS;
1954 crossInfo.thresholdCrossDirection = (UINT32)CROSS_BELOW;
1955 EvHandlerSendEvent(pCtrlData->hEvHandler, IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED, (UINT8 *)&crossInfo,sizeof(trafficIntensityThresholdCross_t));
1956 break;
1957
1958 case CTRL_DATA_TRAFFIC_INTENSITY_LOW_CROSSED_ABOVE:
1959 crossInfo.thresholdCross = (UINT32)LOW_THRESHOLD_CROSS;
1960 crossInfo.thresholdCrossDirection = (UINT32)CROSS_ABOVE;
1961 EvHandlerSendEvent(pCtrlData->hEvHandler, IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED, (UINT8 *)&crossInfo,sizeof(trafficIntensityThresholdCross_t));
1962 break;
1963
1964 case CTRL_DATA_TRAFFIC_INTENSITY_LOW_CROSSED_BELOW:
1965 crossInfo.thresholdCross = (UINT32)LOW_THRESHOLD_CROSS;
1966 crossInfo.thresholdCrossDirection = (UINT32)CROSS_BELOW;
1967 EvHandlerSendEvent(pCtrlData->hEvHandler, IPC_EVENT_TRAFFIC_INTENSITY_THRESHOLD_CROSSED, (UINT8 *)&crossInfo,sizeof(trafficIntensityThresholdCross_t));
1968 break;
1969 default:
1970 WLAN_REPORT_ERROR(pCtrlData->hReport, CTRL_DATA_MODULE_LOG,
1971 (" ctrlData_TrafficThresholdCrossed() : Unknown cookie received from traffic monitor !!! \n"));
1972 break;
1973 }
1974
1975 }
1976
1977 /***************************************************************************
1978 * ctrlData_buildHwBitMapFromArray *
1979 ****************************************************************************
1980 * DESCRIPTION: builds HwRatesBitMap (supported rates) for txRatePolicy
1981 * using an array that consist number of retries for each rate
1982 * all ew do is : if retry > 0 than the HwBit is ON.
1983 *
1984 * INPUTS: Array of retries
1985 *
1986 * OUTPUT: Bit Map of Hw rates.
1987 *
1988 * RETURNS: Bit Map of Hw rates.
1989 *
1990 ***************************************************************************/
ctrlData_buildHwBitMapFromArray(policyClassRatesArray_t * pArray)1991 static UINT32 ctrlData_buildHwBitMapFromArray(policyClassRatesArray_t *pArray)
1992 {
1993 txRateClassId_e TxRateIndex;
1994 UINT32 policyRateMask = 0;
1995 rateMask_e tempArray[MAX_NUM_OF_TX_RATES_IN_CLASS] =
1996 {
1997 DRV_RATE_MASK_54_OFDM,DRV_RATE_MASK_48_OFDM,DRV_RATE_MASK_36_OFDM,
1998 DRV_RATE_MASK_24_OFDM,DRV_RATE_MASK_22_PBCC,DRV_RATE_MASK_18_OFDM,
1999 DRV_RATE_MASK_12_OFDM,DRV_RATE_MASK_11_CCK,DRV_RATE_MASK_9_OFDM,
2000 DRV_RATE_MASK_6_OFDM,DRV_RATE_MASK_5_5_CCK,DRV_RATE_MASK_2_BARKER,
2001 DRV_RATE_MASK_1_BARKER};
2002
2003
2004
2005 for (TxRateIndex = txPolicy54; TxRateIndex < MAX_NUM_OF_TX_RATES_IN_CLASS; TxRateIndex++)
2006 {
2007 if (pArray->txRate[TxRateIndex] > 0 )
2008 {
2009 policyRateMask |= tempArray[TxRateIndex];
2010 }
2011 }
2012
2013 return policyRateMask;
2014 }
2015
2016
2017 /*************************************************************************
2018 * *
2019 * DEBUG FUNCTIONS *
2020 * *
2021 *************************************************************************/
2022
ctrlData_printTxParameters(TI_HANDLE hCtrlData)2023 void ctrlData_printTxParameters(TI_HANDLE hCtrlData)
2024 {
2025 WLAN_OS_REPORT((" Tx Parameters \n"));
2026 WLAN_OS_REPORT(("-------------------------------------\n"));
2027 WLAN_OS_REPORT(("currentPreamble = %d\n\n",((ctrlData_t *)hCtrlData)->ctrlDataCurrentPreambleType));
2028 WLAN_OS_REPORT(("currentModulation = %d\n", ((ctrlData_t *)hCtrlData)->ctrlDataCurrentModulationType));
2029 WLAN_OS_REPORT(("ctrlDataCurrentBasicModulationType = %d\n", ((ctrlData_t *)hCtrlData)->ctrlDataCurrentBasicModulationType));
2030 WLAN_OS_REPORT(("ctrlDataCurrentBasicRate = %d\n", ((ctrlData_t *)hCtrlData)->ctrlDataCurrentBasicRate));
2031 WLAN_OS_REPORT(("ctrlDataBasicRateBitMask = 0x%X\n",((ctrlData_t *)hCtrlData)->ctrlDataBasicRateBitMask));
2032 WLAN_OS_REPORT(("ctrlDataCurrentRateMask = 0x%X\n",((ctrlData_t *)hCtrlData)->ctrlDataCurrentRateMask));
2033 }
2034
ctrlData_printRateAdaptation(TI_HANDLE hCtrlData)2035 void ctrlData_printRateAdaptation(TI_HANDLE hCtrlData)
2036 {
2037 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
2038
2039 rateAdaptation_print(pCtrlData->pRateAdaptation);
2040 }
2041 #ifdef SUPPORT_4X
ctrlData_printFourX(TI_HANDLE hCtrlData)2042 void ctrlData_printFourX(TI_HANDLE hCtrlData)
2043 {
2044 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
2045
2046 fourX_printParams(pCtrlData->pFourX);
2047 }
2048 #endif
2049
ctrlData_printCtrlBlock(TI_HANDLE hCtrlData)2050 void ctrlData_printCtrlBlock(TI_HANDLE hCtrlData)
2051 {
2052 rateClassClients_e clientID;
2053 txRateClassId_e TxRateIndex;
2054
2055 WLAN_OS_REPORT((" CtrlData BLock \n"));
2056 WLAN_OS_REPORT(("----------------------\n"));
2057
2058 WLAN_OS_REPORT(("hSiteMgr = 0x%X\n",((ctrlData_t *)hCtrlData)->hSiteMgr));
2059 WLAN_OS_REPORT(("hTxData = 0x%X\n",((ctrlData_t *)hCtrlData)->hTxData));
2060 WLAN_OS_REPORT(("hWhalCtrl = 0x%X\n",((ctrlData_t *)hCtrlData)->hWhalCtrl));
2061 WLAN_OS_REPORT(("hOs = 0x%X\n",((ctrlData_t *)hCtrlData)->hOs));
2062 WLAN_OS_REPORT(("hReport = 0x%X\n",((ctrlData_t *)hCtrlData)->hReport));
2063
2064 WLAN_OS_REPORT(("ctrlDataDeviceMacAddress = 0x%X.0x%X.0x%X.0x%X.0x%X.0x%X. \n", ((ctrlData_t *)hCtrlData)->ctrlDataDeviceMacAddress.addr[0],
2065 ((ctrlData_t *)hCtrlData)->ctrlDataDeviceMacAddress.addr[1],
2066 ((ctrlData_t *)hCtrlData)->ctrlDataDeviceMacAddress.addr[2],
2067 ((ctrlData_t *)hCtrlData)->ctrlDataDeviceMacAddress.addr[3],
2068 ((ctrlData_t *)hCtrlData)->ctrlDataDeviceMacAddress.addr[4],
2069 ((ctrlData_t *)hCtrlData)->ctrlDataDeviceMacAddress.addr[5]));
2070
2071 WLAN_OS_REPORT(("ctrlDataCurrentBSSID = 0x%X.0x%X.0x%X.0x%X.0x%X.0x%X. \n", ((ctrlData_t *)hCtrlData)->ctrlDataCurrentBSSID.addr[0],
2072 ((ctrlData_t *)hCtrlData)->ctrlDataCurrentBSSID.addr[1],
2073 ((ctrlData_t *)hCtrlData)->ctrlDataCurrentBSSID.addr[2],
2074 ((ctrlData_t *)hCtrlData)->ctrlDataCurrentBSSID.addr[3],
2075 ((ctrlData_t *)hCtrlData)->ctrlDataCurrentBSSID.addr[4],
2076 ((ctrlData_t *)hCtrlData)->ctrlDataCurrentBSSID.addr[5]));
2077
2078 WLAN_OS_REPORT(("ctrlDataRateControlEnable = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataRateControlEnable));
2079 WLAN_OS_REPORT(("ctrlDataFourXEnable = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataFourXEnable));
2080 WLAN_OS_REPORT(("ctrlDataFourCurrState = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCerruentFourXstate));
2081 WLAN_OS_REPORT(("ctrlDataStartStoplinkControlAlg = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataStartStoplinkControlAlg));
2082
2083 WLAN_OS_REPORT(("ctrlDataCurrentBssType = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCurrentBssType));
2084 WLAN_OS_REPORT(("ctrlDataCurrentModulationType = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCurrentModulationType));
2085 WLAN_OS_REPORT(("ctrlDataCurrentBasicRate = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCurrentBasicRate));
2086
2087 WLAN_OS_REPORT(("ctrlDataBasicRateBitMask = 0x%X\n",((ctrlData_t *)hCtrlData)->ctrlDataBasicRateBitMask));
2088 WLAN_OS_REPORT(("ctrlDataCurrentRateMask = 0x%X\n",((ctrlData_t *)hCtrlData)->ctrlDataCurrentRateMask));
2089
2090 WLAN_OS_REPORT(("ctrlDataCurrentBasicModulationType = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCurrentBasicModulationType));
2091 WLAN_OS_REPORT(("ctrlDataCurrentPreambleType = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCurrentPreambleType));
2092
2093 WLAN_OS_REPORT(("Traffic Intensity threshold events status: %s\n", (((ctrlData_t *)hCtrlData)->ctrlDataTrafficIntensityEventsEnabled ? "Enabled" : "Disabled")));
2094 WLAN_OS_REPORT(("Traffic Intensity high threshold: %d packets/sec \n", ((ctrlData_t *)hCtrlData)->ctrlDataTrafficIntensityThresholds.uHighThreshold));
2095 WLAN_OS_REPORT(("Traffic Intensity low threshold: %d packets/sec \n", ((ctrlData_t *)hCtrlData)->ctrlDataTrafficIntensityThresholds.uLowThreshold));
2096 WLAN_OS_REPORT(("Traffic Intensity test interval: %d ms\n", ((ctrlData_t *)hCtrlData)->ctrlDataTrafficIntensityThresholds.TestInterval));
2097
2098 for (clientID = (rateClassClients_e)0 ; clientID < NUM_OF_RATE_CLASS_CLIENTS ; clientID++)
2099 {
2100 WLAN_OS_REPORT((" client = %d : bIsClassAvailable = %s currMask = 0x%x nextMask = 0x%x \n",
2101 clientID,(TRUE == ((ctrlData_t *)hCtrlData)->bIsClassAvailable[clientID] ? "TRUE" : "FALSE"),
2102 ((ctrlData_t *)hCtrlData)->currClientRateMask[clientID],((ctrlData_t *)hCtrlData)->nextClientRateMask[clientID]));
2103 WLAN_OS_REPORT(("Policy for client %d (starting from 54): \n",clientID));
2104 for (TxRateIndex = txPolicy54; TxRateIndex < MAX_NUM_OF_TX_RATES_IN_CLASS; TxRateIndex++)
2105 {
2106 WLAN_OS_REPORT(("retries for rate %d = %d\n",TxRateIndex,((ctrlData_t *)hCtrlData)->ctrlDataTxRatePolicy.rateClass[clientID*MAX_NUM_OF_AC].txRate[TxRateIndex]));
2107 }
2108 WLAN_OS_REPORT(("Long retry = %d , Short retry = %d\n",
2109 ((ctrlData_t *)hCtrlData)->ctrlDataTxRatePolicy.rateClass[clientID].longRetryLimit,((ctrlData_t *)hCtrlData)->ctrlDataTxRatePolicy.rateClass[clientID*MAX_NUM_OF_AC].shortRetryLimit));
2110 }
2111 WLAN_OS_REPORT(("current used client %d\n",((ctrlData_t *)hCtrlData)->currClientRateID));
2112 }
2113
ctrlData_printCtrlCounters(TI_HANDLE hCtrlData)2114 void ctrlData_printCtrlCounters(TI_HANDLE hCtrlData)
2115 {
2116 WLAN_OS_REPORT((" CtrlData Counters \n"));
2117 WLAN_OS_REPORT(("-------------------------\n"));
2118
2119 WLAN_OS_REPORT(("icvFailCounter = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCounters.icvFailCounter));
2120 WLAN_OS_REPORT(("keyNotFoundCounter = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCounters.keyNotFoundCounter));
2121 WLAN_OS_REPORT(("MicFailureCounter = %d\n",((ctrlData_t *)hCtrlData)->ctrlDataCounters.MicFailureCounter));
2122 }
2123
2124
2125 #ifdef TI_DBG
2126
ctrlData_printClsfrTable(TI_HANDLE hCtrlData)2127 void ctrlData_printClsfrTable ( TI_HANDLE hCtrlData )
2128 {
2129 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
2130 Classifier_dbgPrintClsfrTable (pCtrlData->pClsfr);
2131 }
2132
ctrlData_clearClsfrTable(TI_HANDLE hCtrlData)2133 void ctrlData_clearClsfrTable ( TI_HANDLE hCtrlData )
2134 {
2135 clsfrTypeAndSupport myLocalType;
2136 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData;
2137
2138 Classifier_getClsfrType (pCtrlData->pClsfr,&myLocalType);
2139 ctrlData_clsfrSetClsfrType (pCtrlData,myLocalType);
2140 }
2141
2142 #endif
2143
2144
2145 /***************************************************************************
2146 * ctrlData_storeTSRateSet
2147 ****************************************************************************
2148 * DESCRIPTION: This function translates TSRS rates into map of retransmissions
2149 * similar to predefined clients rates retransmissions, and stores
2150 * in the Ctrl database
2151 *
2152 * INPUTS: pCtrlData - the object
2153 * acID
2154 * rates array
2155 *
2156 * RETURNS: -
2157 ****************************************************************************/
ctrlData_storeTSRateSet(ctrlData_t * pCtrlData,txDataQosParams_t * tsrsParams)2158 static void ctrlData_storeTSRateSet(ctrlData_t *pCtrlData, txDataQosParams_t *tsrsParams)
2159 {
2160 UINT32 rateCount;
2161 UINT32 acID, rateID;
2162 UINT32 tsrsRequestedMap;
2163 rate_e rateNumber;
2164 rateClassClients_e clientNumber;
2165 txRateClassId_e rate_e_to_txRateClassId_e[DRV_RATE_MAX+1] =
2166 {
2167 txPolicy1, txPolicy1, txPolicy2, txPolicy5_5, txPolicy11,
2168 txPolicy22, txPolicy6, txPolicy9, txPolicy12, txPolicy18,
2169 txPolicy24, txPolicy36, txPolicy48, txPolicy54
2170 };
2171
2172 acID = tsrsParams->acID;
2173 os_memoryZero(pCtrlData->hOs,
2174 &(pCtrlData->tsrsParameters[acID]),
2175 sizeof(pCtrlData->tsrsParameters[acID]));
2176
2177
2178 for (clientNumber = (rateClassClients_e)0; clientNumber < NUM_OF_RATE_CLASS_CLIENTS; clientNumber++)
2179 {
2180 tsrsRequestedMap = 0;
2181
2182 for (rateCount = 0; rateCount < tsrsParams->tsrsArrLen; rateCount++)
2183 {
2184 /* Erase Most significant bit in case it was raised to mark nominal PHY rates (& 0x7F) */
2185 /* Convert multiplication of 500kb/sec to rate_e and then to txRateClassId_e */
2186 /* and update retransmission map in accordance to USER_RATE client definitions */
2187 rateNumber = RateNumberToHost((tsrsParams->tsrsArr[rateCount] & 0x7F) >> 1);
2188 rateID = rate_e_to_txRateClassId_e[rateNumber];
2189
2190 /* Update Rate Fallback policy map according to the class predefined policy map */
2191 if (pCtrlData->pCurrPolicyClassRatesArray[clientNumber].txRate[rateID] > 0)
2192 {
2193 pCtrlData->tsrsParameters[acID].policyClassRateMask[clientNumber] |= (1<<(rateNumber-1));
2194 }
2195 tsrsRequestedMap |= (1<<(rateNumber-1));
2196 }
2197 /* Update supportedRatesMask according to TSRS rates and rates supported for this class */
2198 pCtrlData->tsrsParameters[acID].supportedRatesMask[clientNumber] =
2199 pCtrlData->nextClientRateMask[clientNumber] & tsrsRequestedMap;
2200
2201 /* Check that Rate Fallback policy map is not empty; if this is a case, ignore pre-defined policy */
2202 if (pCtrlData->tsrsParameters[acID].policyClassRateMask[clientNumber] == 0)
2203 {
2204 pCtrlData->tsrsParameters[acID].policyClassRateMask[clientNumber] =
2205 pCtrlData->tsrsParameters[acID].supportedRatesMask[clientNumber];
2206 }
2207 }
2208 }
2209
2210 /***************************************************************************
2211 * ctrlData_getClosestTSRate
2212 ****************************************************************************
2213 * DESCRIPTION: This function checks if the TSRS is defined for the requested
2214 * access category or not; if requested, it chooses from the TSRS
2215 * a rate that is as close as possible to the requestede one.
2216 *
2217 * INPUTS: pCtrlData - the object
2218 * acID
2219 *
2220 * RETURNS: -
2221 ****************************************************************************/
ctrlData_getClosestTSRate(ctrlData_t * pCtrlData,UINT32 ac,rate_e givenRate)2222 static rate_e ctrlData_getClosestTSRate(ctrlData_t *pCtrlData, UINT32 ac, rate_e givenRate)
2223 {
2224 UINT32 tsRate;
2225 rate_e resultRate;
2226
2227 if (pCtrlData->tsrsParameters[ac].supportedRatesMask[pCtrlData->currClientRateID] != 0)
2228 {
2229 /* From TSRS rates, choose the closest to the basic rate */
2230 /* ((1 << givenRate) - 1) gives a map of all rates <= givenRate */
2231 /* Logical AND with TSRS supported rates gives a map of supported rates <= givenRate */
2232 /* Now just pick the maximal */
2233 tsRate = pCtrlData->tsrsParameters[ac].supportedRatesMask[pCtrlData->currClientRateID]
2234 & ((1 << givenRate) - 1);
2235 resultRate = calculateMaxSupportedRate(&tsRate);
2236
2237 if (resultRate == DRV_RATE_INVALID)
2238 {
2239 return givenRate;
2240 }
2241 else
2242 {
2243 return resultRate;
2244 }
2245 }
2246 else
2247 {
2248 return givenRate;
2249 }
2250 }
2251
2252