1 /**************************************************************************** 2 **+-----------------------------------------------------------------------+** 3 **| |** 4 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |** 5 **| All rights reserved. |** 6 **| |** 7 **| Redistribution and use in source and binary forms, with or without |** 8 **| modification, are permitted provided that the following conditions |** 9 **| are met: |** 10 **| |** 11 **| * Redistributions of source code must retain the above copyright |** 12 **| notice, this list of conditions and the following disclaimer. |** 13 **| * Redistributions in binary form must reproduce the above copyright |** 14 **| notice, this list of conditions and the following disclaimer in |** 15 **| the documentation and/or other materials provided with the |** 16 **| distribution. |** 17 **| * Neither the name Texas Instruments nor the names of its |** 18 **| contributors may be used to endorse or promote products derived |** 19 **| from this software without specific prior written permission. |** 20 **| |** 21 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |** 22 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |** 23 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |** 24 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |** 25 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |** 26 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |** 27 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |** 28 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |** 29 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |** 30 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |** 31 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |** 32 **| |** 33 **+-----------------------------------------------------------------------+** 34 ****************************************************************************/ 35 36 /**************************************************************************** 37 * 38 * MODULE: whalHwMboxCmd.c 39 * PURPOSE: wlan hardware commands handler 40 * 41 ****************************************************************************/ 42 43 #include "whalCommon.h" 44 #include "whalHwMboxCmd.h" 45 #include "whalBus_Api.h" 46 #include "CmdQueue_api.h" 47 48 /* Local Macros */ 49 50 #define MAC_TO_VENDOR_PREAMBLE(mac) ((mac[0] << 16) | (mac[1] << 8) | mac[2]) 51 52 53 /**************************************************************************** 54 * whal_hwMboxCmd_Create() 55 **************************************************************************** 56 * DESCRIPTION: Create the mailbox commands object 57 * 58 * INPUTS: 59 * 60 * OUTPUT: None 61 * 62 * RETURNS: The Created object 63 ****************************************************************************/ 64 HwMboxCmd_T *whal_hwMboxCmd_Create(TI_HANDLE hOs, WhalParams_T *pWhalParams) 65 { 66 HwMboxCmd_T *pObj; 67 68 pObj = os_memoryAlloc(hOs, sizeof(HwMboxCmd_T)); 69 if (pObj == NULL) 70 return NULL; 71 72 os_memoryZero(hOs, (void *)pObj, sizeof(HwMboxCmd_T)); 73 74 pObj->hOs = hOs; 75 pObj->pWhalParams = pWhalParams; 76 77 return(pObj); 78 } 79 80 /**************************************************************************** 81 * whal_hwMboxCmd_Destroy() 82 **************************************************************************** 83 * DESCRIPTION: Destroy the object 84 * 85 * INPUTS: 86 * pHwMboxCmd The object to free 87 * 88 * OUTPUT: None 89 * 90 * RETURNS: OK or NOK 91 ****************************************************************************/ 92 int whal_hwMboxCmd_Destroy(HwMboxCmd_T *pHwMboxCmd) 93 { 94 if (pHwMboxCmd) 95 os_memoryFree(pHwMboxCmd->hOs, pHwMboxCmd, sizeof(HwMboxCmd_T)); 96 return OK; 97 } 98 99 /**************************************************************************** 100 * whal_hwMboxCmd_Config() 101 **************************************************************************** 102 * DESCRIPTION: Configure the object 103 * 104 * INPUTS: 105 * 106 * OUTPUT: None 107 * 108 * RETURNS: OK or NOK 109 ****************************************************************************/ 110 int whal_hwMboxCmd_Config(HwMboxCmd_T *pHwMboxCmd, TI_HANDLE hCmdMboxQueue, TI_HANDLE hReport) 111 { 112 pHwMboxCmd->hReport = hReport; 113 pHwMboxCmd->hCmdMboxQueue = hCmdMboxQueue; 114 return OK; 115 } 116 117 /**************************************************************************** 118 * whal_hwMboxCmd_StartBss() 119 **************************************************************************** 120 * DESCRIPTION: Construct the StartBss command fileds and send it to the mailbox 121 * 122 * INPUTS: None 123 * 124 * OUTPUT: None 125 * 126 * RETURNS: OK or NOK 127 ****************************************************************************/ 128 int whal_hwMboxCmd_StartBss(HwMboxCmd_T *pHwMboxCmd, BSS_e BssType, void *JoinCompleteCB, TI_HANDLE CB_handle) 129 { 130 StartJoinRequest_t AcxCmd_StartBss; 131 StartJoinRequest_t *pCmd = &AcxCmd_StartBss; 132 dot11_SSID_t *pWlanElm_Ssid = whal_ParamsGetElm_Ssid(pHwMboxCmd->pWhalParams); 133 BssInfoParams_T *pBssInfoParams = whal_ParamsGetBssInfoParams(pHwMboxCmd->pWhalParams); 134 UINT8 *BssId; 135 UINT8 *cmdBssId; 136 UINT16 HwBasicRatesBitmap; 137 UINT16 HwSupportedRatesBitmap; 138 int i; 139 140 os_memoryZero(pHwMboxCmd->hOs, (void *)pCmd, sizeof(StartJoinRequest_t)); 141 142 /* 143 * Set RxCfg and RxFilterCfg values 144 */ 145 pCmd->rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG( pHwMboxCmd->pWhalParams->WlanParams.RxConfigOption ); 146 pCmd->rxFilter.FilterOptions = ENDIAN_HANDLE_LONG( pHwMboxCmd->pWhalParams->WlanParams.RxFilterOption ); 147 148 pCmd->beaconInterval = ENDIAN_HANDLE_WORD(whal_ParamsGetBeaconInterval(pHwMboxCmd->pWhalParams)); 149 pCmd->dtimInterval = whal_ParamsGetDtimCount(pHwMboxCmd->pWhalParams); 150 pCmd->channelNumber = whal_ParamsGetRadioChannel(pHwMboxCmd->pWhalParams); 151 152 153 pCmd->bssType = BssType; 154 155 /* Add radio band */ 156 pCmd->bssType |= whal_ParamsGetRadioBand (pHwMboxCmd->pWhalParams) << 4; 157 pCmd->ctrl = pBssInfoParams->Ctrl; /* Only bit 7 is currently in use in the Ctrl field, bit 7 indicates if to flash the Tx queues */ 158 159 160 /* 161 * BasicRateSet 162 * The wlan hardware uses pHwMboxCmd field to determine the rate at which to transmit 163 * control frame responses (such as ACK or CTS frames) 164 */ 165 whalUtils_ConvertAppRatesBitmap(pBssInfoParams->BasicRateSet, 0, &HwBasicRatesBitmap); 166 167 168 /* 169 * SupportedRateSet 170 * The wlan hardware uses pHwMboxCmd information to determine which rates are allowed 171 * when rate fallback is enabled 172 */ 173 whalUtils_ConvertAppRatesBitmap(pBssInfoParams->SupportedRateSet, 0, &HwSupportedRatesBitmap); 174 pCmd->basicRateSet = ENDIAN_HANDLE_WORD(HwBasicRatesBitmap); 175 176 /* 177 * ACX100_Frm_Rate 178 * pHwMboxCmd field indicates the rate at which the wlan hardware transmits 179 * Beacon, Probe Response, RTS, and PS-Poll frames 180 */ 181 pCmd->txCtrlFrmRate = pBssInfoParams->txCtrlFrmRate; 182 183 WLAN_REPORT_INFORMATION(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 184 ("txCtrlFrmRate = 0x%x\n", pCmd->txCtrlFrmRate)); 185 /* 186 * PreambleOpt 187 * indicates the PLCP preamble type to use when transmitting 188 * Beacon, Probe Response, RTS, and PS-Poll frames. 189 */ 190 pCmd->txCtrlFrmMod = pBssInfoParams->txCtrlFrmModulation; 191 192 /* BSS ID - reversed order (see wlan hardware spec) */ 193 BssId = whal_ParamsGetBssId(pHwMboxCmd->pWhalParams); 194 cmdBssId = (UINT8*)&pCmd->bssIdL; 195 for (i=0; i<MAC_ADDR_SIZE; i++) 196 cmdBssId[i] = BssId[MAC_ADDR_SIZE-1-i]; 197 198 /* SSID string */ 199 pCmd->ssidLength = pWlanElm_Ssid->hdr.eleLen; 200 os_memoryCopy(pHwMboxCmd->hOs, (void *)(pCmd->ssidStr),(void *)pWlanElm_Ssid->serviceSetId, pWlanElm_Ssid->hdr.eleLen); 201 202 /* Set the Frame Rate and The Frame Mode */ 203 pCmd->txMgmtFrmRate = pBssInfoParams->txMgmtFrmRate; 204 pCmd->txMgmtFrmMod = pBssInfoParams->txMgmtFrmModulation; 205 206 /* Send the command */ 207 if(JoinCompleteCB == NULL) 208 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_START_JOIN, (char *)pCmd, sizeof(*pCmd))); 209 else 210 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, CMD_START_JOIN, (char *)pCmd, sizeof(*pCmd), (void *)JoinCompleteCB, CB_handle, NULL)); 211 212 } 213 214 215 /**************************************************************************** 216 * whal_hwMboxCmd_LNAControl() 217 **************************************************************************** 218 * DESCRIPTION: Construct the LNA control command fileds and send it to the mailbox 219 * 220 * INPUTS: None 221 * 222 * OUTPUT: None 223 * 224 * RETURNS: OK or NOK 225 ****************************************************************************/ 226 int whal_hwMboxCmd_LNAControl(HwMboxCmd_T *pHwMboxCmd, UINT8 LNAControlField) 227 { 228 LNAControl_t AcxCmd_LNAControl; 229 LNAControl_t *pCmd = &AcxCmd_LNAControl; 230 231 pCmd->LNAControlField = LNAControlField; 232 233 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_LNA_CONTROL , (char *)pCmd, sizeof(*pCmd))); 234 } 235 236 237 /**************************************************************************** 238 * whal_hwMboxCmd_Reset() 239 **************************************************************************** 240 * DESCRIPTION: Reset the Rx wlan hardware 241 * 242 * INPUTS: None 243 * 244 * OUTPUT: None 245 * 246 * RETURNS: OK or NOK 247 ****************************************************************************/ 248 int whal_hwMboxCmd_RxReset(HwMboxCmd_T *pHwMboxCmd) 249 { 250 /* 251 * no parameters 252 */ 253 254 /* 255 * Send the command 256 */ 257 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_RX_RESET, NULL, 0)); 258 } 259 260 /**************************************************************************** 261 * whal_hwMboxCmd_Reset() 262 **************************************************************************** 263 * DESCRIPTION: Reset the wlan hardware 264 * 265 * INPUTS: None 266 * 267 * OUTPUT: None 268 * 269 * RETURNS: OK or NOK 270 ****************************************************************************/ 271 int whal_hwMboxCmd_Reset(HwMboxCmd_T *pHwMboxCmd) 272 { 273 /* 274 * no parameters 275 */ 276 277 /* 278 * Send the command 279 */ 280 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_RESET, NULL, 0)); 281 } 282 283 /**************************************************************************** 284 * whal_hwMboxCmd_EnableRx() 285 **************************************************************************** 286 * DESCRIPTION: Construct the EnableRx command fileds and send it to the mailbox 287 * 288 * INPUTS: None 289 * 290 * OUTPUT: None 291 * 292 * RETURNS: OK or NOK 293 ****************************************************************************/ 294 int whal_hwMboxCmd_EnableRx(HwMboxCmd_T *pHwMboxCmd) 295 { 296 UINT8 ChannelNumber; 297 298 ChannelNumber = whal_ParamsGetDefaultChannel(pHwMboxCmd->pWhalParams); 299 300 /* 301 * Send the command 302 */ 303 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_ENABLE_RX, (char *)&ChannelNumber, sizeof(UINT8))); 304 } 305 306 /**************************************************************************** 307 * whal_hwMboxCmd_EnableTx() 308 **************************************************************************** 309 * DESCRIPTION: Construct the EnableTx command fileds and send it to the mailbox 310 * Note: This Enable_TX command is used also for changing the serving 311 * channel. 312 * 313 * INPUTS: None 314 * 315 * OUTPUT: None 316 * 317 * RETURNS: OK or NOK 318 ****************************************************************************/ 319 int whal_hwMboxCmd_EnableTx(HwMboxCmd_T *pHwMboxCmd ,UINT8 defaultChannel) 320 { 321 UINT8 ChannelNumber; 322 323 ChannelNumber = defaultChannel; 324 /* 325 * Send the command 326 */ 327 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_ENABLE_TX, (char *)&ChannelNumber, sizeof(UINT8))); 328 } 329 330 /**************************************************************************** 331 * whal_hwMboxCmd_DisableRx() 332 **************************************************************************** 333 * DESCRIPTION: Construct the DisableRx command fileds and send it to the mailbox 334 * 335 * INPUTS: None 336 * 337 * OUTPUT: None 338 * 339 * RETURNS: OK or NOK 340 ****************************************************************************/ 341 int whal_hwMboxCmd_DisableRx(HwMboxCmd_T *pHwMboxCmd) 342 { 343 /* 344 * no parameters 345 */ 346 347 /* 348 * Send the command 349 */ 350 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_DISABLE_RX, NULL, 0)); 351 } 352 353 /**************************************************************************** 354 * whal_hwMboxCmd_DisableTx() 355 **************************************************************************** 356 * DESCRIPTION: Construct the DisableTx command fileds and send it to the mailbox 357 * 358 * INPUTS: None 359 * 360 * OUTPUT: None 361 * 362 * RETURNS: OK or NOK 363 ****************************************************************************/ 364 int whal_hwMboxCmd_DisableTx(HwMboxCmd_T *pHwMboxCmd) 365 { 366 /* 367 * no parameters 368 */ 369 370 /* 371 * Send the command 372 */ 373 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_DISABLE_TX, NULL, 0)); 374 } 375 376 /**************************************************************************** 377 * whal_hwMboxCmd_ConfigureTemplateFrame() 378 **************************************************************************** 379 * DESCRIPTION: Generic function which sets the Fw with a template frame according 380 * to the given template type. 381 * 382 * INPUTS: templateType - CMD_BEACON, CMD_PROBE_REQ, CMD_PROBE_RESP etc. 383 * 384 * OUTPUT: None 385 * 386 * RETURNS: OK or NOK 387 ****************************************************************************/ 388 int whal_hwMboxCmd_ConfigureTemplateFrame(HwMboxCmd_T *pHwMboxCmd, UINT8 *pFrame, UINT16 FrameSize, 389 Command_e templateType, void *CBFunc,TI_HANDLE CBObj) 390 { 391 PktTemplate_t AcxCmd_PktTemplate; 392 PktTemplate_t *pCmd = &AcxCmd_PktTemplate; 393 394 /* if the frame size is too big - we truncate the frame template */ 395 if (FrameSize > MAX_TEMPLATES_SIZE) 396 { 397 WLAN_REPORT_ERROR(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 398 ("%s: Frame size (=%d) is bigger than MAX_TEMPLATES_SIZE(=%d) !!!\n", 399 __FUNCTION__,FrameSize,MAX_TEMPLATES_SIZE)); 400 401 FrameSize = MAX_TEMPLATES_SIZE; 402 } 403 404 /* if pFrame is NULL than it means that we just want to reserve place in Fw, and there is no need to copy */ 405 if (pFrame != NULL) 406 { 407 /* Set configuration fields */ 408 os_memoryCopy(pHwMboxCmd->hOs, (void *)&pCmd->templateStart, (void *)pFrame, FrameSize); 409 } 410 pCmd->len = ENDIAN_HANDLE_WORD(FrameSize); 411 412 if (NULL == CBFunc) 413 { 414 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, templateType, (char *)pCmd, FrameSize + sizeof(pCmd->len))); 415 } 416 else 417 { 418 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, templateType, (char *)pCmd, FrameSize + sizeof(pCmd->len), 419 CBFunc,CBObj,NULL)); 420 } 421 } 422 423 /**************************************************************************** 424 * whal_hwMboxCmd_TimTemplate() 425 **************************************************************************** 426 * DESCRIPTION: Build the tim template fileds and send it to the mailbox 427 * 428 * INPUTS: None 429 * 430 * OUTPUT: None 431 * 432 * RETURNS: OK or NOK 433 ****************************************************************************/ 434 int whal_hwMboxCmd_TimTemplate(HwMboxCmd_T *pHwMboxCmd, char BmapControl, char *PartialBmapVec, int PartialBmapLen) 435 { 436 VBMUpdateRequest_t AcxCmd_ConfTim; 437 VBMUpdateRequest_t *pCmd = &AcxCmd_ConfTim; 438 439 /* 440 * Set command fields 441 */ 442 os_memoryZero(pHwMboxCmd->hOs, (void *)pCmd, sizeof(*pCmd)); 443 444 /* 445 * Copy the fields and set sizes 446 */ 447 pCmd->tim.BitMap_ctrl = BmapControl; 448 /* dtimCount and dtimPeriod will be filled by the wlan hardware */ 449 os_memoryCopy(pHwMboxCmd->hOs, (void *)pCmd->tim.PVB_field, (void *)PartialBmapVec, PartialBmapLen); 450 pCmd->tim.identity = DOT11_TIM_ELE_ID; 451 pCmd->tim.length = 3+PartialBmapLen; 452 pCmd->len = ENDIAN_HANDLE_WORD(5+PartialBmapLen); 453 454 /* 455 * Send the command 456 */ 457 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_VBM, (char *)pCmd, sizeof(*pCmd))); 458 459 } 460 461 462 /**************************************************************************** 463 * whal_hwMboxCmd_SetKey() 464 **************************************************************************** 465 * DESCRIPTION: Construct the SetKey command fileds and send it to the mailbox 466 * 467 * INPUTS: 468 * Action - add/remove key 469 * MacAddr - relevant only for mapping keys 470 * KeySize - key size 471 * KeyType - default/mapping/TKIP 472 * KeyId - relevant only for default keys 473 * Key - key data 474 * 475 * OUTPUT: None 476 * 477 * RETURNS: OK or NOK 478 ****************************************************************************/ 479 int whal_hwMboxCmd_SetKey(HwMboxCmd_T *pHwMboxCmd, int Action, char *MacAddr, int KeySize, 480 int KeyType, int KeyId, char *Key, UINT16 SecuritySeqNumLow, UINT32 SecuritySeqNumHigh, 481 void *CB_Func, TI_HANDLE CB_handle) 482 { 483 SetKey_t AcxCmd_SetKey; 484 SetKey_t *pCmd = &AcxCmd_SetKey; 485 486 /* 487 * Set command fields 488 */ 489 os_memoryZero(pHwMboxCmd->hOs, (void *)pCmd, sizeof(*pCmd)); 490 491 /* 492 * Command fields 493 */ 494 os_memoryCopy(pHwMboxCmd->hOs, (void *)pCmd->addr, (void *)MacAddr, MAC_ADDR_SIZE); 495 if (KeySize > MAX_KEY_SIZE) 496 { 497 os_memoryCopy(pHwMboxCmd->hOs, (void *)pCmd->key, (void *)Key, MAX_KEY_SIZE); 498 } else { 499 os_memoryCopy(pHwMboxCmd->hOs, (void *)pCmd->key, (void *)Key, KeySize); 500 } 501 pCmd->action = (UINT8)Action; 502 pCmd->keySize = (UINT8)KeySize; 503 pCmd->type = (UINT8)KeyType; 504 pCmd->id = (UINT8)KeyId; 505 pCmd->ssidProfile = 0; 506 507 /* 508 * Preserve TKIP/AES security sequence number after recovery. 509 * Note that our STA Tx is currently using only one sequence-counter 510 * for all ACs (unlike the Rx which is separated per AC). 511 */ 512 pCmd->AcSeqNum16[0] = SecuritySeqNumLow; 513 pCmd->AcSeqNum16[1] = 0; 514 pCmd->AcSeqNum16[2] = 0; 515 pCmd->AcSeqNum16[3] = 0; 516 517 pCmd->AcSeqNum32[0] = SecuritySeqNumHigh; 518 pCmd->AcSeqNum32[1] = 0; 519 pCmd->AcSeqNum32[2] = 0; 520 pCmd->AcSeqNum32[3] = 0; 521 522 523 WLAN_REPORT_WARNING(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 524 ("*********************** \n")); 525 526 WLAN_REPORT_WARNING(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 527 ("whal_hwMboxCmd_SetKey \n")); 528 529 WLAN_REPORT_WARNING(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 530 ("*********************** \n")); 531 532 WLAN_REPORT_WARNING(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 533 ("addr = %x:%x:%x:%x:%x:%x \n", 534 pCmd->addr[0], pCmd->addr[1], pCmd->addr[2], pCmd->addr[3], pCmd->addr[4], pCmd->addr[5] )); 535 536 WLAN_REPORT_WARNING(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 537 (" key= %x\n, action= %d\n keySize= %d\n type= %d\n id= %d\n AcSeqNum16[0]= %d\n AcSeqNum32[0]= %d\n", 538 pCmd->key,pCmd->action,pCmd->keySize,pCmd->type, pCmd->id, pCmd->AcSeqNum16[0], pCmd->AcSeqNum32[0] )); 539 540 WLAN_REPORT_WARNING(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 541 ("*********************** \n")); 542 543 /* 544 * Send the command 545 */ 546 if((CB_Func == NULL) || (CB_handle == NULL)) 547 { 548 WLAN_REPORT_WARNING(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 549 ("*** whal_hwMboxCmd_SetKey:Calling CmdQueue_Command *** \n")); 550 551 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_SET_KEYS, (char *)pCmd, sizeof(*pCmd))); 552 } 553 else 554 { 555 WLAN_REPORT_WARNING(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 556 ("!!! whal_hwMboxCmd_SetKey:CmdQueue_CommandwithCB !!! \n")); 557 558 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, CMD_SET_KEYS, (char *)pCmd, sizeof(*pCmd), CB_Func, CB_handle, NULL)); 559 } 560 } 561 562 563 /**************************************************************************** 564 * whal_hwMboxCmd_Test() 565 **************************************************************************** 566 * DESCRIPTION: Test NO WAIT (use EnableRx command) 567 * 568 * INPUTS: None 569 * 570 * OUTPUT: None 571 * 572 * RETURNS: OK or NOK 573 ****************************************************************************/ 574 int whal_hwMboxCmd_Test(HwMboxCmd_T *pHwMboxCmd) 575 { 576 UINT8 ChannelNumber = whal_ParamsGetRadioChannel(pHwMboxCmd->pWhalParams); 577 578 /* 579 * Send the command 580 */ 581 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_ENABLE_RX, (char *)&ChannelNumber, sizeof(UINT8))); 582 } 583 584 /**************************************************************************** 585 * whal_hwMboxCmd_StartScan () 586 **************************************************************************** 587 * DESCRIPTION: Send SCAN Command 588 * 589 * INPUTS: None 590 * 591 * OUTPUT: None 592 * 593 * RETURNS: OK or NOK 594 ****************************************************************************/ 595 int whal_hwMboxCmd_StartScan (HwMboxCmd_T *pHwMboxCmd, ScanParameters_t* pScanParams ,void* ScanCommandResponseCB, TI_HANDLE CB_handle) 596 { 597 return CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue,CMD_SCAN, (char *)pScanParams, sizeof(ScanParameters_t), 598 (void *)ScanCommandResponseCB, CB_handle, NULL /* void* CB_Buf */); 599 } 600 601 /**************************************************************************** 602 * whal_hwMboxCmd_StartSPSScan () 603 **************************************************************************** 604 * DESCRIPTION: Send SPS SCAN Command 605 * 606 * INPUTS: None 607 * 608 * OUTPUT: None 609 * 610 * RETURNS: OK or NOK 611 ****************************************************************************/ 612 int whal_hwMboxCmd_StartSPSScan (HwMboxCmd_T *pHwMboxCmd, ScheduledScanParameters_t* pScanParams, void* ScanCommandResponseCB, TI_HANDLE CB_handle) 613 { 614 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, CMD_SPS_SCAN, (char *)pScanParams, sizeof(ScheduledScanParameters_t), 615 (void *)ScanCommandResponseCB, CB_handle, NULL )); 616 } 617 618 /**************************************************************************** 619 * whal_hwMboxCmd_StopScan () 620 **************************************************************************** 621 * DESCRIPTION: Construct the STOP_SCAN command fields and send it to the 622 * mailbox 623 * 624 * INPUTS: None 625 * 626 * OUTPUT: None 627 * 628 * RETURNS: OK or NOK 629 ****************************************************************************/ 630 int whal_hwMboxCmd_StopScan (HwMboxCmd_T *pHwMboxCmd, void *ScanCommandResponseCB, TI_HANDLE CB_handle) 631 { 632 WLAN_REPORT_INFORMATION(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 633 ("whal_hwMboxCmd_StopScan: -------------- \n")); 634 635 if (NULL != ScanCommandResponseCB) 636 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, CMD_STOP_SCAN, 0, 0, (void *)ScanCommandResponseCB,CB_handle,NULL)); 637 else 638 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_STOP_SCAN, 0, 0)); 639 } 640 641 /**************************************************************************** 642 * whal_hwMboxCmd_StopSPSScan () 643 **************************************************************************** 644 * DESCRIPTION: Construct the STOP_SPS_SCAN command fields and send it to the 645 * mailbox 646 * 647 * INPUTS: None 648 * 649 * OUTPUT: None 650 * 651 * RETURNS: OK or NOK 652 ****************************************************************************/ 653 int whal_hwMboxCmd_StopSPSScan (HwMboxCmd_T *pHwMboxCmd, void* ScanCommandResponseCB, TI_HANDLE CB_handle) 654 { 655 WLAN_REPORT_INFORMATION(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 656 ("whal_hwMboxCmd_StopSPSScan: -------------- \n")); 657 if (NULL != ScanCommandResponseCB) 658 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, CMD_STOP_SPS_SCAN, 0, 0, (void *)ScanCommandResponseCB, CB_handle, NULL )); 659 else 660 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_STOP_SPS_SCAN, 0, 0)); 661 662 } 663 664 /**************************************************************************** 665 * whal_hwMboxCmd_GenCmd () 666 **************************************************************************** 667 * DESCRIPTION: Send any command 668 * INPUTS: None 669 * 670 * OUTPUT: None 671 * 672 * RETURNS: OK or NOK 673 ****************************************************************************/ 674 int whal_hwMboxCmd_GenCmd(HwMboxCmd_T *pHwMboxCmd,short CmdId, char* pBuf, UINT32 Length) 675 { 676 WLAN_REPORT_INFORMATION(pHwMboxCmd->hReport, HAL_HW_CTRL_MODULE_LOG, 677 ("whal_hwMboxCmd_GenCmd: -------------- \n")); 678 679 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CmdId, pBuf, Length)); 680 } 681 682 /**************************************************************************** 683 * whal_hwMboxCmd_NoiseHistogramCmd () 684 **************************************************************************** 685 * DESCRIPTION: Send NOISE_HISTOGRAM Command 686 * 687 * INPUTS: None 688 * 689 * OUTPUT: None 690 * 691 * RETURNS: OK or NOK 692 ****************************************************************************/ 693 int whal_hwMboxCmd_NoiseHistogramCmd (HwMboxCmd_T *pHwMboxCmd, whalCtrl_noiseHistogram_t* pNoiseHistParams) 694 { 695 NoiseHistRequest_t AcxCmd_NoiseHistogram; 696 NoiseHistRequest_t *pCmd = &AcxCmd_NoiseHistogram; 697 698 os_memoryZero(pHwMboxCmd->hOs, (void *)pCmd, sizeof(*pCmd)); 699 700 pCmd->mode = (uint16)pNoiseHistParams->cmd; 701 pCmd->sampleIntervalUSec = pNoiseHistParams->sampleInterval; 702 703 os_memoryCopy(pHwMboxCmd->hOs, (void *)&(pCmd->thresholds[0]), (void *)&(pNoiseHistParams->ranges[0]), MEASUREMENT_NOISE_HISTOGRAM_NUM_OF_RANGES); 704 705 /* Send the command */ 706 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_NOISE_HIST, (char *)pCmd, sizeof(*pCmd))); 707 } 708 709 /**************************************************************************** 710 * whal_hwMboxCmd_PowerMgmtConfiguration() 711 **************************************************************************** 712 * DESCRIPTION: send Command for Power Management configuration 713 * to the mailbox 714 * 715 * INPUTS: None 716 * 717 * OUTPUT: None 718 * 719 * RETURNS: OK or NOK 720 ****************************************************************************/ 721 int whal_hwMboxCmd_PowerMgmtConfiguration (HwMboxCmd_T *pHwMboxCmd,whalCtrl_powerSaveParams_t* powerSaveParams) 722 /*whalCtrl_powerMgmtConfig_t* pPowerMgmtParams)*/ 723 { 724 PSModeParameters_t Cmd_PowerMgmtCnf; 725 PSModeParameters_t * pCmd = &Cmd_PowerMgmtCnf; 726 727 os_memoryZero(pHwMboxCmd->hOs, (void *)pCmd, sizeof(*pCmd)); 728 729 if(powerSaveParams->ps802_11Enable == TRUE) 730 pCmd->mode = 1; 731 732 else 733 pCmd->mode = 0; 734 735 pCmd->hangOverPeriod = powerSaveParams->hangOverPeriod; 736 pCmd->needToSendNullData = powerSaveParams->needToSendNullData; 737 pCmd->rateToTransmitNullData = ENDIAN_HANDLE_WORD(powerSaveParams->NullPktRateModulation); 738 pCmd->numberOfRetries = powerSaveParams->numNullPktRetries; 739 740 741 /* 742 * Send the command 743 */ 744 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, CMD_SET_PS_MODE, (char *)pCmd, sizeof(*pCmd),(void *)powerSaveParams->powerSavecmdResponseCB,powerSaveParams->powerSaveCBObject,NULL)); 745 } 746 747 748 /**************************************************************************** 749 * whal_hwMboxCmd_SwitchChannelCmd () 750 **************************************************************************** 751 * DESCRIPTION: Send CMD_SWITCH_CHANNEL Command 752 * 753 * INPUTS: None 754 * 755 * OUTPUT: None 756 * 757 * RETURNS: OK or NOK 758 ****************************************************************************/ 759 int whal_hwMboxCmd_SwitchChannelCmd (HwMboxCmd_T *pHwMboxCmd, whalCtrl_switchChannelCmd_t *pSwitchChannelCmd) 760 { 761 ChannelSwitchParameters_t AcxCmd_SwitchChannel; 762 ChannelSwitchParameters_t *pCmd = &AcxCmd_SwitchChannel; 763 764 os_memoryZero(pHwMboxCmd->hOs, (void *)pCmd, sizeof(*pCmd)); 765 766 pCmd->channel = pSwitchChannelCmd->channelNumber; 767 pCmd->switchTime = pSwitchChannelCmd->switchTime; 768 pCmd->txSuspend = pSwitchChannelCmd->txFlag; 769 pCmd->flush = pSwitchChannelCmd->flush; 770 771 /* Send the command */ 772 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_CHANNEL_SWITCH, (char *)pCmd, sizeof(*pCmd))); 773 } 774 775 776 /**************************************************************************** 777 * whal_hwMboxCmd_SwitchChannelCancelCmd () 778 **************************************************************************** 779 * DESCRIPTION: Send CMD_SWITCH_CHANNEL_CANCEL Command 780 * 781 * INPUTS: None 782 * 783 * OUTPUT: None 784 * 785 * RETURNS: OK or NOK 786 ****************************************************************************/ 787 int whal_hwMboxCmd_SwitchChannelCancelCmd (HwMboxCmd_T *pHwMboxCmd) 788 { 789 790 /* Send the command */ 791 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_STOP_CHANNEL_SWICTH, 0, 0)); 792 } 793 794 /**************************************************************************** 795 * whal_hwMboxCmd_FwDisconnect() 796 **************************************************************************** 797 * DESCRIPTION: Construct the Disconnect command fileds and send it to the mailbox 798 * 799 * INPUTS: None 800 * 801 * OUTPUT: None 802 * 803 * RETURNS: OK or NOK 804 ****************************************************************************/ 805 int whal_hwMboxCmd_FwDisconnect(HwMboxCmd_T *pHwMboxCmd, uint32 ConfigOptions, uint32 FilterOptions) 806 { 807 DisconnectParameters_t AcxCmd_Disconnect; 808 809 AcxCmd_Disconnect.rxFilter.ConfigOptions = ConfigOptions; 810 AcxCmd_Disconnect.rxFilter.FilterOptions = FilterOptions; 811 /* 812 * Send the command 813 */ 814 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_DISCONNECT, (char *)&AcxCmd_Disconnect, sizeof(AcxCmd_Disconnect))); 815 816 } /* whal_hwMboxCmd_FWDisconnect()*/ 817 818 819 820 821 822 /**************************************************************************** 823 * whal_hwMboxCmd_measurementParams() 824 **************************************************************************** 825 * DESCRIPTION: send Command for measurement configuration 826 * to the mailbox 827 * 828 * INPUTS: None 829 * 830 * OUTPUT: None 831 * 832 * RETURNS: OK or NOK 833 ****************************************************************************/ 834 int whal_hwMboxCmd_measurement (HwMboxCmd_T *pHwMboxCmd, whalCtrl_MeasurementParameters_t* pMeasurementParams, 835 void* MeasureCommandResponseCB, TI_HANDLE CB_handle) 836 { 837 MeasurementParameters_t Cmd_MeasurementParam; 838 MeasurementParameters_t *pCmd = &Cmd_MeasurementParam; 839 840 os_memoryZero(pHwMboxCmd->hOs, (void *)pCmd, sizeof(*pCmd)); 841 842 pCmd->band = pMeasurementParams->band; 843 pCmd->channel = pMeasurementParams->channel; 844 pCmd->duration = ENDIAN_HANDLE_LONG(pMeasurementParams->duration); 845 pCmd->rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG(pMeasurementParams->ConfigOptions); 846 pCmd->rxFilter.FilterOptions = ENDIAN_HANDLE_LONG(pMeasurementParams->FilterOptions); 847 /* 848 * Send the command 849 */ 850 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, CMD_MEASUREMENT, (char *)pCmd, sizeof(*pCmd), 851 (void *)MeasureCommandResponseCB, CB_handle, NULL)); 852 } 853 854 /**************************************************************************** 855 * whal_hwMboxCmd_measurementStop() 856 **************************************************************************** 857 * DESCRIPTION: send Command for stoping measurement 858 * 859 * INPUTS: None 860 * 861 * OUTPUT: None 862 * 863 * RETURNS: OK or NOK 864 ****************************************************************************/ 865 int whal_hwMboxCmd_measurementStop (HwMboxCmd_T *pHwMboxCmd, void* MeasureCommandResponseCB, TI_HANDLE CB_handle) 866 { 867 /* 868 * Send the command 869 */ 870 return (CmdQueue_CommandWithCb(pHwMboxCmd->hCmdMboxQueue, CMD_STOP_MEASUREMENT, 0, 0, 871 (void *)MeasureCommandResponseCB, CB_handle, NULL)); 872 } 873 /**************************************************************************** 874 * whal_hwMboxCmd_ApDiscovery() 875 **************************************************************************** 876 * DESCRIPTION: send Command for AP Discovery 877 * to the mailbox 878 * 879 * INPUTS: None 880 * 881 * OUTPUT: None 882 * 883 * RETURNS: OK or NOK 884 ****************************************************************************/ 885 int whal_hwMboxCmd_ApDiscovery (HwMboxCmd_T *pHwMboxCmd, whalCtrl_ApDiscoveryParameters_t* pApDiscoveryParams) 886 { 887 ApDiscoveryParameters_t Cmd_ApDiscovery; 888 ApDiscoveryParameters_t *pCmd = &Cmd_ApDiscovery; 889 890 os_memoryZero(pHwMboxCmd->hOs, (void *)pCmd, sizeof(*pCmd)); 891 892 pCmd->txPowerAttenuation = pApDiscoveryParams->txPowerDbm; 893 pCmd->numOfProbRqst = pApDiscoveryParams->numOfProbRqst; 894 pCmd->scanDuration = ENDIAN_HANDLE_LONG(pApDiscoveryParams->scanDuration); 895 pCmd->scanOptions = ENDIAN_HANDLE_WORD(pApDiscoveryParams->scanOptions); 896 pCmd->txdRateSet = ENDIAN_HANDLE_WORD(pApDiscoveryParams->txdRateSet); 897 pCmd->rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG(pApDiscoveryParams->ConfigOptions); 898 pCmd->rxFilter.FilterOptions = ENDIAN_HANDLE_LONG(pApDiscoveryParams->FilterOptions); 899 /* 900 * Send the command 901 */ 902 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_AP_DISCOVERY, (char *)pCmd, sizeof(*pCmd))); 903 } 904 /**************************************************************************** 905 * whal_hwMboxCmd_ApDiscoveryStop() 906 **************************************************************************** 907 * DESCRIPTION: send Command for stoping AP Discovery 908 * 909 * INPUTS: None 910 * 911 * OUTPUT: None 912 * 913 * RETURNS: OK or NOK 914 ****************************************************************************/ 915 int whal_hwMboxCmd_ApDiscoveryStop (HwMboxCmd_T *pHwMboxCmd) 916 { 917 /* 918 * Send the command 919 */ 920 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_STOP_AP_DISCOVERY, 0, 0)); 921 922 } 923 924 925 /**************************************************************************** 926 * whal_hwMboxCmd_HealthCheck() 927 **************************************************************************** 928 * DESCRIPTION: 929 * 930 * INPUTS: 931 * 932 * OUTPUT: 933 * 934 * RETURNS: 935 ****************************************************************************/ 936 int whal_hwMboxCmd_HealthCheck(HwMboxCmd_T *pHwMboxCmd) 937 { 938 /* 939 * no parameters 940 */ 941 942 /* 943 * Send the command 944 */ 945 return (CmdQueue_Command(pHwMboxCmd->hCmdMboxQueue, CMD_HEALTH_CHECK, NULL, 0)); 946 } 947 948
