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: */ 38 /* PURPOSE: */ 39 /* */ 40 /***************************************************************************/ 41 #include "fourX.h" 42 #include "report.h" 43 #include "osApi.h" 44 #include "utils.h" 45 46 47 static void fourXManager_resetAll4xCapabilities(fourX_t* pFourX); 48 static void fourXManager_resetAll_AP_4xCapabilities(fourX_t* pFourX); 49 50 static TI_STATUS fourXManager_InfoElementParsing(fourX_t* pFourX, 51 dot11_4X_t* site4xParams, 52 fourX_Capabilities_t* pFourX_Capabilities); 53 54 static void setDefault4xCapabilities(fourX_Capabilities_t* pFourX_Capabilities); 55 static TI_STATUS build4XInfoElementVersion0(fourX_t* pFourX, 56 dot11_4X_t* fourXInfoElemnt); 57 58 static TI_STATUS build4XInfoElementVersion1(fourX_t* pFourX, 59 dot11_4X_t* fourXInfoElemnt); 60 61 62 63 64 /* 4X manager */ 65 TI_STATUS fourXManager_evalSite(fourX_t* pFourX, 66 dot11_4X_t* site4xParams, 67 UINT32 *matchingLevel) 68 { 69 /* TODO - define 4x matching level */ 70 return OK; 71 } 72 73 TI_STATUS fourXManager_setSite(fourX_t* pFourX, 74 dot11_4X_t* site4xParams) 75 { 76 TI_STATUS status; 77 whalParamInfo_t param; 78 79 80 status = fourXManager_InfoElementParsing(pFourX, 81 site4xParams, 82 &pFourX->ApFourX_Capabilities); 83 if(status != OK) 84 { 85 /* set all 4x capabilities to 0 */ 86 fourXManager_resetAll4xCapabilities(pFourX); 87 return NOK; 88 } 89 90 /* 91 * configure fourX module and driver 4x Parameters 92 */ 93 94 /* configure concatenation parameters */ 95 if( (pFourX->desiredConcatenationEnable == TRUE) && 96 (pFourX->ApFourX_Capabilities.concatenationParams.enableDisable == TRUE) ) 97 { 98 pFourX->concatenationEnable = TRUE; 99 } 100 else 101 { 102 pFourX->concatenationEnable = FALSE; 103 } 104 pFourX->currentMaxConcatSize = MIN(pFourX->desiredMaxConcatSize,pFourX->ApFourX_Capabilities.concatenationParams.concatenationSize); 105 106 /* 107 * set Hal Parameters 108 */ 109 param.paramType = HAL_CTRL_RTS_THRESHOLD_PARAM; 110 param.content.halCtrlRtsThreshold = HAL_CTRL_RTS_THRESHOLD_MAX; 111 112 whalCtrl_SetParam(pFourX->hWhalCtrl, ¶m); 113 114 115 /* configure contentionWindow parameters */ 116 if( (pFourX->desiredCWMinEnable == TRUE) && 117 (pFourX->ApFourX_Capabilities.contentionWindowParams.enableDisable == TRUE) ) 118 { 119 pFourX->CWMinEnable = TRUE; 120 } 121 else 122 { 123 pFourX->CWMinEnable = FALSE; 124 125 } 126 pFourX->currentCWMax = MIN(pFourX->desiredCWMax,pFourX->ApFourX_Capabilities.contentionWindowParams.CWMax); 127 pFourX->currentCWMax = MAX(pFourX->desiredCWMin,pFourX->ApFourX_Capabilities.contentionWindowParams.CWMin); 128 129 /* configure CWCombo parameters - DO NOT Supported */ 130 if( (pFourX->desiredCWComboEnable == TRUE) && 131 (pFourX->ApFourX_Capabilities.CWCombParams.enableDisable == TRUE) ) 132 { 133 pFourX->CWComboEnable = TRUE; 134 } 135 else 136 { 137 pFourX->CWComboEnable = FALSE; 138 139 } 140 141 /* configure CWCombo parameters */ 142 if( (pFourX->desiredAckEmulationEnable == TRUE) && 143 (pFourX->ApFourX_Capabilities.ackEmulationParams.enableDisable == TRUE) ) 144 { 145 #ifdef ACK_EMUL 146 pFourX->ackEmulationEnable = TRUE; 147 #else 148 pFourX->ackEmulationEnable = FALSE; 149 #endif 150 } 151 else 152 { 153 pFourX->ackEmulationEnable = FALSE; 154 155 } 156 157 /* configure CWCombo parameters - DO NOT Supported */ 158 if( (pFourX->desiredERP_ProtectionEnable == TRUE) && 159 (pFourX->ApFourX_Capabilities.ERP_ProtectionParams.enableDisable == TRUE) ) 160 { 161 pFourX->ERP_ProtectionEnable = TRUE; 162 } 163 else 164 { 165 pFourX->ERP_ProtectionEnable = FALSE; 166 167 } 168 169 return OK; 170 } 171 172 173 static TI_STATUS fourXManager_InfoElementParsing(fourX_t* pFourX, 174 dot11_4X_t* site4xParams, 175 fourX_Capabilities_t* pFourX_Capabilities) 176 { 177 char *capPtr; 178 UINT32 len; 179 UINT16 capLen; 180 WlanTIcap_t cap_type; 181 UINT8 ti_oui[] = TI_OUI; 182 183 if(site4xParams == NULL) 184 { 185 fourXManager_resetAll_AP_4xCapabilities(pFourX); 186 return NOK; 187 } 188 189 /* 190 * IE parsing 191 */ 192 if( (site4xParams->hdr.eleId != DOT11_4X_ELE_ID) || 193 (site4xParams->hdr.eleLen > DOT11_4X_MAX_LEN) || 194 (os_memoryCompare(pFourX->hOs ,ti_oui, (PUINT8)site4xParams->fourXCapabilities, DOT11_OUI_LEN) != 0) ) 195 { 196 fourXManager_resetAll_AP_4xCapabilities(pFourX); 197 return NOK; 198 } 199 200 /* 201 * check protocol version 202 */ 203 if( ((site4xParams->fourXCapabilities[DOT11_OUI_LEN]) & 0xF) == FOUR_X_PROTOCOL_VERSION_0) 204 { 205 /* 206 * version 0 207 */ 208 pFourX_Capabilities->fourXProtocolVersion = FOUR_X_PROTOCOL_VERSION_0; 209 setDefault4xCapabilities(pFourX_Capabilities); 210 return OK; 211 } 212 else 213 if( ((site4xParams->fourXCapabilities[DOT11_OUI_LEN]) & 0xF) == FOUR_X_PROTOCOL_VERSION_1) 214 { 215 /* 216 * version 1 217 */ 218 pFourX_Capabilities->fourXProtocolVersion = FOUR_X_PROTOCOL_VERSION_1; 219 220 capPtr = (char *)site4xParams; 221 capPtr += (sizeof(dot11_eleHdr_t) + DOT11_OUI_LEN + 1); /*IE header + TI_OUI + version field */; 222 223 len = DOT11_OUI_LEN+1; /* TI_OUI + version field */ 224 225 while(len < (UINT32)(site4xParams->hdr.eleLen)) /* Dm: Security fix */ 226 { 227 cap_type = (WlanTIcap_t)(*((UINT16*)(capPtr))); 228 229 switch(cap_type) 230 { 231 case TI_CAP_4X_CONCATENATION: 232 pFourX_Capabilities->concatenationParams.enableDisable = TRUE; 233 capPtr += 2; 234 capLen = *((UINT16*)(capPtr)); 235 capPtr += 2; 236 pFourX_Capabilities->concatenationParams.concatenationSize = *((UINT16*)(capPtr)); 237 capPtr += 2; 238 len += sizeof(UINT16) /* type field */ + sizeof(UINT16) /* len field */ + (UINT32)capLen /* val fields */; 239 break; 240 241 case TI_CAP_4X_CONT_WINDOW: 242 pFourX_Capabilities->contentionWindowParams.enableDisable = TRUE; 243 capPtr += 2; 244 capLen = *((UINT16*)(capPtr)); 245 capPtr += 2; 246 pFourX_Capabilities->contentionWindowParams.CWMin = *((UINT16*)(capPtr)); 247 capPtr += 2; 248 pFourX_Capabilities->contentionWindowParams.CWMax = *((UINT16*)(capPtr)); 249 capPtr += 2; 250 len += sizeof(UINT16) /* type field */ + sizeof(UINT16) /* len field */ + (UINT32)capLen /* val field */; 251 break; 252 253 case TI_CAP_4X_CONT_WINDOW_COMBO: 254 pFourX_Capabilities->CWCombParams.enableDisable = TRUE; 255 capPtr += 2; 256 capLen = *((UINT16*)(capPtr)); 257 capPtr += 2; 258 pFourX_Capabilities->CWCombParams.DIFS = *((UINT16*)(capPtr)); 259 capPtr += 2; 260 pFourX_Capabilities->CWCombParams.SLOT = *((UINT16*)(capPtr)); 261 capPtr += 2; 262 pFourX_Capabilities->CWCombParams.CWMin = *((UINT16*)(capPtr)); 263 capPtr += 2; 264 len += sizeof(UINT16) /* type field */ + sizeof(UINT16) /* len field */ + (UINT32)capLen /* val field */; 265 break; 266 267 case TI_CAP_4X_TCP_ACK_EMUL: 268 pFourX_Capabilities->ackEmulationParams.enableDisable = TRUE; 269 capPtr += 2; 270 capLen = *((UINT16*)(capPtr)); 271 capPtr += 2; 272 len += sizeof(UINT16) /* type field */ + sizeof(UINT16) /* len field */ + (UINT32)capLen /* val field */; 273 break; 274 275 case TI_CAP_TRICK_PACKET_ERP: 276 pFourX_Capabilities->ERP_ProtectionParams.enableDisable = TRUE; 277 capPtr += 2; 278 capLen = *((UINT16*)(capPtr)); 279 capPtr += 2; 280 len += sizeof(UINT16) /* type field */ + sizeof(UINT16) /* len field */ + (UINT32)capLen /* val field */; 281 break; 282 283 default: 284 WLAN_REPORT_INFORMATION(pFourX->hReport, FOUR_X_MODULE_LOG, 285 ("unrecognized capability in TI IE: %d\n",cap_type)); 286 return NOK; 287 } 288 } 289 } 290 else 291 { 292 /* 293 * unknown version 294 */ 295 fourXManager_resetAll_AP_4xCapabilities(pFourX); 296 return NOK; 297 } 298 299 return OK; 300 } 301 302 TI_STATUS fourXManager_get4xInfoElemnt(fourX_t* pFourX, 303 dot11_4X_t* fourXInfoElemnt) 304 { 305 TI_STATUS Status; 306 if(pFourX->ApFourX_Capabilities.fourXProtocolVersion == FOUR_X_PROTOCOL_VERSION_0) 307 { 308 Status = build4XInfoElementVersion0(pFourX, fourXInfoElemnt); 309 } 310 else 311 if(pFourX->ApFourX_Capabilities.fourXProtocolVersion == FOUR_X_PROTOCOL_VERSION_1) 312 { 313 Status = build4XInfoElementVersion1(pFourX, fourXInfoElemnt); 314 } 315 else 316 { 317 WLAN_REPORT_INFORMATION(pFourX->hReport, FOUR_X_MODULE_LOG, 318 ("fourXManager_get4xInfoElemnt: Versionm unknown\n")); 319 return NOK; 320 } 321 322 return Status; 323 } 324 325 static TI_STATUS build4XInfoElementVersion0(fourX_t* pFourX, 326 dot11_4X_t* fourXInfoElemnt) 327 { 328 UINT8 ti_oui[] = TI_OUI; 329 330 WLAN_REPORT_INFORMATION(pFourX->hReport, FOUR_X_MODULE_LOG, 331 ("build4XInfoElementVersion0: build IE version 0\n")); 332 333 /* 4x Protocol version should support ALL version 0 features */ 334 if( (pFourX->desiredConcatenationEnable == FALSE) || 335 (pFourX->desiredCWMinEnable == FALSE) ) 336 { 337 return NOK; 338 } 339 340 fourXInfoElemnt->hdr.eleId = TI_4X_IE_ID; 341 fourXInfoElemnt->hdr.eleLen = FOUR_X_INFO_ELEMENT_VERSION_0_LEN; 342 343 os_memoryCopy(pFourX->hOs, (PUINT8)fourXInfoElemnt->fourXCapabilities, ti_oui, DOT11_OUI_LEN); 344 fourXInfoElemnt->fourXCapabilities[DOT11_OUI_LEN] = FOUR_X_PROTOCOL_VERSION_0; 345 return OK; 346 } 347 348 static TI_STATUS build4XInfoElementVersion1(fourX_t* pFourX, 349 dot11_4X_t* fourXInfoElemnt) 350 { 351 UINT8 len = 0; 352 UINT8 *capPtr; 353 UINT8 ti_oui[] = TI_OUI; 354 355 WLAN_REPORT_INFORMATION(pFourX->hReport, FOUR_X_MODULE_LOG, 356 ("build4XInfoElementVersion0: build IE version 1\n")); 357 358 fourXInfoElemnt->hdr.eleId = TI_4X_IE_ID; 359 360 capPtr = (UINT8 *)fourXInfoElemnt->fourXCapabilities; 361 362 os_memoryCopy(pFourX->hOs, capPtr, ti_oui, DOT11_OUI_LEN); 363 capPtr += DOT11_OUI_LEN ; 364 len += DOT11_OUI_LEN ; 365 366 *capPtr = FOUR_X_PROTOCOL_VERSION_1; 367 capPtr += 1; 368 len += 1; 369 370 371 if(pFourX->desiredConcatenationEnable == TRUE) 372 { 373 *((UINT16*)capPtr) = FOUR_X_CONCAT_CAP_ID; 374 capPtr += 2; 375 len += 2; 376 *((UINT16*)capPtr) = FOUR_X_CONCAT_CAP_LEN; 377 capPtr += 2; 378 len += 2; 379 *((UINT16*)capPtr) = 4095; 380 capPtr += 2; 381 len += 2; 382 } 383 384 385 fourXInfoElemnt->hdr.eleLen = len; 386 return OK; 387 388 } 389 390 static void fourXManager_resetAll4xCapabilities(fourX_t* pFourX) 391 { 392 pFourX->concatenationEnable = FALSE; 393 pFourX->CWMinEnable = FALSE; 394 pFourX->CWComboEnable = FALSE; 395 pFourX->ackEmulationEnable = FALSE; 396 pFourX->ERP_ProtectionEnable = FALSE; 397 } 398 399 static void fourXManager_resetAll_AP_4xCapabilities(fourX_t* pFourX) 400 { 401 os_memoryZero(pFourX->hOs, &pFourX->ApFourX_Capabilities, (sizeof(fourX_Capabilities_t))); 402 } 403 404 static void setDefault4xCapabilities(fourX_Capabilities_t* pFourX_Capabilities) 405 { 406 /* Concatenation */ 407 pFourX_Capabilities->concatenationParams.enableDisable = TRUE; 408 pFourX_Capabilities->concatenationParams.concatenationSize = MAX_CONCAT_SIZE_DEF; 409 410 /* CW min */ 411 pFourX_Capabilities->contentionWindowParams.enableDisable = TRUE; 412 pFourX_Capabilities->contentionWindowParams.CWMax = DEF_CW_MAX; 413 pFourX_Capabilities->contentionWindowParams.CWMin = DEF_CW_MIN; 414 415 /* CW combo */ 416 pFourX_Capabilities->CWCombParams.enableDisable = FALSE; 417 pFourX_Capabilities->CWCombParams.CWMin = DEF_CW_COMBO_CW_MIN; 418 pFourX_Capabilities->CWCombParams.DIFS = DEF_CW_COMBO_DIFS; 419 pFourX_Capabilities->CWCombParams.SLOT = DEF_CW_COMBO_SLOT; 420 421 /* Ack Emulation */ 422 pFourX_Capabilities->ackEmulationParams.enableDisable = TRUE; 423 424 /* ERP protection */ 425 pFourX_Capabilities->ERP_ProtectionParams.enableDisable = FALSE; 426 427 428 } 429 430 431