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: whalHwMboxCmdBit.c
39 * PURPOSE: wlan hardware BIT commands handler
40 *
41 ****************************************************************************/
42
43 #include "whalCommon.h"
44 #include "CmdQueue_api.h"
45 #include "public_infoele.h"
46 #include "commonTypes.h"
47 #include "whalHwMboxCmdBit.h"
48
49
50
51 /*******************************************
52 * Wlan hardware Test (BIT)
53 * =================
54 *
55 * Tests description:
56 * ==================
57 * FCC = Continuous modulated transmission (should not emit carrier)
58 * TELEC = Continuous unmodulated carrier transmission (carrier only)
59 * PER_TX_STOP = Stops the TX test in progress (FCC or TELEC).
60 * ReadRegister = Read a register value.
61 * WriteRegister = Sets a register value.
62 *
63 * Rx PER test
64 * ========
65 * PerRxStart = Start or resume the PER measurement. This function will put the device in promiscuous mode, and resume counters update.
66 * PerRxStop = Stop Rx PER measurements. This function stop counters update and make it is safe to read the PER test result.
67 * PerRxGetResults = Get the last Rx PER test results.
68 * PerRxClear = Clear the Rx PER test results.
69 */
70
71 enum
72 {
73 /* 0 */ TEST_MOD_QPSK,
74 /* 1 */ TEST_MOD_CCK,
75 /* 2 */ TEST_MOD_PBCC,
76
77 TEST_MOD_NUMOF
78 };
79
80 enum
81 {
82 /* 0 */ TEST_MOD_LONG_PREAMBLE,
83 /* 1 */ TEST_MOD_SHORT_PREAMBLE
84 };
85
86 enum
87 {
88 /* 0 */ TEST_BAND_2_4GHZ,
89 /* 1 */ TEST_BAND_5GHZ,
90 /* 2 */ TEST_BAND_4_9GHZ
91 };
92
93
94 #define TEST_MOD_MIN_GAP 200
95 #define TEST_MOD_MIN_TX_BODYLEN 0
96 #define TEST_MOD_MAX_TX_BODYLEN 2304
97
98 #define TEST_RX_CAL_SAFE_TIME 5000 /*uSec*/
99
100 #define TEST_MOD_IS_GAP_OK(gap) ((gap) >= TEST_MOD_MIN_GAP)
101
102 #define TEST_MOD_IS_TX_BODYLEN_OK(len) \
103 (INRANGE((len), TEST_MOD_MIN_TX_BODYLEN, TEST_MOD_MAX_TX_BODYLEN) && \
104 (((len) & 3) == 0) )
105
106 #define TEST_MOD_IS_PREAMBLE_OK(p) \
107 INRANGE((p), TEST_MOD_LONG_PREAMBLE, TEST_MOD_SHORT_PREAMBLE)
108
109
110 void whal_hwCmdBit_RxPer_Clear_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void *InterrogateParamsBuf);
111 void whal_hwCmdBit_RxPer_GetResults_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void *InterrogateParamsBuf);
112 void whal_hwCmdBit_RxCal_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void *InterrogateParamsBuf);
113 void whal_hwCmdBit_RxCal_Complete_Event_CB( TI_HANDLE objectHandle, char* str, UINT32 strLen );
114
115 /****************************************************************************
116 * whal_hwMboxCmdBit_Create()
117 ****************************************************************************
118 * DESCRIPTION: Create the mailbox BIT commands object
119 *
120 * INPUTS:
121 *
122 * OUTPUT: None
123 *
124 * RETURNS: The Created object
125 ****************************************************************************/
whal_hwMboxCmdBit_Create(TI_HANDLE hOs)126 HwMboxCmdBit_T *whal_hwMboxCmdBit_Create(TI_HANDLE hOs)
127 {
128 HwMboxCmdBit_T *pObj;
129
130 pObj = os_memoryAlloc(hOs, sizeof(HwMboxCmdBit_T));
131 if (pObj == NULL)
132 return NULL;
133
134 os_memoryZero(hOs, (void *)pObj, sizeof(HwMboxCmdBit_T));
135
136 pObj->hOs = hOs;
137
138 return(pObj);
139 }
140
141 /****************************************************************************
142 * whal_hwMboxCmdBit_Destroy()
143 ****************************************************************************
144 * DESCRIPTION: Destroy the object
145 *
146 * INPUTS:
147 * pHwMboxCmdBit The object to free
148 *
149 * OUTPUT: None
150 *
151 * RETURNS: OK or NOK
152 ****************************************************************************/
whal_hwMboxCmdBit_Destroy(HwMboxCmdBit_T * pHwMboxCmdBit)153 int whal_hwMboxCmdBit_Destroy(HwMboxCmdBit_T *pHwMboxCmdBit)
154 {
155 if (pHwMboxCmdBit)
156 {
157 whalCtrl_EventMbox_Disable( pHwMboxCmdBit->hWhalCtr, HAL_EVENT_PLT_RX_CALIBRATION_COMPLETE );
158 os_memoryFree(pHwMboxCmdBit->hOs, pHwMboxCmdBit, sizeof(HwMboxCmdBit_T));
159 }
160 return OK;
161 }
162
163 /****************************************************************************
164 * whal_hwMboxCmdBit_Config()
165 ****************************************************************************
166 * DESCRIPTION: Configure the object
167 *
168 * INPUTS:
169 *
170 * OUTPUT: None
171 *
172 * RETURNS: OK or NOK
173 ****************************************************************************/
whal_hwMboxCmdBit_Config(TI_HANDLE hWhalCtr,HwMboxCmdBit_T * pHwMboxCmdBit,TI_HANDLE hCmdQueue,TI_HANDLE hReport)174 int whal_hwMboxCmdBit_Config(TI_HANDLE hWhalCtr, HwMboxCmdBit_T *pHwMboxCmdBit, TI_HANDLE hCmdQueue, TI_HANDLE hReport)
175 {
176 pHwMboxCmdBit->hReport = hReport;
177 pHwMboxCmdBit->hCmdQueue = hCmdQueue;
178 pHwMboxCmdBit->hWhalCtr = hWhalCtr;
179
180 whalCtrl_EventMbox_RegisterForEvent( hWhalCtr,
181 HAL_EVENT_PLT_RX_CALIBRATION_COMPLETE,
182 (void *)whal_hwCmdBit_RxCal_Complete_Event_CB,
183 (void*)pHwMboxCmdBit);
184
185 whalCtrl_EventMbox_Enable( hWhalCtr, HAL_EVENT_PLT_RX_CALIBRATION_COMPLETE );
186
187 pHwMboxCmdBit->PltData.RxTxCal.lastStatus = OK;
188 return OK;
189 }
190
191 /*******************
192 Helper functions
193 *******************/
194
errPrint_ChID(HwMboxCmdBit_T * pHwMboxCmdBit,int chID)195 static void errPrint_ChID(HwMboxCmdBit_T *pHwMboxCmdBit, int chID)
196 {
197 WLAN_REPORT_REPLY(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
198 ("Channel ID (%d) is out of range, use [%d..%d] for 2.4Ghz, [%d..%d] for 5Ghz and [%d %d %d] for 4.9Ghz.\n",
199 chID,
200 HAL_CTRL_CALIBRATION_CHANNEL_2_4_MIN, HAL_CTRL_CALIBRATION_CHANNEL_2_4_MAX,
201 HAL_CTRL_CALIBRATION_CHANNEL_5_0_MIN, HAL_CTRL_CALIBRATION_CHANNEL_5_0_MAX,
202 HAL_CTRL_CALIBRATION_CHANNEL_4_9_MIN, HAL_CTRL_CALIBRATION_CHANNEL_4_9_DEF, HAL_CTRL_CALIBRATION_CHANNEL_4_9_MAX));
203 }
204
errPrint_BandID(HwMboxCmdBit_T * pHwMboxCmdBit,int bandID)205 static void errPrint_BandID(HwMboxCmdBit_T *pHwMboxCmdBit, int bandID)
206 {
207 WLAN_REPORT_REPLY(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
208 ("PLT whal_hwCmdBit_Fcc: Wrong band parameter 0x%x(must be 0x%x for 2.4Ghz or 0x%x for 5Ghz or 0x%x for 4.9Ghz).\n",
209 bandID, TEST_BAND_2_4GHZ, TEST_BAND_5GHZ, TEST_BAND_4_9GHZ));
210 }
211
212 /* MACROS */
VALIDATE_BAND_CHID(HwMboxCmdBit_T * pHwMboxCmdBit,int chID,int bandID)213 int VALIDATE_BAND_CHID(HwMboxCmdBit_T *pHwMboxCmdBit, int chID, int bandID)
214 {
215 int minVal, maxVal;
216 switch(bandID)
217 {
218 case TEST_BAND_2_4GHZ:
219 minVal = HAL_CTRL_CALIBRATION_CHANNEL_2_4_MIN;
220 maxVal = HAL_CTRL_CALIBRATION_CHANNEL_2_4_MAX;
221 break;
222
223 case TEST_BAND_5GHZ:
224 minVal = HAL_CTRL_CALIBRATION_CHANNEL_5_0_MIN;
225 maxVal = HAL_CTRL_CALIBRATION_CHANNEL_5_0_MAX;
226 break;
227
228 case TEST_BAND_4_9GHZ:
229 minVal = HAL_CTRL_CALIBRATION_CHANNEL_4_9_MIN;
230 maxVal = HAL_CTRL_CALIBRATION_CHANNEL_4_9_MAX;
231 break;
232
233 default:
234 errPrint_BandID(pHwMboxCmdBit, bandID);
235 return NOK;
236 }
237 if(!INRANGE(chID, minVal, maxVal))
238 {
239 errPrint_ChID(pHwMboxCmdBit, chID);
240 return NOK;
241 }
242 return(OK);
243 }
244
245 /****************************************************************************
246 * whal_hwCmdBit_Fcc()
247 ****************************************************************************
248 * DESCRIPTION: Performs FCC test
249 *
250 * INPUTS: chID, rate, Modulation, preamble, band, TestMode
251 *
252 * OUTPUT: None
253 *
254 * RETURNS: OK or NOK
255 ****************************************************************************/
whal_hwCmdBit_Fcc(HwMboxCmdBit_T * pHwMboxCmdBit,int chID,int rate,int preamble,int bandID,int InterPacketDelay,int TestMode,uint32 numFrames,uint32 seqNumMode,uint32 frameBodySize,uint8 * PeerMacAddr,void * CB_Func,TI_HANDLE CB_Handle,void * CB_Buf)256 int whal_hwCmdBit_Fcc(HwMboxCmdBit_T *pHwMboxCmdBit,
257 int chID,
258 int rate,
259 int preamble,
260 int bandID,
261 int InterPacketDelay,
262 int TestMode,
263 uint32 numFrames,
264 uint32 seqNumMode,
265 uint32 frameBodySize,
266 uint8 *PeerMacAddr,
267 void *CB_Func, TI_HANDLE CB_Handle, void *CB_Buf)
268 {
269 int Modulation;
270 TestCmd_t TestCmd;
271 os_memoryZero(pHwMboxCmdBit->hOs, (void *)&TestCmd, sizeof(TestCmd));
272
273 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
274 ("whal_hwCmdBit_Fcc:\n chID = %d\n rate = %d preamble = %d, bandID %d, InterPacketDelay %d, TestMode %d numOfFrames %d\n ",
275 chID, rate, preamble,
276 bandID, InterPacketDelay, TestMode, numFrames));
277
278 /*Check Channel and band*/
279 if (VALIDATE_BAND_CHID(pHwMboxCmdBit, chID, bandID) == NOK)
280 return NOK;
281
282 /*Check rate and set Modulation*/
283 if ((rate >= 1) && (rate <= 4))
284 Modulation = MOD_CCK;
285 else if ((rate >= 6) && (rate <= 13))
286 Modulation = MOD_OFDM;
287 else
288 {
289 WLAN_REPORT_REPLY(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
290 ("PLT whal_hwCmdBit_Fcc: Wrong rate parameter %d(must be 1-4 to CCK modulation or 6-13 for OFDM modulation) .\n",
291 rate));
292 return NOK;
293 }
294
295 /*Set FW rate */
296 TestCmd.testCmd_u.fcc.dataRate = ConvertDrvRate2HwRate((rate_e)rate);
297
298 /*Validate preamble*/
299 if ((preamble!=0) && preamble != CTL_PREAMBLE)
300 {
301 WLAN_REPORT_REPLY(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
302 ("PLT whal_hwCmdBit_Fcc: Wrong preamble parameter 0x%x(must be (0x%x) for long preamble or short(0x%x)) .\n",
303 preamble, 0, CTL_PREAMBLE));
304
305 return NOK;
306 }
307
308 /*Validate test mode*/
309 if ((TestMode != TEST_MODE_ZOZO_DATA) && (TestMode != TEST_MODE_RANDOM_DATA))
310 {
311 WLAN_REPORT_REPLY(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
312 ("PLT whal_hwCmdBit_Fcc: Wrong TestMode parameter 0x%x(must be RANDOM_DATA(0x%x) or ZOZO_DATA(0x%x)) .\n",
313 TestMode, TEST_MODE_RANDOM_DATA, TEST_MODE_ZOZO_DATA));
314 /*Not returning NOX for enabling GAP bit*/
315 }
316
317 /*Validate seq num mode*/
318 if ((seqNumMode != TEST_SEQ_NUM_MODE_FIXED) && (seqNumMode != TEST_SEQ_NUM_MODE_INCREMENTED))
319 {
320 WLAN_REPORT_REPLY(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
321 ("PLT whal_hwCmdBit_Fcc: Wrong seqNumMode parameter 0x%x(must be TEST_SEQ_NUM_MODE_FIXED(0x%x) or TEST_SEQ_NUM_MODE_INCREMENTED(0x%x)) .\n",
322 seqNumMode, TEST_SEQ_NUM_MODE_FIXED, TEST_SEQ_NUM_MODE_INCREMENTED));
323
324 return NOK;
325 }
326
327 TestCmd.testCmd_u.fcc.seqNumMode = seqNumMode;
328 TestCmd.testCmd_u.fcc.frameBodySize = frameBodySize;
329 os_memoryCopy(pHwMboxCmdBit->hOs , TestCmd.testCmd_u.fcc.dest, PeerMacAddr,NUM_OF_MAC_ADDR_ELEMENTS);
330
331 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
332 ("whal_hwCmdBit_Fcc: \n seqNumMode = %d ,frameBodySize = 0x%x",
333 TestCmd.testCmd_u.fcc.seqNumMode,
334 TestCmd.testCmd_u.fcc.frameBodySize));
335
336 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
337 ("whal_hwCmdBit_Fcc: \n Dest = %02x:%02x:%02x:%02x:%02x:%02x",
338 TestCmd.testCmd_u.fcc.dest[0],
339 TestCmd.testCmd_u.fcc.dest[1],
340 TestCmd.testCmd_u.fcc.dest[2],
341 TestCmd.testCmd_u.fcc.dest[3],
342 TestCmd.testCmd_u.fcc.dest[4],
343 TestCmd.testCmd_u.fcc.dest[5]));
344
345 TestCmd.testCmd_u.fcc.channel = chID;
346
347 switch (Modulation)
348 {
349 case MOD_PBCC:
350 Modulation = PBCC_MODULATION_MASK;
351 break;
352
353 case MOD_CCK:
354 Modulation = 0x00;
355 break;
356
357 case MOD_OFDM:
358 Modulation = OFDM_MODULATION_MASK;
359 break;
360 }
361 /*Build preamble parameter*/
362 TestCmd.testCmd_u.fcc.modPreamble = preamble;
363 TestCmd.testCmd_u.fcc.band = bandID;
364 TestCmd.testCmd_u.fcc.modulation = Modulation;
365
366 TestCmd.testCmd_u.fcc.testModeCtrl = TestMode;
367
368 /* Set command fields */
369 TestCmd.testCmdId = TEST_CMD_FCC;
370
371 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
372 ("whal_hwCmdBit_Fcc: \n AcxCmd_TestFCC.channel = %d ,AcxCmd_TestFCC.dataRate = 0x%x, AcxCmd_TestFCC.modPreamble = 0x%x, AcxCmd_TestFCC.testModeCtrl = 0x%x\n ",
373 TestCmd.testCmd_u.fcc.channel,
374 TestCmd.testCmd_u.fcc.dataRate,
375 TestCmd.testCmd_u.fcc.modPreamble,
376 TestCmd.testCmd_u.fcc.testModeCtrl));
377
378
379 /*Set InterPacketDelay*/
380 /*TestCmd.testCmd_u.fcc.interFrameGap = 1000 * InterPacketDelay; */ /*Convert ms to us*/
381 TestCmd.testCmd_u.fcc.interFrameGap = InterPacketDelay; /*(uSec)*/
382
383 /*Set numFrames */
384 TestCmd.testCmd_u.fcc.numFrames = numFrames;
385
386 return whal_hwCmdBit_TestCmd(pHwMboxCmdBit, CB_Func, CB_Handle, &TestCmd);
387 }/* END whal_hwCmdBit_Fcc() */
388
389
390
391 /****************************************************************************
392 * whal_hwCmdBit_Telec()
393 ****************************************************************************
394 * DESCRIPTION: Performs TELEC test
395 *
396 * INPUTS: chID - Channel number, between 1 (MIN_CHANNEL_ID) to 14 (MAX_CHANNEL_ID).
397 * bandID - Band ID number, 0 - 2.4Ghz, 1 - 5Ghz.
398 *
399 * OUTPUT: None
400 *
401 * RETURNS: OK or NOK
402 ****************************************************************************/
whal_hwCmdBit_Telec(HwMboxCmdBit_T * pHwMboxCmdBit,int chID,int bandID,void * CB_Func,TI_HANDLE CB_Handle,void * CB_Buf)403 int whal_hwCmdBit_Telec(HwMboxCmdBit_T *pHwMboxCmdBit, int chID, int bandID, void *CB_Func, TI_HANDLE CB_Handle, void *CB_Buf)
404 {
405 TestCmd_t TestCmd;
406 TestCmd_t *pCmd = &TestCmd;
407 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
408 ("whal_hwCmdBit_Telec: chID = %d bandID = %d\n ", chID, bandID));
409
410
411 /*Check Channel and band*/
412 if (VALIDATE_BAND_CHID(pHwMboxCmdBit, chID, bandID) == NOK)
413 return NOK;
414
415 /* Set command fields; param1 = chID, param2 = BandID */
416 os_memoryZero(pHwMboxCmdBit->hOs, (void *)pCmd, sizeof(*pCmd ));
417 pCmd->testCmdId = TEST_CMD_TELEC;
418 pCmd->testCmd_u.telec.channel = (UINT8)chID;
419 pCmd->testCmd_u.telec.band = (UINT8)bandID;
420
421 /* Send the command */
422 return whal_hwCmdBit_TestCmd(pHwMboxCmdBit, CB_Func, CB_Handle, &TestCmd);
423 }/* END whal_hwCmdBit_Telec() */
424
425 /**************************
426 REGISTER HANDLING
427 *************************/
428
429 /****************************************************************************
430 * whal_hwCmdBit_ReadRegister()
431 ****************************************************************************
432 * DESCRIPTION: Performs PLT read register
433 *
434 * INPUTS: RegAddress - the address of the register to read
435 *
436 * OUTPUT: None
437 *
438 * RETURNS: OK or NOK
439 ****************************************************************************/
whal_hwCmdBit_ReadRegister(HwMboxCmdBit_T * pHwMboxCmdBit,TI_HANDLE CB_Handle,void * CB_Func,void * CB_Buf)440 int whal_hwCmdBit_ReadRegister(HwMboxCmdBit_T *pHwMboxCmdBit, TI_HANDLE CB_Handle, void *CB_Func, void *CB_Buf)
441 {
442 ReadWriteCommand_t* pCmd = CB_Buf;
443
444 /* Send the command */
445 return (CmdQueue_CommandWithCb(pHwMboxCmdBit->hCmdQueue, CMD_READ_MEMORY, (char *)pCmd, sizeof(*pCmd), CB_Func, CB_Handle, CB_Buf));
446 }/* END whal_hwCmdBit_ReadRegister() */
447
448
449 /****************************************************************************
450 * whal_hwCmdBit_WriteRegister()
451 ****************************************************************************
452 * DESCRIPTION: Performs PLT write register
453 *
454 * INPUTS: RegAddress - the address of the register to write to
455 * RegData - the data to write
456 *
457 * OUTPUT: None
458 *
459 * RETURNS: OK or NOK
460 ****************************************************************************/
whal_hwCmdBit_WriteRegister(HwMboxCmdBit_T * pHwMboxCmdBit,TI_HANDLE CB_Handle,void * CB_Func,void * Command_Buf)461 int whal_hwCmdBit_WriteRegister(HwMboxCmdBit_T *pHwMboxCmdBit, TI_HANDLE CB_Handle, void *CB_Func, void *Command_Buf)
462 {
463
464
465 /* Send the command */
466 if (CB_Func)
467 return (CmdQueue_CommandWithCb(pHwMboxCmdBit->hCmdQueue, CMD_WRITE_MEMORY, (char *)Command_Buf, sizeof(ReadWriteCommand_t), CB_Func, CB_Handle, NULL));
468 else
469 return (CmdQueue_Command(pHwMboxCmdBit->hCmdQueue, CMD_WRITE_MEMORY, (char *)Command_Buf, sizeof(ReadWriteCommand_t)));
470 }/* END whal_hwCmdBit_WriteRegister() */
471
472
473 /****************************************************************************
474 * whal_hwCmdBit_perTxStop()
475 ****************************************************************************
476 * DESCRIPTION: Packet Error Rate - stop test, no params.
477 * Does not clear statistics.
478 * INPUTS: None
479 *
480 * OUTPUT: None
481 *
482 * RETURNS: OK or NOK
483 ****************************************************************************/
whal_hwCmdBit_perTxStop(HwMboxCmdBit_T * pHwMboxCmdBit,void * CB_Func,TI_HANDLE CB_Handle,void * CB_Buf)484 int whal_hwCmdBit_perTxStop(HwMboxCmdBit_T *pHwMboxCmdBit, void *CB_Func, TI_HANDLE CB_Handle, void *CB_Buf)
485 {
486 TestCmd_t TestCmd;
487 TestCmd_t *pCmd = &TestCmd;
488
489 /* Set command fields*/
490 os_memoryZero(pHwMboxCmdBit->hOs, (void *)pCmd, sizeof(*pCmd ));
491 pCmd->testCmdId = TEST_CMD_PLT_FCC_TELEC_TX_STOP;
492
493 /* Send the command */
494 return whal_hwCmdBit_TestCmd(pHwMboxCmdBit, CB_Func, CB_Handle, pCmd);
495 }/* END whal_hwCmdBit_perTxStop() */
496
497
498
499
500 /****************************************************************************
501 * whal_hwCmdBit_RxPER()
502 ****************************************************************************
503 * DESCRIPTION: RX PER main function - All other RX per function are called using this function
504 * INPUTS: None
505 *
506 * OUTPUT: None
507 *
508 * RETURNS: OK or NOK
509 ****************************************************************************/
510
whal_hwCmdBit_RxPER(HwMboxCmdBit_T * pHwMboxCmdBit,PLT_RxPerCmd_e eRxPerCmd,TI_HANDLE CB_Handle,void * CB_Func)511 int whal_hwCmdBit_RxPER(HwMboxCmdBit_T *pHwMboxCmdBit, PLT_RxPerCmd_e eRxPerCmd, TI_HANDLE CB_Handle, void *CB_Func)
512 {
513 int ret = OK;
514 ACXErrorCounters_t ACXErrorCounters;
515 TestCmd_t TestCmd;
516 TestCmd_t *pCmd = &TestCmd;
517
518
519
520 /*Defining a local function that will support the Rx PER process
521 in a sync mode (for the core) as well as Async mode (for GWSI, as callbacks)*/
522
523 CmdQueue_InterrogateCB_t PltRxPerCBArr[PLT_RX_PER_MAX] =
524 {
525 NULL, //PLT_RX_PER_START
526 NULL, //PLT_RX_PER_STOP
527 whal_hwCmdBit_RxPer_Clear_CB, //PLT_RX_PER_CLEAR
528 whal_hwCmdBit_RxPer_GetResults_CB //PLT_RX_PER_GETRESULTS
529 };
530
531 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
532 ("whal_hwCmdBit_RxPER eRxPerCmd=%d, CB_Handle=0x%p, CB_Func=0x%p\n", eRxPerCmd, CB_Handle, CB_Func));
533
534
535 /*
536 * Set information element header
537 * Each call to ACX_ERROR_CNT - retrieve the F.W Rx Per and reset them.
538 */
539 ACXErrorCounters.EleHdr.id = ACX_ERROR_CNT;
540 ACXErrorCounters.EleHdr.len = sizeof(ACXErrorCounters) - sizeof(EleHdrStruct);
541
542 if ((UINT32)eRxPerCmd >= (UINT32)PLT_RX_PER_MAX)
543 return PARAM_VALUE_NOT_VALID;
544
545 pHwMboxCmdBit->PltData.RxPer.CB_Func = CB_Func;
546 pHwMboxCmdBit->PltData.RxPer.CB_Handle = CB_Handle;
547 pHwMboxCmdBit->PltData.RxPer.CB_RxPerCmd = eRxPerCmd;
548
549 /*
550 * Send the interrogation command
551 */
552 if((PLT_RX_PER_GETRESULTS == eRxPerCmd) || (PLT_RX_PER_CLEAR == eRxPerCmd))
553 {
554 ret = CmdQueue_CmdInterrogateWithCb(pHwMboxCmdBit->hCmdQueue,
555 &ACXErrorCounters, sizeof(ACXErrorCounters),
556 (void *) PltRxPerCBArr[eRxPerCmd], pHwMboxCmdBit,
557 &pHwMboxCmdBit->PltData.RxPer.ACXErrCountTable);
558 return ret;
559 }
560
561 /* Set command fields*/
562 os_memoryZero(pHwMboxCmdBit->hOs, (void *)pCmd, sizeof(*pCmd ));
563
564 if(PLT_RX_PER_START == eRxPerCmd)
565 {
566 pCmd->testCmdId = TEST_CMD_RX_PER_START;
567 /* Send the command */
568 if (CB_Func != NULL) {
569 return (CmdQueue_CommandWithCb(pHwMboxCmdBit->hCmdQueue, CMD_TEST, (char *)pCmd, sizeof(*pCmd),CB_Func , CB_Handle, NULL));
570 }
571 else
572 {
573 return (CmdQueue_Command(pHwMboxCmdBit->hCmdQueue, CMD_TEST, (char *)pCmd, sizeof(*pCmd) ));
574 }
575 }
576
577 if(PLT_RX_PER_STOP == eRxPerCmd)
578 {
579 pCmd->testCmdId = TEST_CMD_RX_PER_STOP;
580 /* Send the command */
581 if (CB_Func != NULL) {
582 return (CmdQueue_CommandWithCb(pHwMboxCmdBit->hCmdQueue, CMD_TEST, (char *)pCmd, sizeof(*pCmd),CB_Func, CB_Handle, NULL));
583 }
584 else
585 {
586 return (CmdQueue_Command(pHwMboxCmdBit->hCmdQueue, CMD_TEST, (char *)pCmd, sizeof(*pCmd) ));
587 }
588 }
589
590 return NOK;
591 }
592
593 /****************************************************************************
594 * whal_hwCmdBit_RxPer_Clear_CB()
595 ****************************************************************************
596 * DESCRIPTION: Clear the RX per counters
597 *.
598 * INPUTS: None
599 *
600 * OUTPUT: None
601 *
602 * RETURNS: OK or NOK
603 ****************************************************************************/
whal_hwCmdBit_RxPer_Clear_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void * InterrogateParamsBuf)604 void whal_hwCmdBit_RxPer_Clear_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void *InterrogateParamsBuf)
605 {
606 HwMboxCmdBit_T *pHwMboxCmdBit = (HwMboxCmdBit_T*)objectHandle;
607 CmdQueue_InterrogateCB_t CB_Func;
608
609 /*Add the latest F.W. counter result to the total RX per counters*/
610 pHwMboxCmdBit->PltData.RxPer.PltRxPer.FCSErrorCount = 0;
611 pHwMboxCmdBit->PltData.RxPer.PltRxPer.TotalFrameCount = 0;
612 pHwMboxCmdBit->PltData.RxPer.PltRxPer.PLCPErrorCount = 0;
613 pHwMboxCmdBit->PltData.RxPer.PltRxPer.SeqNumMissCountRef = pHwMboxCmdBit->PltData.RxPer.ACXErrCountTable.seqNumMissCount; /* set as reference point for the mesurements */
614
615
616 /* Call the saved CB function (if any)*/
617 if (pHwMboxCmdBit->PltData.RxPer.CB_Func)
618 {
619 CB_Func = (CmdQueue_InterrogateCB_t)(pHwMboxCmdBit->PltData.RxPer.CB_Func);
620 CB_Func(pHwMboxCmdBit->PltData.RxPer.CB_Handle, MboxStatus, &pHwMboxCmdBit->PltData.RxPer);
621 }
622 }
623
624
625 /****************************************************************************
626 * whal_hwCmdBit_RxPer_GetResults_CB()
627 ****************************************************************************
628 * DESCRIPTION: Returns the accumulated counters.
629 * INPUTS: None
630 *
631 * OUTPUT: None
632 *
633 * RETURNS: OK or NOK
634 ****************************************************************************/
whal_hwCmdBit_RxPer_GetResults_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void * InterrogateParamsBuf)635 void whal_hwCmdBit_RxPer_GetResults_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void *InterrogateParamsBuf)
636 {
637 HwMboxCmdBit_T *pHwMboxCmdBit = (HwMboxCmdBit_T*)objectHandle;
638 CmdQueue_InterrogateCB_t CB_Func;
639
640
641 /*Accumulate the RX PER counters */
642 pHwMboxCmdBit->PltData.RxPer.PltRxPer.FCSErrorCount += (UINT16)pHwMboxCmdBit->PltData.RxPer.ACXErrCountTable.FCSErrorCount;
643 pHwMboxCmdBit->PltData.RxPer.PltRxPer.PLCPErrorCount += (UINT16)pHwMboxCmdBit->PltData.RxPer.ACXErrCountTable.PLCPErrorCount;
644 pHwMboxCmdBit->PltData.RxPer.PltRxPer.TotalFrameCount += (UINT16)pHwMboxCmdBit->PltData.RxPer.ACXErrCountTable.validFrameCount;
645 pHwMboxCmdBit->PltData.RxPer.PltRxPer.SeqNumMissCount = (UINT16)(pHwMboxCmdBit->PltData.RxPer.ACXErrCountTable.seqNumMissCount -
646 pHwMboxCmdBit->PltData.RxPer.PltRxPer.SeqNumMissCountRef);
647
648
649 /* Call the saved CB function (if any)*/
650 if (pHwMboxCmdBit->PltData.RxPer.CB_Func)
651 {
652 CB_Func = (CmdQueue_InterrogateCB_t)(pHwMboxCmdBit->PltData.RxPer.CB_Func);
653 CB_Func(pHwMboxCmdBit->PltData.RxPer.CB_Handle, MboxStatus, &(pHwMboxCmdBit->PltData.RxPer));
654 }
655 }
656
657
658
659 /****************************************************************************
660 * whal_hwCmdBit_TestCmd()
661 ****************************************************************************
662 * DESCRIPTION:
663 * INPUTS: None
664 *
665 * OUTPUT: None
666 *
667 * RETURNS: OK or NOK
668 ****************************************************************************/
whal_hwCmdBit_TestCmd(HwMboxCmdBit_T * pHwMboxCmdBit,void * CB_Func,TI_HANDLE CB_Handle,TestCmd_t * pTestCmd_Buf)669 int whal_hwCmdBit_TestCmd(HwMboxCmdBit_T *pHwMboxCmdBit, void *CB_Func, TI_HANDLE CB_Handle, TestCmd_t* pTestCmd_Buf)
670 {
671 int bIsCBfuncNecessary=TRUE;
672
673 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
674 ("%s CB_Handle=0x%p, CB_Func=0x%p, pTestCmd_Buf=%p\n",__FUNCTION__, CB_Handle, CB_Func, pTestCmd_Buf));
675
676 if (NULL == pTestCmd_Buf)
677 {
678 WLAN_REPORT_ERROR(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
679 ("%s pTestCmd_Buf = NULL!!!\n",__FUNCTION__));
680
681 return NOK;
682 }
683
684 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
685 ("%s pTestCmd_Buf->testCmdId=%d\n",__FUNCTION__, pTestCmd_Buf->testCmdId));
686
687 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
688 ("%s pTestCmd_Buf (HEX DUMP):\n",__FUNCTION__));
689 WLAN_REPORT_HEX_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
690 (PUINT8)pTestCmd_Buf, sizeof(TestCmd_t));
691
692
693 switch((TestCmdID_enum)pTestCmd_Buf->testCmdId)
694 {
695 case TEST_CMD_FCC:
696 case TEST_CMD_TELEC:
697 case TEST_CMD_PLT_FCC_TELEC_TX_STOP:
698 case TEST_CMD_RADIO_TUNE:
699 bIsCBfuncNecessary = FALSE;
700 break;
701
702 case TEST_CMD_PLT_GAIN_ADJUST:
703 case TEST_CMD_PLT_TXPOWER_CAL_START:
704 case TEST_CMD_PLT_TXPOWER_CAL_STOP:
705 case TEST_CMD_PLT_GAIN_GET:
706 case TEST_CMD_PLT_GET_NVS_UPDATE_BUFFER:
707 bIsCBfuncNecessary = TRUE;
708 break;
709
710 case TEST_CMD_PLT_RX_CALIBRATION:
711 /* Mark that a calibration operation is pending */
712 pHwMboxCmdBit->PltData.RxTxCal.lastStatus = PENDING;
713 /* Save the CB for the command response (GWSI oriented) */
714 pHwMboxCmdBit->PltData.RxTxCal.CB_Func = CB_Func;
715 pHwMboxCmdBit->PltData.RxTxCal.CB_Handle = CB_Handle;
716
717 CB_Func = (void*)whal_hwCmdBit_RxCal_CB;
718 CB_Handle = (TI_HANDLE)pHwMboxCmdBit;
719 bIsCBfuncNecessary = TRUE;
720 break;
721
722 default:
723 WLAN_REPORT_WARNING(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
724 ("%s Unsupported TestCmdId (%d)\n",__FUNCTION__, pTestCmd_Buf->testCmdId));
725 break;
726 }
727
728 /* Send the command */
729 if (CB_Func)
730 {
731 return (CmdQueue_CommandWithCb(pHwMboxCmdBit->hCmdQueue, CMD_TEST, (char *)pTestCmd_Buf, sizeof(*pTestCmd_Buf),
732 CB_Func, CB_Handle, (void*)pTestCmd_Buf));
733 }
734 else
735 {
736 if (bIsCBfuncNecessary)
737 return NOK;
738 else
739 return (CmdQueue_Command(pHwMboxCmdBit->hCmdQueue, CMD_TEST, (char *)pTestCmd_Buf, sizeof(*pTestCmd_Buf) ));
740 }
741
742 }/* END whal_hwCmdBit_TestCmd() */
743
744
745 /****************************************************************************
746 * whal_hwCmdBit_RxCal_CB()
747 ****************************************************************************
748 * DESCRIPTION: Returns the accumulated counters.
749 * INPUTS: None
750 *
751 * OUTPUT: None
752 *
753 * RETURNS: OK or NOK
754 ****************************************************************************/
whal_hwCmdBit_RxCal_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void * InterrogateParamsBuf)755 void whal_hwCmdBit_RxCal_CB(TI_HANDLE objectHandle,UINT16 MboxStatus,void *InterrogateParamsBuf)
756 {
757 HwMboxCmdBit_T *pHwMboxCmdBit = (HwMboxCmdBit_T*)objectHandle;
758 CmdQueue_InterrogateCB_t CB_Func;
759
760 WLAN_REPORT_INFORMATION(pHwMboxCmdBit->hReport, HAL_HW_CTRL_MODULE_LOG,
761 ("%s MboxStatus = 0x%x\n",
762 __FUNCTION__, MboxStatus));
763
764 /* If there was an error in the RX Calibration command, mark the NOK status here rather than
765 from the RX calibration complete event callback function (the event won't be sent)*/
766 if (OK != MboxStatus)
767 {
768 pHwMboxCmdBit->PltData.RxTxCal.lastStatus = NOK;
769 }
770
771 /* Call the saved CB function (if any)*/
772 if (pHwMboxCmdBit->PltData.RxTxCal.CB_Func)
773 {
774 CB_Func = (CmdQueue_InterrogateCB_t)(pHwMboxCmdBit->PltData.RxTxCal.CB_Func);
775 CB_Func(pHwMboxCmdBit->PltData.RxTxCal.CB_Handle, MboxStatus, &pHwMboxCmdBit->PltData.RxTxCal);
776 }
777
778 }
779
780
781 /****************************************************************************
782 * whal_hwCmdBit_RxCal_Complete_Event_CB()
783 ****************************************************************************
784 * DESCRIPTION: Returns the accumulated counters.
785 * INPUTS: None
786 *
787 * OUTPUT: None
788 *
789 * RETURNS: OK or NOK
790 ****************************************************************************/
whal_hwCmdBit_RxCal_Complete_Event_CB(TI_HANDLE objectHandle,char * str,UINT32 strLen)791 void whal_hwCmdBit_RxCal_Complete_Event_CB( TI_HANDLE objectHandle, char* str, UINT32 strLen )
792 {
793 HwMboxCmdBit_T *pHwMboxCmdBit = (HwMboxCmdBit_T*)objectHandle;
794
795 /* mark the status as completed */
796 pHwMboxCmdBit->PltData.RxTxCal.lastStatus = OK;
797 }
798
799 /****************************************************************************
800 * whal_hwCmdBit_GetPltRxCalibrationStatus()
801 ****************************************************************************
802 * DESCRIPTION: Returns whether the last RX calibration is pending.
803 * INPUTS: None
804 *
805 * OUTPUT: None
806 *
807 * RETURNS: None
808 ****************************************************************************/
whal_hwCmdBit_GetPltRxCalibrationStatus(TI_HANDLE objectHandle,TI_STATUS * pLastStatus)809 void whal_hwCmdBit_GetPltRxCalibrationStatus( TI_HANDLE objectHandle, TI_STATUS* pLastStatus )
810 {
811 HwMboxCmdBit_T *pHwMboxCmdBit = (HwMboxCmdBit_T*)objectHandle;
812
813 /* return the status of the last RX calibration */
814 *pLastStatus = pHwMboxCmdBit->PltData.RxTxCal.lastStatus;
815 }
816