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 ****************************************************************************/
whal_hwMboxCmd_Create(TI_HANDLE hOs,WhalParams_T * pWhalParams)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 ****************************************************************************/
whal_hwMboxCmd_Destroy(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_Config(HwMboxCmd_T * pHwMboxCmd,TI_HANDLE hCmdMboxQueue,TI_HANDLE hReport)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 ****************************************************************************/
whal_hwMboxCmd_StartBss(HwMboxCmd_T * pHwMboxCmd,BSS_e BssType,void * JoinCompleteCB,TI_HANDLE CB_handle)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 ****************************************************************************/
whal_hwMboxCmd_LNAControl(HwMboxCmd_T * pHwMboxCmd,UINT8 LNAControlField)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 ****************************************************************************/
whal_hwMboxCmd_RxReset(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_Reset(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_EnableRx(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_EnableTx(HwMboxCmd_T * pHwMboxCmd,UINT8 defaultChannel)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 ****************************************************************************/
whal_hwMboxCmd_DisableRx(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_DisableTx(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_ConfigureTemplateFrame(HwMboxCmd_T * pHwMboxCmd,UINT8 * pFrame,UINT16 FrameSize,Command_e templateType,void * CBFunc,TI_HANDLE CBObj)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 ****************************************************************************/
whal_hwMboxCmd_TimTemplate(HwMboxCmd_T * pHwMboxCmd,char BmapControl,char * PartialBmapVec,int PartialBmapLen)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 ****************************************************************************/
whal_hwMboxCmd_SetKey(HwMboxCmd_T * pHwMboxCmd,int Action,char * MacAddr,int KeySize,int KeyType,int KeyId,char * Key,UINT16 SecuritySeqNumLow,UINT32 SecuritySeqNumHigh,void * CB_Func,TI_HANDLE CB_handle)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 ****************************************************************************/
whal_hwMboxCmd_Test(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_StartScan(HwMboxCmd_T * pHwMboxCmd,ScanParameters_t * pScanParams,void * ScanCommandResponseCB,TI_HANDLE CB_handle)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 ****************************************************************************/
whal_hwMboxCmd_StartSPSScan(HwMboxCmd_T * pHwMboxCmd,ScheduledScanParameters_t * pScanParams,void * ScanCommandResponseCB,TI_HANDLE CB_handle)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 ****************************************************************************/
whal_hwMboxCmd_StopScan(HwMboxCmd_T * pHwMboxCmd,void * ScanCommandResponseCB,TI_HANDLE CB_handle)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 ****************************************************************************/
whal_hwMboxCmd_StopSPSScan(HwMboxCmd_T * pHwMboxCmd,void * ScanCommandResponseCB,TI_HANDLE CB_handle)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 ****************************************************************************/
whal_hwMboxCmd_GenCmd(HwMboxCmd_T * pHwMboxCmd,short CmdId,char * pBuf,UINT32 Length)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 ****************************************************************************/
whal_hwMboxCmd_NoiseHistogramCmd(HwMboxCmd_T * pHwMboxCmd,whalCtrl_noiseHistogram_t * pNoiseHistParams)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 ****************************************************************************/
whal_hwMboxCmd_PowerMgmtConfiguration(HwMboxCmd_T * pHwMboxCmd,whalCtrl_powerSaveParams_t * powerSaveParams)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 ****************************************************************************/
whal_hwMboxCmd_SwitchChannelCmd(HwMboxCmd_T * pHwMboxCmd,whalCtrl_switchChannelCmd_t * pSwitchChannelCmd)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 ****************************************************************************/
whal_hwMboxCmd_SwitchChannelCancelCmd(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_FwDisconnect(HwMboxCmd_T * pHwMboxCmd,uint32 ConfigOptions,uint32 FilterOptions)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 ****************************************************************************/
whal_hwMboxCmd_measurement(HwMboxCmd_T * pHwMboxCmd,whalCtrl_MeasurementParameters_t * pMeasurementParams,void * MeasureCommandResponseCB,TI_HANDLE CB_handle)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 ****************************************************************************/
whal_hwMboxCmd_measurementStop(HwMboxCmd_T * pHwMboxCmd,void * MeasureCommandResponseCB,TI_HANDLE CB_handle)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 ****************************************************************************/
whal_hwMboxCmd_ApDiscovery(HwMboxCmd_T * pHwMboxCmd,whalCtrl_ApDiscoveryParameters_t * pApDiscoveryParams)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 ****************************************************************************/
whal_hwMboxCmd_ApDiscoveryStop(HwMboxCmd_T * pHwMboxCmd)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 ****************************************************************************/
whal_hwMboxCmd_HealthCheck(HwMboxCmd_T * pHwMboxCmd)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