1/*
2 * CmdBldCmdIE.c
3 *
4 * Copyright(c) 1998 - 2009 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/** \file  CmdBldCmdIE.c
36 *  \brief Command builder. Command information elements
37 *
38 *  \see   CmdBldCmdIE.h
39 */
40#define __FILE_ID__  FILE_ID_94
41#include "osApi.h"
42#include "tidef.h"
43#include "report.h"
44#include "TWDriver.h"
45#include "CmdQueue_api.h"
46#include "CmdBld.h"
47
48
49/* Local Macros */
50
51#define MAC_TO_VENDOR_PREAMBLE(mac) ((mac[0] << 16) | (mac[1] << 8) | mac[2])
52
53/*******************************************
54 * Wlan hardware Test (BIT)
55 * =================
56 *
57 * Tests description:
58 * ==================
59 * FCC           = Continuous modulated transmission (should not emit carrier)
60 * TELEC         = Continuous unmodulated carrier transmission (carrier only)
61 * PER_TX_STOP   = Stops the TX test in progress (FCC or TELEC).
62 * ReadRegister  = Read a register value.
63 * WriteRegister = Sets a register value.
64*
65* Rx PER test
66* ========
67* PerRxStart       = Start or resume the PER measurement. This function will put the device in promiscuous mode, and resume counters update.
68* PerRxStop        = Stop Rx PER measurements. This function stop counters update and make it is safe to read the PER test result.
69* PerRxGetResults  = Get the last Rx PER test results.
70* PerRxClear       = Clear the Rx PER test results.
71 */
72
73enum
74{
75/* 0 */   TEST_MOD_QPSK,
76/* 1 */   TEST_MOD_CCK,
77/* 2 */   TEST_MOD_PBCC,
78          TEST_MOD_NUMOF
79};
80
81enum
82{
83/* 0 */   TEST_MOD_LONG_PREAMBLE,
84/* 1 */   TEST_MOD_SHORT_PREAMBLE
85};
86
87enum
88{
89/* 0 */   TEST_BAND_2_4GHZ,
90/* 1 */   TEST_BAND_5GHZ,
91/* 2 */   TEST_BAND_4_9GHZ
92};
93
94
95enum
96{
97    MOD_PBCC = 1,
98    MOD_CCK,
99    MOD_OFDM
100};
101
102
103#define TEST_MOD_MIN_GAP           200
104#define TEST_MOD_MIN_TX_BODYLEN    0
105#define TEST_MOD_MAX_TX_BODYLEN    2304
106
107#define TEST_RX_CAL_SAFE_TIME      5000  /*uSec*/
108
109#define TEST_MOD_IS_GAP_OK(gap)     ((gap) >= TEST_MOD_MIN_GAP)
110
111#define TEST_MOD_IS_TX_BODYLEN_OK(len)  \
112   (INRANGE((len), TEST_MOD_MIN_TX_BODYLEN, TEST_MOD_MAX_TX_BODYLEN) && \
113   (((len) & 3) == 0) )
114
115#define TEST_MOD_IS_PREAMBLE_OK(p)  \
116   INRANGE((p), TEST_MOD_LONG_PREAMBLE, TEST_MOD_SHORT_PREAMBLE)
117
118
119#define RESEARVED_SIZE_FOR_RESPONSE 4
120
121
122/****************************************************************************
123 *                      cmdBld_CmdIeStartBss()
124 ****************************************************************************
125 * DESCRIPTION: Construct the StartBss command fileds and send it to the mailbox
126 *
127 * INPUTS: None
128 *
129 * OUTPUT:  None
130 *
131 * RETURNS: TI_OK or TI_NOK
132 ****************************************************************************/
133TI_STATUS cmdBld_CmdIeStartBss (TI_HANDLE hCmdBld, BSS_e BssType, void *fJoinCompleteCb, TI_HANDLE hCb)
134{
135    TCmdBld            *pCmdBld = (TCmdBld *)hCmdBld;
136    StartJoinRequest_t  AcxCmd_StartBss;
137    StartJoinRequest_t *pCmd = &AcxCmd_StartBss;
138    TSsid              *pSsid = &DB_BSS(hCmdBld).tSsid;
139    TBssInfoParams     *pBssInfoParams = &DB_BSS(hCmdBld);
140    TI_UINT8 *BssId;
141    TI_UINT8 *cmdBssId;
142    EHwRateBitFiled HwBasicRatesBitmap;
143    TI_UINT32 i;
144
145    os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(StartJoinRequest_t));
146
147    /*
148     * Set RxCfg and RxFilterCfg values
149     */
150    pCmd->rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG (DB_WLAN(hCmdBld).RxConfigOption);
151    pCmd->rxFilter.FilterOptions = ENDIAN_HANDLE_LONG (DB_WLAN(hCmdBld).RxFilterOption);
152    pCmd->beaconInterval = ENDIAN_HANDLE_WORD (DB_BSS(hCmdBld).BeaconInterval);
153    pCmd->dtimInterval = DB_BSS(hCmdBld).DtimInterval;
154    pCmd->channelNumber = DB_BSS(hCmdBld).RadioChannel;
155    pCmd->bssType = BssType;
156    /* Add radio band */
157    pCmd->bssType |= DB_WLAN(hCmdBld).RadioBand << 4;
158    /* Bits 0-2: Tx-Session-Count. bit 7: indicates if to flush the Tx queues */
159    pCmd->ctrl = pBssInfoParams->Ctrl;
160
161    /*
162     * BasicRateSet
163     * The wlan hardware uses pHwMboxCmd field to determine the rate at which to transmit
164     * control frame responses (such as ACK or CTS frames)
165     */
166    cmdBld_ConvertAppRatesBitmap (pBssInfoParams->BasicRateSet, 0, &HwBasicRatesBitmap);
167    pCmd->basicRateSet = ENDIAN_HANDLE_LONG(HwBasicRatesBitmap);
168
169    /* BSS ID - reversed order (see wlan hardware spec) */
170    BssId = DB_BSS(hCmdBld).BssId;
171    cmdBssId = (TI_UINT8*)&pCmd->bssIdL;
172    for (i = 0; i < MAC_ADDR_LEN; i++)
173        cmdBssId[i] = BssId[MAC_ADDR_LEN - 1 - i];
174
175    /* SSID string */
176    pCmd->ssidLength = pSsid->len;
177    os_memoryCopy (pCmdBld->hOs, (void *)pCmd->ssidStr, (void *)pSsid->str, pSsid->len);
178
179    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
180                             CMD_START_JOIN,
181                             (TI_CHAR *)pCmd,
182                             sizeof(*pCmd),
183                             fJoinCompleteCb,
184                             hCb,
185                             NULL);
186}
187
188
189/****************************************************************************
190 *                      cmdBld_CmdIeEnableRx()
191 ****************************************************************************
192 * DESCRIPTION: Construct the EnableRx command fileds and send it to the mailbox
193 *
194 * INPUTS: None
195 *
196 * OUTPUT:  None
197 *
198 * RETURNS: TI_OK or TI_NOK
199 ****************************************************************************/
200TI_STATUS cmdBld_CmdIeEnableRx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
201{
202    TCmdBld  *pCmdBld = (TCmdBld *)hCmdBld;
203    TI_UINT8  uChannelNumber;
204
205    uChannelNumber = DB_DEFAULT_CHANNEL (hCmdBld);
206
207    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
208                             CMD_ENABLE_RX,
209                             (TI_CHAR *)&uChannelNumber,
210                             sizeof(TI_UINT8),
211                             fCb,
212                             hCb,
213                             NULL);
214}
215
216
217/****************************************************************************
218 *                      cmdBld_CmdIeEnableTx()
219 ****************************************************************************
220 * DESCRIPTION: Construct the EnableTx command fileds and send it to the mailbox
221 *              Note: This Enable_TX command is used also for changing the serving
222 *              channel.
223 *
224 * INPUTS: None
225 *
226 * OUTPUT:  None
227 *
228 * RETURNS: TI_OK or TI_NOK
229 ****************************************************************************/
230TI_STATUS cmdBld_CmdIeEnableTx (TI_HANDLE hCmdBld, TI_UINT8 channel, void *fCb, TI_HANDLE hCb)
231{
232    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
233
234    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
235                             CMD_ENABLE_TX,
236                             (TI_CHAR *)&channel,
237                             sizeof(TI_UINT8),
238                             fCb,
239                             hCb,
240                             NULL);
241}
242
243
244/****************************************************************************
245 *                      cmdBld_CmdIeDisableRx()
246 ****************************************************************************
247 * DESCRIPTION: Construct the DisableRx command fileds and send it to the mailbox
248 *
249 * INPUTS: None
250 *
251 * OUTPUT:  None
252 *
253 * RETURNS: TI_OK or TI_NOK
254 ****************************************************************************/
255TI_STATUS cmdBld_CmdIeDisableRx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
256{
257    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
258
259    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_DISABLE_RX, NULL, 0, fCb, hCb, NULL);
260}
261
262/****************************************************************************
263 *                      cmdBld_CmdIeDisableTx()
264 ****************************************************************************
265 * DESCRIPTION: Construct the DisableTx command fileds and send it to the mailbox
266 *
267 * INPUTS: None
268 *
269 * OUTPUT:  None
270 *
271 * RETURNS: TI_OK or TI_NOK
272 ****************************************************************************/
273TI_STATUS cmdBld_CmdIeDisableTx (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
274{
275    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
276
277    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_DISABLE_TX, NULL, 0, fCb, hCb, NULL);
278}
279
280/****************************************************************************
281 *                      cmdBld_CmdIeConfigureTemplateFrame()
282 ****************************************************************************
283 * DESCRIPTION: Generic function which sets the Fw with a template frame according
284 *              to the given template type.
285 *
286 * INPUTS: templateType - CMD_BEACON, CMD_PROBE_REQ, CMD_PROBE_RESP etc.
287 *
288 * OUTPUT:  None
289 *
290 * RETURNS: TI_OK or TI_NOK
291 ****************************************************************************/
292TI_STATUS cmdBld_CmdIeConfigureTemplateFrame (TI_HANDLE         hCmdBld,
293                                              TTemplateParams  *pTemplate,
294                                              TI_UINT16         uFrameSize,
295                                              TemplateType_e    eTemplateType,
296                                              TI_UINT8          uIndex,
297                                              void *            fCb,
298                                              TI_HANDLE         hCb)
299{
300    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
301    PktTemplate_t AcxCmd_PktTemplate;
302    PktTemplate_t *pCmd = &AcxCmd_PktTemplate;
303
304    /* If the frame size is too big - we truncate the frame template */
305    if (uFrameSize > MAX_TEMPLATES_SIZE)
306    {
307        TRACE3(pCmdBld->hReport, REPORT_SEVERITY_ERROR, ": Frame size (=%d) of CmdType (=%d) is bigger than MAX_TEMPLATES_SIZE(=%d) !!!\n", uFrameSize, eTemplateType, MAX_TEMPLATES_SIZE);
308
309        uFrameSize = MAX_TEMPLATES_SIZE;
310    }
311
312    /* if pTemplate is NULL than it means that we just want to reserve place in Fw, and there is no need to copy */
313    if (pTemplate != NULL)
314    {
315        os_memoryCopy(pCmdBld->hOs, (void *)&pCmd->templateStart, (void *)(pTemplate->Buffer), uFrameSize);
316        pCmd->templateTxAttribute.enabledRates    = pTemplate->uRateMask;
317    }
318    pCmd->len = ENDIAN_HANDLE_WORD(uFrameSize);
319    pCmd->index = uIndex;
320    pCmd->templateType = eTemplateType;
321    pCmd->templateTxAttribute.shortRetryLimit = 10;
322    pCmd->templateTxAttribute.longRetryLimit  = 10;
323
324#ifdef TI_DBG
325    if (pCmdBld->uDbgTemplatesRateMask != 0)
326    {
327        pCmd->templateTxAttribute.enabledRates = pCmdBld->uDbgTemplatesRateMask;
328    }
329#endif
330
331    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
332                             CMD_SET_TEMPLATE,
333                             (TI_CHAR *)pCmd,
334                             sizeof (PktTemplate_t),
335                             fCb,
336                             hCb,
337                             NULL);
338}
339
340
341/****************************************************************************
342 *                      cmdBld_CmdIeSetKey()
343 ****************************************************************************
344 * DESCRIPTION: Construct the SetKey command fileds and send it to the mailbox
345 *
346 * INPUTS:
347 *      Action      - add/remove key
348 *      MacAddr     - relevant only for mapping keys
349 *      KeySize     - key size
350 *      KeyType     - default/mapping/TKIP
351 *      KeyId       - relevant only for default keys
352 *      Key         - key data
353 *
354 * OUTPUT:  None
355 *
356 * RETURNS: TI_OK or TI_NOK
357 ****************************************************************************/
358TI_STATUS cmdBld_CmdIeSetKey (TI_HANDLE hCmdBld,
359                              TI_UINT32 action,
360                              TI_UINT8  *pMacAddr,
361                              TI_UINT32 uKeySize,
362                              TI_UINT32 uKeyType,
363                              TI_UINT32 uKeyId,
364                              TI_UINT8  *pKey,
365                              TI_UINT32 uSecuritySeqNumLow,
366                              TI_UINT32 uSecuritySeqNumHigh,
367                              void      *fCb,
368                              TI_HANDLE hCb)
369{
370    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
371    SetKey_t AcxCmd_SetKey;
372    SetKey_t *pCmd = &AcxCmd_SetKey;
373
374    os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
375
376    MAC_COPY (pCmd->addr, pMacAddr);
377
378    if (uKeySize > MAX_KEY_SIZE)
379    {
380        os_memoryCopy (pCmdBld->hOs, (void *)pCmd->key, (void *)pKey, MAX_KEY_SIZE);
381    }
382    else
383    {
384        os_memoryCopy (pCmdBld->hOs, (void *)pCmd->key, (void *)pKey, uKeySize);
385    }
386
387    pCmd->action = ENDIAN_HANDLE_WORD((TI_UINT16)action);
388    pCmd->keySize = (TI_UINT8)uKeySize;
389    pCmd->type = (TI_UINT8)uKeyType;
390    pCmd->id = (TI_UINT8)uKeyId;
391    pCmd->ssidProfile = 0;
392
393    /*
394     * Preserve TKIP/AES security sequence number after recovery.
395     * Note that our STA Tx is currently using only one sequence-counter
396     * for all ACs (unlike the Rx which is separated per AC).
397     */
398    pCmd->AcSeqNum16[0] = ENDIAN_HANDLE_WORD((TI_UINT16)uSecuritySeqNumLow);
399    pCmd->AcSeqNum16[1] = 0;
400    pCmd->AcSeqNum16[2] = 0;
401    pCmd->AcSeqNum16[3] = 0;
402
403    pCmd->AcSeqNum32[0] = ENDIAN_HANDLE_LONG(uSecuritySeqNumHigh);
404    pCmd->AcSeqNum32[1] = 0;
405    pCmd->AcSeqNum32[2] = 0;
406    pCmd->AcSeqNum32[3] = 0;
407
408
409TRACE6(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "Addr: %02x:%02x:%02x:%02x:%02x:%02x\n", pCmd->addr[0],pCmd->addr[1],pCmd->addr[2],pCmd->addr[3],pCmd->addr[4],pCmd->addr[5]);
410
411TRACE7(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "Action=%x,keySize=0x%x,type=%x, id=%x, ssidProfile=%x, AcSeqNum16[0]=%x, AcSeqNum32[0]=%x\n", pCmd->action,pCmd->keySize, pCmd->type,pCmd->id,pCmd->ssidProfile,pCmd->AcSeqNum16[0],pCmd->AcSeqNum32[0] );
412
413	return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_SET_KEYS, (char *)pCmd, sizeof(*pCmd), fCb, hCb, NULL);
414}
415
416
417/****************************************************************************
418 *                      cmdBld_CmdIeStartScan ()
419 ****************************************************************************
420 * DESCRIPTION: Send SCAN Command
421 *
422 * INPUTS: None
423 *
424 * OUTPUT:  None
425 *
426 * RETURNS: TI_OK or TI_NOK
427 ****************************************************************************/
428TI_STATUS cmdBld_CmdIeStartScan (TI_HANDLE hCmdBld, ScanParameters_t* pScanParams, void *fScanResponseCb, TI_HANDLE hCb)
429{
430    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
431
432    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
433                             CMD_SCAN,
434                             (TI_CHAR *)pScanParams,
435                             sizeof(ScanParameters_t),
436                             fScanResponseCb,
437                             hCb,
438                             NULL);
439}
440
441/****************************************************************************
442 *                      cmdBld_CmdIeStartSPSScan ()
443 ****************************************************************************
444 * DESCRIPTION: Send SPS SCAN Command
445 *
446 * INPUTS: None
447 *
448 * OUTPUT:  None
449 *
450 * RETURNS: TI_OK or TI_NOK
451 ****************************************************************************/
452TI_STATUS cmdBld_CmdIeStartSPSScan (TI_HANDLE hCmdBld, ScheduledScanParameters_t* pScanParams, void* fScanResponseCb, TI_HANDLE hCb)
453{
454    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
455
456    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
457                             CMD_SPS_SCAN,
458                             (TI_CHAR *)pScanParams,
459                             sizeof(ScheduledScanParameters_t),
460                             fScanResponseCb,
461                             hCb,
462                             NULL);
463}
464
465
466/****************************************************************************
467 *                      cmdBld_CmdIeStopScan ()
468 ****************************************************************************
469 * DESCRIPTION: Construct the STOP_SCAN command fields and send it to the
470 *              mailbox
471 *
472 * INPUTS: None
473 *
474 * OUTPUT:  None
475 *
476 * RETURNS: TI_OK or TI_NOK
477 ****************************************************************************/
478TI_STATUS cmdBld_CmdIeStopScan (TI_HANDLE hCmdBld, void *fScanResponseCb, TI_HANDLE hCb)
479{
480    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
481
482    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CmdIeStopScan: -------------- \n");
483
484    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_STOP_SCAN, 0, 0, fScanResponseCb, hCb, NULL);
485}
486
487
488/****************************************************************************
489 *                      cmdBld_CmdIeStopSPSScan ()
490 ****************************************************************************
491 * DESCRIPTION: Construct the STOP_SPS_SCAN command fields and send it to the
492 *              mailbox
493 *
494 * INPUTS: None
495 *
496 * OUTPUT:  None
497 *
498 * RETURNS: TI_OK or TI_NOK
499 ****************************************************************************/
500TI_STATUS cmdBld_CmdIeStopSPSScan (TI_HANDLE hCmdBld, void* fScanResponseCB, TI_HANDLE hCb)
501{
502    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
503
504    TRACE0(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CmdIeStopSPSScan: -------------- \n");
505
506    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_STOP_SPS_SCAN, 0, 0, fScanResponseCB, hCb, NULL);
507}
508
509
510TI_STATUS cmdBld_CmdIeSetSplitScanTimeOut (TI_HANDLE hCmdBld, TI_UINT32 uTimeOut, void *fCB, TI_HANDLE hCb)
511{
512	TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
513	enhancedTriggerTO_t Cmd_enhancedTrigger;
514	enhancedTriggerTO_t *pCmd = &Cmd_enhancedTrigger;
515
516TRACE1(pCmdBld->hReport, REPORT_SEVERITY_INFORMATION, "cmdBld_CmdIeSetSplitScanTimeOut: uTimeOut=%d -------------- \n", uTimeOut);
517
518	pCmd->slicedScanTimeOut = uTimeOut;
519
520	return cmdQueue_SendCommand(pCmdBld->hCmdQueue, CMD_TRIGGER_SCAN_TO, (char *)pCmd, sizeof(*pCmd), fCB, hCb, NULL);
521}
522
523/**
524 * \fn     cmdBld_CmdIeScanSsidList
525 * \brief  Sets SSID list for periodic scan
526 *
527 * Sets SSID list for periodic scan
528 *
529 * \param  hCmdBld - handle to command builder object
530 * \param  pSsidList - command data
531 * \param  fScanResponseCB - command complete function callback
532 * \param  hCb - command complete callback handle
533 * \return TI_OK on success, any other code on error
534 * \sa     cmdBld_CmdIePeriodicScanParams, cmdBld_CmdIeStartPeriodicScan, cmdBld_CmdIeStopPeriodicScan
535 */
536TI_STATUS cmdBld_CmdIeScanSsidList (TI_HANDLE hCmdBld, ConnScanSSIDList_t *pSsidList,
537                                    void* fScanResponseCB, TI_HANDLE hCb)
538{
539    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
540
541    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
542                             CMD_CONNECTION_SCAN_SSID_CFG,
543                             (char *)pSsidList,
544                             sizeof(ConnScanSSIDList_t),
545                             fScanResponseCB,
546                             hCb,
547                             NULL);
548}
549
550/**
551 * \fn     cmdBld_CmdIePeriodicScanParams
552 * \brief  Sets periodic scan parameters
553 *
554 * Sets periodic scan parameters
555 *
556 * \param  hCmdBld - handle to command builder object
557 * \param  pPeriodicScanParams - command data
558 * \param  fScanResponseCB - command complete function callback
559 * \param  hCb - command complete callback handle
560 * \return TI_OK on success, any other code on error
561 * \sa     cmdBld_CmdIeScanSsidList, cmdBld_CmdIeStartPeriodicScan, cmdBld_CmdIeStopPeriodicScan
562 */
563TI_STATUS cmdBld_CmdIePeriodicScanParams (TI_HANDLE hCmdBld, ConnScanParameters_t *pPeriodicScanParams,
564                                          void* fScanResponseCB, TI_HANDLE hCb)
565{
566    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
567
568    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
569                             CMD_CONNECTION_SCAN_CFG,
570                             (char *)pPeriodicScanParams,
571                             sizeof(ConnScanParameters_t),
572                             fScanResponseCB,
573                             hCb,
574                             NULL);
575}
576
577/**
578 * \fn     cmdBld_CmdIeStartPeriodicScan
579 * \brief  Starts a periodic scan operation
580 *
581 * Starts a periodic scan operation
582 *
583 * \param  hCmdBld - handle to command builder object
584 * \param  pPeriodicScanStart - command data
585 * \param  fScanResponseCB - command complete function callback
586 * \param  hCb - command complete callback handle
587 * \return TI_OK on success, any other code on error
588 * \sa     cmdBld_CmdIeScanSsidList,  cmdBld_CmdIePeriodicScanParams, cmdBld_CmdIeStopPeriodicScan
589 */
590TI_STATUS cmdBld_CmdIeStartPeriodicScan (TI_HANDLE hCmdBld, PeriodicScanTag* pPeriodicScanStart,
591                                         void* fScanResponseCB, TI_HANDLE hCb)
592{
593    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
594
595    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
596                             CMD_START_PERIODIC_SCAN,
597                             pPeriodicScanStart, sizeof (PeriodicScanTag),
598                             fScanResponseCB,
599                             hCb,
600                             NULL);
601}
602
603/**
604 * \fn     cmdBld_CmdIeStopPeriodicScan
605 * \brief  Stops an on-going periodic scan operation
606 *
607 * Stops an on-going periodic scan operation
608 *
609 * \param  hCmdBld - handle to command builder object
610 * \param  fScanResponseCB - command complete function callback
611 * \param  hCb - command complete callback handle
612 * \return TI_OK on success, any other code on error
613 * \sa     cmdBld_CmdIeScanSsidList, cmdBld_CmdIePeriodicScanParams, cmdBld_CmdIeStartPeriodicScan
614 */
615TI_STATUS cmdBld_CmdIeStopPeriodicScan (TI_HANDLE hCmdBld,
616                                        PeriodicScanTag* pPeriodicScanStop,
617                                        void* fScanResponseCB,
618                                        TI_HANDLE hCb)
619{
620    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
621
622    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
623                             CMD_STOP_PERIODIC_SCAN,
624                             pPeriodicScanStop,
625                             sizeof(pPeriodicScanStop),
626                             fScanResponseCB,
627                             hCb,
628                             NULL);
629}
630
631/****************************************************************************
632 *                      cmdBld_CmdIeNoiseHistogram ()
633 ****************************************************************************
634 * DESCRIPTION: Send NOISE_HISTOGRAM Command
635 *
636 * INPUTS: None
637 *
638 * OUTPUT:  None
639 *
640 * RETURNS: TI_OK or TI_NOK
641 ****************************************************************************/
642TI_STATUS cmdBld_CmdIeNoiseHistogram (TI_HANDLE hCmdBld, TNoiseHistogram *pNoiseHistParams, void *fCb, TI_HANDLE hCb)
643{
644    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
645    NoiseHistRequest_t AcxCmd_NoiseHistogram;
646    NoiseHistRequest_t *pCmd = &AcxCmd_NoiseHistogram;
647
648    os_memoryZero(pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
649
650    pCmd->mode = ENDIAN_HANDLE_WORD((TI_UINT16)pNoiseHistParams->cmd);
651    pCmd->sampleIntervalUSec = ENDIAN_HANDLE_WORD(pNoiseHistParams->sampleInterval);
652
653    os_memoryCopy (pCmdBld->hOs, (void *)&(pCmd->thresholds[0]), (void *)&(pNoiseHistParams->ranges[0]), MEASUREMENT_NOISE_HISTOGRAM_NUM_OF_RANGES);
654
655    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_NOISE_HIST, (TI_CHAR *)pCmd, sizeof(*pCmd), fCb, hCb, NULL);
656}
657
658
659/****************************************************************************
660 *                      cmdBld_CmdIeSetPsMode()
661 ****************************************************************************
662 * DESCRIPTION: send Command for Power Management configuration
663 *              to the mailbox
664 *
665 * INPUTS: None
666 *
667 * OUTPUT:  None
668 *
669 * RETURNS: TI_OK or TI_NOK
670 ****************************************************************************/
671TI_STATUS cmdBld_CmdIeSetPsMode (TI_HANDLE hCmdBld, TPowerSaveParams* powerSaveParams, void *fCb, TI_HANDLE hCb)
672{
673    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
674    PSModeParameters_t   Cmd_PowerMgmtCnf;
675    PSModeParameters_t * pCmd = &Cmd_PowerMgmtCnf;
676
677    os_memoryZero(pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
678
679    if (powerSaveParams->ps802_11Enable)
680    {
681        pCmd->mode = 1;
682    }
683    else
684    {
685        pCmd->mode = 0;
686    }
687
688    pCmd->hangOverPeriod            = powerSaveParams->hangOverPeriod;
689    pCmd->needToSendNullData        = powerSaveParams->needToSendNullData;
690    pCmd->rateToTransmitNullData    = ENDIAN_HANDLE_LONG(powerSaveParams->NullPktRateModulation);
691    pCmd->numberOfRetries           = powerSaveParams->numNullPktRetries;
692
693  	return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_SET_PS_MODE, (TI_CHAR *)pCmd, sizeof(*pCmd), fCb, hCb, NULL);
694}
695
696
697/****************************************************************************
698 *                      cmdBld_CmdIeSwitchChannel ()
699 ****************************************************************************
700 * DESCRIPTION: Send CMD_SWITCH_CHANNEL Command
701 *
702 * INPUTS: None
703 *
704 * OUTPUT:  None
705 *
706 * RETURNS: TI_OK or TI_NOK
707 ****************************************************************************/
708TI_STATUS cmdBld_CmdIeSwitchChannel (TI_HANDLE hCmdBld, TSwitchChannelParams *pSwitchChannelCmd, void *fCb, TI_HANDLE hCb)
709{
710    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
711    ChannelSwitchParameters_t AcxCmd_SwitchChannel;
712    ChannelSwitchParameters_t *pCmd = &AcxCmd_SwitchChannel;
713
714    os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
715
716    pCmd->channel = pSwitchChannelCmd->channelNumber;
717    pCmd->switchTime = pSwitchChannelCmd->switchTime;
718    pCmd->txSuspend = pSwitchChannelCmd->txFlag;
719    pCmd->flush = pSwitchChannelCmd->flush;
720
721    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_CHANNEL_SWITCH, (TI_CHAR *)pCmd, sizeof(*pCmd), fCb, hCb, NULL);
722}
723
724
725/****************************************************************************
726 *                      cmdBld_CmdIeSwitchChannelCancel ()
727 ****************************************************************************
728 * DESCRIPTION: Send CMD_SWITCH_CHANNEL_CANCEL Command
729 *
730 * INPUTS: None
731 *
732 * OUTPUT:  None
733 *
734 * RETURNS: TI_OK or TI_NOK
735 ****************************************************************************/
736TI_STATUS cmdBld_CmdIeSwitchChannelCancel (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
737{
738    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
739
740    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_STOP_CHANNEL_SWICTH, 0, 0, fCb, hCb, NULL);
741}
742
743
744/****************************************************************************
745 *                      cmdBld_CmdIeFwDisconnect()
746 ****************************************************************************
747 * DESCRIPTION: Construct the Disconnect command fileds and send it to the mailbox
748 *
749 * INPUTS: None
750 *
751 * OUTPUT:  None
752 *
753 * RETURNS: TI_OK or TI_NOK
754 ****************************************************************************/
755TI_STATUS cmdBld_CmdIeFwDisconnect (TI_HANDLE hCmdBld, TI_UINT32 uConfigOptions, TI_UINT32 uFilterOptions, DisconnectType_e uDisconType, TI_UINT16 uDisconReason, void *fCb, TI_HANDLE hCb)
756{
757    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
758    DisconnectParameters_t AcxCmd_Disconnect;
759
760    AcxCmd_Disconnect.rxFilter.ConfigOptions = ENDIAN_HANDLE_LONG(uConfigOptions);
761    AcxCmd_Disconnect.rxFilter.FilterOptions = ENDIAN_HANDLE_LONG(uFilterOptions);
762    AcxCmd_Disconnect.disconnectReason = ENDIAN_HANDLE_LONG(uDisconReason);
763    AcxCmd_Disconnect.disconnectType = uDisconType;
764
765    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
766                             CMD_DISCONNECT,
767                             (void *)&AcxCmd_Disconnect,
768                             sizeof(AcxCmd_Disconnect),
769                             fCb,
770                             hCb,
771                             NULL);
772}
773
774
775/****************************************************************************
776 *                      cmdBld_CmdIeMeasurement()
777 ****************************************************************************
778 * DESCRIPTION: send Command for measurement configuration
779 *              to the mailbox
780 *
781 * INPUTS: None
782 *
783 * OUTPUT:  None
784 *
785 * RETURNS: TI_OK or TI_NOK
786 ****************************************************************************/
787TI_STATUS cmdBld_CmdIeMeasurement (TI_HANDLE          hCmdBld,
788                                   TMeasurementParams *pMeasurementParams,
789                                   void               *fMeasureResponseCb,
790                                   TI_HANDLE          hCb)
791{
792    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
793    MeasurementParameters_t Cmd_MeasurementParam;
794    MeasurementParameters_t *pCmd = &Cmd_MeasurementParam;
795
796    os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
797
798    pCmd->band =                    pMeasurementParams->band;
799    pCmd->channel =                 pMeasurementParams->channel;
800    pCmd->duration =                ENDIAN_HANDLE_LONG(pMeasurementParams->duration);
801    pCmd->rxFilter.ConfigOptions =  ENDIAN_HANDLE_LONG(pMeasurementParams->ConfigOptions);
802    pCmd->rxFilter.FilterOptions =  ENDIAN_HANDLE_LONG(pMeasurementParams->FilterOptions);
803    pCmd->scanTag =                 (TI_UINT8)pMeasurementParams->eTag;
804
805    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
806                             CMD_MEASUREMENT,
807                             (TI_CHAR *)pCmd,
808                             sizeof(*pCmd),
809                             fMeasureResponseCb,
810                             hCb,
811                             NULL);
812}
813
814
815/****************************************************************************
816 *                      cmdBld_CmdIeMeasurementStop()
817 ****************************************************************************
818 * DESCRIPTION: send Command for stoping measurement
819 *
820 * INPUTS: None
821 *
822 * OUTPUT:  None
823 *
824 * RETURNS: TI_OK or TI_NOK
825 ****************************************************************************/
826TI_STATUS cmdBld_CmdIeMeasurementStop (TI_HANDLE hCmdBld, void* fMeasureResponseCb, TI_HANDLE hCb)
827{
828    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
829
830    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
831                             CMD_STOP_MEASUREMENT,
832                             0,
833                             0,
834                             fMeasureResponseCb,
835                             hCb,
836                             NULL);
837}
838
839
840/****************************************************************************
841 *                      cmdBld_CmdIeApDiscovery()
842 ****************************************************************************
843 * DESCRIPTION: send Command for AP Discovery
844 *              to the mailbox
845 *
846 * INPUTS: None
847 *
848 * OUTPUT:  None
849 *
850 * RETURNS: TI_OK or TI_NOK
851 ****************************************************************************/
852TI_STATUS cmdBld_CmdIeApDiscovery (TI_HANDLE hCmdBld, TApDiscoveryParams *pApDiscoveryParams, void *fCb, TI_HANDLE hCb)
853{
854    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
855    ApDiscoveryParameters_t Cmd_ApDiscovery;
856    ApDiscoveryParameters_t *pCmd = &Cmd_ApDiscovery;
857
858    os_memoryZero (pCmdBld->hOs, (void *)pCmd, sizeof(*pCmd));
859
860    pCmd->txPowerAttenuation = pApDiscoveryParams->txPowerDbm;
861    pCmd->numOfProbRqst = pApDiscoveryParams->numOfProbRqst;
862    pCmd->scanDuration  =  ENDIAN_HANDLE_LONG(pApDiscoveryParams->scanDuration);
863    pCmd->scanOptions   =  ENDIAN_HANDLE_WORD(pApDiscoveryParams->scanOptions);
864    pCmd->txdRateSet    =  ENDIAN_HANDLE_LONG(pApDiscoveryParams->txdRateSet);
865    pCmd->rxFilter.ConfigOptions =  ENDIAN_HANDLE_LONG(pApDiscoveryParams->ConfigOptions);
866    pCmd->rxFilter.FilterOptions =  ENDIAN_HANDLE_LONG(pApDiscoveryParams->FilterOptions);
867
868	return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
869                             CMD_AP_DISCOVERY,
870                             (void *)pCmd,
871                             sizeof(*pCmd),
872                             fCb,
873                             hCb,
874                             NULL);
875}
876
877
878/****************************************************************************
879 *                      cmdBld_CmdIeApDiscoveryStop()
880 ****************************************************************************
881 * DESCRIPTION: send Command for stoping AP Discovery
882 *
883 * INPUTS: None
884 *
885 * OUTPUT:  None
886 *
887 * RETURNS: TI_OK or TI_NOK
888 ****************************************************************************/
889TI_STATUS cmdBld_CmdIeApDiscoveryStop (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
890{
891    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
892
893    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_STOP_AP_DISCOVERY, 0, 0, fCb, hCb, NULL);
894}
895
896
897/****************************************************************************
898 *                      cmdBld_CmdIeHealthCheck()
899 ****************************************************************************
900 * DESCRIPTION:
901 *
902 * INPUTS:
903 *
904 * OUTPUT:
905 *
906 * RETURNS:
907 ****************************************************************************/
908TI_STATUS cmdBld_CmdIeHealthCheck (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb)
909{
910    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
911
912    return cmdQueue_SendCommand (pCmdBld->hCmdQueue, CMD_HEALTH_CHECK, NULL, 0, fCb, hCb, NULL);
913}
914
915/****************************************************************************
916 *                      cmdBld_CmdIeSetStaState()
917 ****************************************************************************
918 * DESCRIPTION: Construct the Disconnect command fileds and send it to the mailbox
919 *
920 * INPUTS: None
921 *
922 * OUTPUT:  None
923 *
924 * RETURNS: TI_OK or TI_NOK
925 ****************************************************************************/
926TI_STATUS cmdBld_CmdIeSetStaState (TI_HANDLE hCmdBld, TI_UINT8 staState, void *fCb, TI_HANDLE hCb)
927{
928    TCmdBld *pCmdBld = (TCmdBld *)hCmdBld;
929    SetStaState_t AcxCmd_SetStaState;
930
931    AcxCmd_SetStaState.staState = staState;
932
933    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
934                             CMD_SET_STA_STATE,
935                             (void *)&AcxCmd_SetStaState,
936                             sizeof(AcxCmd_SetStaState),
937                             fCb,
938                             hCb,
939                             NULL);
940}
941
942/****************************************************************************
943 *                      cmdBld_BitIeTestCmd()
944 ****************************************************************************
945 * DESCRIPTION:
946 * INPUTS: None
947 *
948 * OUTPUT:  None
949 *
950 * RETURNS: TI_OK or TI_NOK
951 ****************************************************************************/
952TI_STATUS cmdBld_CmdIeTest (TI_HANDLE hCmdBld, void *fCb, TI_HANDLE hCb, TTestCmd* pTestCmd)
953{
954    TCmdBld		 *pCmdBld = (TI_HANDLE)hCmdBld;
955    TI_UINT32	 paramLength;
956    TI_BOOL      bIsCBfuncNecessary = TI_TRUE;
957
958    if (NULL == pTestCmd)
959    {
960         TRACE0(pCmdBld->hReport, REPORT_SEVERITY_ERROR, " pTestCmd_Buf = NULL!!!\n");
961		 return TI_NOK;
962    }
963
964	if ( (TestCmdID_enum)pTestCmd->testCmdId < MAX_TEST_CMD_ID )
965	{
966        bIsCBfuncNecessary = TI_TRUE;
967	}
968	else
969	{
970        TRACE1(pCmdBld->hReport, REPORT_SEVERITY_WARNING, " Unsupported testCmdId (%d)\n", pTestCmd->testCmdId);
971	}
972
973    if (bIsCBfuncNecessary && fCb == NULL)
974    {
975        return TI_OK;
976    }
977
978	switch( pTestCmd->testCmdId )
979	{
980		case TEST_CMD_PD_BUFFER_CAL:
981			paramLength = sizeof(TTestCmdPdBufferCal);
982			break;
983
984		case TEST_CMD_P2G_CAL:
985			paramLength = sizeof(TTestCmdP2GCal);
986			break;
987
988		case TEST_CMD_RX_STAT_GET:
989			paramLength = sizeof(RadioRxStatistics);
990			break;
991
992		/* packet */
993		case TEST_CMD_FCC:
994			paramLength = sizeof(TPacketParam);
995			break;
996
997		/* tone */
998		case TEST_CMD_TELEC:
999			paramLength = sizeof(TToneParam);
1000			break;
1001
1002		case TEST_CMD_PLT_TEMPLATE:
1003			paramLength = sizeof(TTxTemplate);
1004			break;
1005
1006		/* channel tune */
1007		case TEST_CMD_CHANNEL_TUNE:
1008			paramLength = sizeof(TTestCmdChannel);
1009			break;
1010
1011		case TEST_CMD_GET_FW_VERSIONS:
1012			paramLength = sizeof(TFWVerisons);
1013			break;
1014
1015        case TEST_CMD_INI_FILE_RADIO_PARAM:
1016            paramLength = sizeof(IniFileRadioParam);
1017            break;
1018
1019        case TEST_CMD_INI_FILE_GENERAL_PARAM:
1020            paramLength = sizeof(IniFileGeneralParam);
1021            break;
1022
1023		case TEST_CMD_PLT_GAIN_ADJUST:
1024			paramLength = sizeof(uint32);
1025			break;
1026
1027		case TEST_CMD_RUN_CALIBRATION_TYPE:
1028			paramLength = sizeof(TTestCmdRunCalibration);
1029			break;
1030
1031		case TEST_CMD_TX_GAIN_ADJUST:
1032			paramLength = sizeof(TTxGainAdjust);
1033			break;
1034        case TEST_CMD_TEST_TONE:
1035            paramLength = sizeof(TestToneParams_t);
1036            break;
1037
1038		case TEST_CMD_SET_EFUSE:
1039			paramLength = sizeof(EfuseParameters_t);
1040			break;
1041		case TEST_CMD_GET_EFUSE:
1042			paramLength = sizeof(EfuseParameters_t);
1043			break;
1044
1045		case TEST_CMD_RX_PLT_CAL:
1046			paramLength = sizeof(RadioRxPltCal);
1047			break;
1048
1049		case TEST_CMD_UPDATE_PD_REFERENCE_POINT:
1050			paramLength = sizeof(TTestCmdUpdateReferncePoint);
1051			break;
1052
1053		case TEST_CMD_UPDATE_PD_BUFFER_ERRORS:
1054			paramLength = sizeof(TTestCmdPdBufferErrors);
1055			break;
1056
1057		case TEST_CMD_POWER_MODE:
1058			paramLength = sizeof(TTestCmdPowerMode);
1059			break;
1060
1061		case TEST_CMD_STOP_TX:
1062		case TEST_CMD_RX_STAT_STOP:
1063		case TEST_CMD_RX_STAT_START:
1064		case TEST_CMD_RX_STAT_RESET:
1065		case TEST_CMD_RX_PLT_ENTER:
1066		case TEST_CMD_RX_PLT_EXIT:
1067			paramLength = 0;
1068			break;
1069
1070		default:
1071			paramLength = sizeof(pTestCmd->testCmd_u);
1072	}
1073
1074    return cmdQueue_SendCommand (pCmdBld->hCmdQueue,
1075                             CMD_TEST,
1076                             (void *)pTestCmd,
1077                             paramLength + RESEARVED_SIZE_FOR_RESPONSE,
1078                             fCb,
1079                             hCb,
1080                             (void*)pTestCmd);
1081}
1082