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 ************************************************************************/ 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 ***************************************************************************/ 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 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 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 */ 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 ***************************************************************************/ 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 ***************************************************************************/ 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 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 ***************************************************************************/ 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 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 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 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 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 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 ***************************************************************************/ 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 ***************************************************************************/ 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 ***************************************************************************/ 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 ***************************************************************************/ 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 ***************************************************************************/ 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 ***************************************************************************/ 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 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 ***************************************************************************/ 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 ***************************************************************************/ 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 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 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 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 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 -----------------------------------------------------------------------------*/ 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 -----------------------------------------------------------------------------*/ 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 -----------------------------------------------------------------------------*/ 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 -----------------------------------------------------------------------------*/ 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 ***************************************************************************/ 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 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 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 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 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 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 2127 void ctrlData_printClsfrTable ( TI_HANDLE hCtrlData ) 2128 { 2129 ctrlData_t *pCtrlData = (ctrlData_t *)hCtrlData; 2130 Classifier_dbgPrintClsfrTable (pCtrlData->pClsfr); 2131 } 2132 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 ****************************************************************************/ 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 ****************************************************************************/ 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
