1 /*
2 * Copyright (c) Texas Instruments Incorporated 2021
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 *
8 * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 *
11 * Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the
14 * distribution.
15 *
16 * Neither the name of Texas Instruments Incorporated nor the names of
17 * its contributors may be used to endorse or promote products derived
18 * from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
33 /* ========================================================================== */
34 /* Include Files */
35 /* ========================================================================== */
37 /* Standard Include Files. */
38 #include <stdint.h>
39 #include <stdlib.h>
40 #include <stddef.h>
41 #include <string.h>
42 #include <stdio.h>
44 /* BIOS/XDC Include Files. */
45 #include <ti/osal/TaskP.h>
46 #include <ti/osal/DebugP.h>
47 #include <ti/osal/SemaphoreP.h>
49 /* ADCBUF Driver: */
50 #include <ti/drv/adcbuf/adcbuf.h>
51 #include <ti/drv/edma/edma.h>
52 #include <ti/csl/soc.h>
53 #include <ti/osal/osal.h>
55 /* ========================================================================== */
56 /* Macros */
57 /* ========================================================================== */
58 static uint8_t gAppTskStackMain[4 * 1024] __attribute__((aligned(32)));
60 /* Test definition specific to the device */
61 #define TOTAL_TEST_CASES (4U)
62 #define TEST_ADCBUF_NUM_SAMPLES (1024U)
63 #define TEST_ADCBUF_DMADATA_BASE_ADDRESS (CSL_DSS_L3_U_BASE + 0x8000U)
65 #if defined(_TMS320C6X)
66 #define RSS_ADC_CAPTURE_COMPLETE_IRQ (57U)
67 #else
68 #define RSS_ADC_CAPTURE_COMPLETE_IRQ (142U)
69 #endif
71 #define OSAL_DEFAULT_PRIORITY (~((uint32_t) 0U))
74 /* ========================================================================== */
75 /* Structures */
76 /* ========================================================================== */
77 typedef struct ADCBUFTestParams_t
78 {
79 /* Number of ADC samples */
80 uint32_t numSamples;
82 /* Device specific ADCBUF memory address */
83 uint32_t ADCBUFMemAddr;
85 /* Memory address to store ADC samples */
86 uint32_t dstMemAddr;
88 /* Chirp Interrupt Number */
89 uint32_t chirpIntNumber;
91 /* Enable Edma for copy data */
92 uint8_t enableEdma;
93 }ADCBUFTestParams;
95 /* ========================================================================== */
96 /* Global Variables */
97 /* ========================================================================== */
99 /* Device specific test parameters */
100 ADCBUFTestParams gADCBUFTestParam =
101 {
102 TEST_ADCBUF_NUM_SAMPLES,
103 CSL_RSS_ADCBUF_READ_U_BASE,
104 TEST_ADCBUF_DMADATA_BASE_ADDRESS,
105 #if defined(_TMS320C6X)
106 RSS_ADC_CAPTURE_COMPLETE_IRQ,
107 #else
108 RSS_ADC_CAPTURE_COMPLETE_IRQ,
109 #endif
110 0
111 };
113 /* Test cases with different data format */
114 ADCBuf_dataFormat dataFmtTestCase_awr2944[TOTAL_TEST_CASES]=
115 {
116 /* Complex, Q+I, non-interleaved */
117 {0, 0, 0},
119 /* Complex, I+Q, non-interleaved */
120 {0, 1, 0},
122 /* Real, I, non-interleaved */
123 {1, 0, 0},
125 /* Real, Q, non-interleaved */
126 {1, 1, 0},
127 };
129 /* Test Control variables */
130 volatile uint32_t gTestRun = 1U;
131 SemaphoreP_Handle gIntSemaHandle = NULL;
133 /* Test statistics */
134 volatile uint32_t gIntCounter = 0U;
135 volatile uint32_t gVerifyFailCount = 0U;
137 /* ========================================================================== */
138 /* Internal Function Declarations */
139 /* ========================================================================== */
140 static int32_t Test_ADCBUFApiTest(void);
141 static int32_t Test_ADCBUFCmdParamsCheckTest(void);
142 static EDMA_Handle Test_ADCBUFInitEDMA(void);
143 static void Test_edmaErrorCallbackFxn(EDMA_Handle handle, EDMA_errorInfo_t *errorInfo);
144 static void Test_edmaTransferControllerErrorCallbackFxn(EDMA_Handle handle,
145 EDMA_transferControllerErrorInfo_t *errorInfo);
146 static void Test_ADCBUFIntCallBackFunc(uintptr_t arg);
147 static void Test_ADCBUFContDataPathWithTestPattern(ADCBuf_Handle handle, ADCBuf_dataFormat *ptrDataFormat);
148 static void Test_ADCBUFContModeConfig(ADCBuf_Handle handle, ADCBuf_dataFormat *ptrDataFormat);
149 static int32_t Test_ADCBUFConfigEdma(EDMA_Handle handle, uint8_t chId, uint32_t* pSrcAddress, uint32_t * pDestAddress,
150 uint16_t aCount, uint16_t bCount, uint16_t cCount,uint16_t linkChId);
151 static int32_t Test_ADCBUFEDMA_setup_shadow_link (EDMA_Handle handle, uint32_t chId, uint32_t linkChId,
152 EDMA_paramSetConfig_t *config,
153 EDMA_transferCompletionCallbackFxn_t transferCompletionCallbackFxn);
154 static uint32_t Test_ADCBUFVerifyDataPattern(void *memAddr, ADCBuf_dataFormat *ptrDataFormat);
155 static void Test_ADCBUFCloseEDMA(EDMA_Handle handle);
157 /* ========================================================================== */
158 /* Function Definitions */
159 /* ========================================================================== */
160 /**
161 * @b Description
162 * @n
163 * Call back function for EDMA CC (Channel controller) error as per EDMA API.
164 * Declare fatal error if happens, the output errorInfo can be examined if code
165 * gets trapped here.
166 */
167 void Test_edmaErrorCallbackFxn(EDMA_Handle handle, EDMA_errorInfo_t *errorInfo)
168 {
169 DebugP_assert(0);
170 }
172 /**
173 * @b Description
174 * @n
175 * Call back function for EDMA transfer controller error as per EDMA API.
176 * Declare fatal error if happens, the output errorInfo can be examined if code
177 * gets trapped here.
178 */
179 void Test_edmaTransferControllerErrorCallbackFxn(EDMA_Handle handle,
180 EDMA_transferControllerErrorInfo_t *errorInfo)
181 {
182 DebugP_assert(0);
183 }
185 /**
186 * @b Description
187 * @n
188 * Interrupt handler callback for chirp available. It runs in the ISR context.
189 *
190 * @param[in] handle
191 * ADCBUF Instance Handle
192 *
193 * @retval
194 * Not Applicable.
195 */
196 void Test_ADCBUFIntCallBackFunc(uintptr_t arg)
197 {
198 ADCBuf_Handle handle;
200 handle = (ADCBuf_Handle)arg;
202 /* Increment interrupt counter for debugging purpose */
203 gIntCounter++;
205 /* Check the buffer every 10 chirp avail interrupt */
206 if(gIntCounter % 10 == 0)
207 {
208 /* Stop Continuous mode */
209 ADCBuf_control(handle, ADCBufMMWave_CMD_STOP_CONTINUOUS_MODE, NULL);
211 /* Stop Test Pattern generation */
212 ADCBuf_control(handle, ADCBufMMWave_CMD_STOP_TEST_PATTERN, NULL);
214 /* Semaphore post for test thread to copy samples and verify */
215 SemaphoreP_post(gIntSemaHandle);
216 }
217 }
219 /**
220 * @b Description
221 * @n
222 * Continuous mode with Test pattern generation test.
223 *
224 * @param[in] handle
225 * ADCBUF Instance Handle
226 * @param[in] ptrDataFormat
227 * Pointer to the ADCBuf Data format configuration
228 *
229 * @retval
230 * Not Applicable.
231 */
232 void Test_ADCBUFContDataPathWithTestPattern(ADCBuf_Handle handle, ADCBuf_dataFormat *ptrDataFormat)
233 {
234 int32_t retVal = 0;
236 /* Configure test pattern */
237 Test_ADCBUFContModeConfig(handle, ptrDataFormat);
239 /* Start Test Pattern generation */
240 if ((retVal = ADCBuf_control(handle, ADCBufMMWave_CMD_START_TEST_PATTERN, NULL) ) < 0)
241 printf("Error: ADCBufMMWave_CMD_START_TEST_PATTERN failed with [Error=%d]\n", retVal);
242 }
244 /**
245 * @b Description
246 * @n
247 * Continuous mode with Test patern generation test.
248 *
249 * @param[in] handle
250 * ADCBUF Instance Handle
251 * @param[in] ptrDataFormat
252 * Pointer to the ADCBuf Data format configuration
253 *
254 * @retval
255 * Not Applicable.
256 */
257 void Test_ADCBUFContModeConfig(ADCBuf_Handle handle, ADCBuf_dataFormat *ptrDataFormat)
258 {
259 uint32_t arg;
260 ADCBuf_RxChanConf rxChanConf;
261 ADCBuf_TestPatternConf testPatternConf;
262 uint8_t channel;
263 uint16_t offset = 0;
264 uint32_t numSamples;
265 int32_t retVal = 0;
267 /* Configure ADC buffer data format */
268 if ((retVal = ADCBuf_control(handle, ADCBufMMWave_CMD_CONF_DATA_FORMAT, (void *)ptrDataFormat)) < 0)
269 printf("Error: ADCBufMMWave_CMD_CONF_DATA_FORMAT failed with [Error=%d]\n", retVal);
271 /* Enable all 4 Rx Channel */
272 for (channel=0; channel < NUM_RX_CHANNEL; channel++)
273 {
274 rxChanConf.channel = channel;
275 rxChanConf.offset = offset;
276 if((retVal = ADCBuf_control(handle, ADCBufMMWave_CMD_CHANNEL_ENABLE, (void *)&rxChanConf)) < 0)
277 printf("Error: ADCBufMMWave_CMD_CHANNEL_ENABLE failed for channel %d offset =0x%x with [Error = %d]\n",
278 channel, offset, retVal);
279 /* Test purpose only : Verify channel address */
280 {
281 uint32_t channelAddr = 0;
283 if ( (channelAddr = ADCBuf_getChanBufAddr(handle, channel, &retVal)) != 0)
284 {
285 channelAddr -= gADCBUFTestParam.ADCBUFMemAddr;
287 if(channelAddr != offset)
288 {
289 printf("Error: ADCBuf_getChanBufAddr() return mismatched channel(%d) buffer address [%x: %x]\n",
290 channel, offset, channelAddr);
292 retVal = -1;
293 }
294 }
295 else
296 {
297 printf("Error: ADCBuf_getChanBufAddr failed for channel %d with [Error = %d]\n",
298 channel, retVal);
299 }
300 }
302 offset += gADCBUFTestParam.numSamples * 4;
303 }
305 /* Configure ADC buffer in continuous mode */
306 arg = 1;
307 if ((retVal = ADCBuf_control(handle, ADCBufMMWave_CMD_SET_CONTINUOUS_MODE, (void *)&arg)) < 0)
308 printf("Error: ADCBufMMWave_CMD_SET_CONTINUOUS_MODE failed with [Error=%d]\n", retVal);
310 /* Start the continuous streaming mode in ADCBUFF */
311 numSamples = gADCBUFTestParam.numSamples;
312 if ((retVal = ADCBuf_control(handle, ADCBufMMWave_CMD_START_CONTINUOUS_MODE, (void *)&numSamples)) < 0)
313 printf("Error: ADCBufMMWave_CMD_START_CONTINUOUS_MODE failed with [Error=%d]\n", retVal);
315 /* Configure Test Pattern generation */
316 testPatternConf.period = 255;
317 testPatternConf.numSamples = gADCBUFTestParam.numSamples;
319 for (channel=0; channel < 4; channel++)
320 {
321 testPatternConf.rxConfig[channel].rxIOffset = 0x0000;
322 testPatternConf.rxConfig[channel].rxIInc = 2;
323 testPatternConf.rxConfig[channel].rxQOffset = 0x1000 ;
324 testPatternConf.rxConfig[channel].rxQInc = 2;
325 }
327 /* Send control command to driver */
328 if ( (retVal = ADCBuf_control(handle, ADCBufMMWave_CMD_CONF_TEST_PATTERN, (void *)&testPatternConf)) < 0)
329 printf("Error: ADCBufMMWave_CMD_CONF_TEST_PATTERN failed with [Error=%d]\n", retVal);
331 }
333 /**
334 * @b Description
335 * @n
336 * Config EDMA channel for data buffer copy.
337 *
338 * @param[in] handle
339 * EDMA driver instance Handle
340 * @param[in] chId
341 * EDMA Channle id used to copy data buffer
342 * @param[in] pSrcAddress
343 * Source address
344 * @param[in] pDestAddress
345 * Destination address
346 * @param[in] aCount
347 * EDMA channel Acount configuration
348 * @param[in] bCount
349 * EDMA channel Bcount configuration
350 * @param[in] cCount
351 * EDMA channel Ccount configuration
352 * @param[in] linkChId
353 * EDMA link Id
354 *
355 * @retval
356 * Success - 0
357 * Fail < 0 (ErrorCode)
358 */
359 int32_t Test_ADCBUFConfigEdma(EDMA_Handle handle, uint8_t chId,
360 uint32_t* pSrcAddress, uint32_t * pDestAddress,
361 uint16_t aCount, uint16_t bCount, uint16_t cCount,
362 uint16_t linkChId)
363 {
364 EDMA_channelConfig_t config;
365 int32_t errorCode = EDMA_NO_ERROR;
367 config.channelId = chId;
368 config.channelType = (uint8_t)EDMA3_CHANNEL_TYPE_DMA;
369 config.paramId = chId;
370 config.eventQueueId = 0;
372 config.paramSetConfig.sourceAddress = (uint32_t) pSrcAddress;
373 config.paramSetConfig.destinationAddress = (uint32_t) pDestAddress;
375 config.paramSetConfig.aCount = aCount;
376 config.paramSetConfig.bCount = bCount;
377 config.paramSetConfig.cCount = cCount;
378 config.paramSetConfig.bCountReload = config.paramSetConfig.bCount;
380 config.paramSetConfig.sourceBindex = 0;
381 config.paramSetConfig.destinationBindex = 0;
383 config.paramSetConfig.sourceCindex = 0;
384 config.paramSetConfig.destinationCindex = 0;
386 config.paramSetConfig.linkAddress = EDMA_NULL_LINK_ADDRESS;
387 config.paramSetConfig.transferType = (uint8_t)EDMA3_SYNC_A;
388 config.paramSetConfig.transferCompletionCode = 0;
389 config.paramSetConfig.sourceAddressingMode = (uint8_t) EDMA3_ADDRESSING_MODE_LINEAR;
390 config.paramSetConfig.destinationAddressingMode = (uint8_t) EDMA3_ADDRESSING_MODE_LINEAR;
392 /* don't care because of linear addressing modes above */
393 config.paramSetConfig.fifoWidth = (uint8_t) EDMA3_FIFO_WIDTH_8BIT;
395 config.paramSetConfig.isStaticSet = false;
396 config.paramSetConfig.isEarlyCompletion = false;
397 config.paramSetConfig.isFinalTransferInterruptEnabled = true;
398 config.paramSetConfig.isIntermediateTransferInterruptEnabled = false;
399 config.paramSetConfig.isFinalChainingEnabled = false;
400 config.paramSetConfig.isIntermediateChainingEnabled = false;
401 config.transferCompletionCallbackFxn = NULL;
403 if ((errorCode = EDMA_configChannel(handle, &config, false)) != EDMA_NO_ERROR)
404 {
405 printf("Error: EDMA_configChannel() failed with error code = %d\n", errorCode);
406 goto Exit;
407 }
409 errorCode = Test_ADCBUFEDMA_setup_shadow_link(handle, chId, linkChId,
410 &config.paramSetConfig, config.transferCompletionCallbackFxn);
412 Exit:
413 return(errorCode);
414 }
416 /**
417 * @b Description
418 * @n
419 * Setup shadow link for EDMA copy.
420 *
421 * @param[in] handle
422 * EDMA driver instance Handle
423 * @param[in] chId
424 * EDMA Channle id used to copy data buffer
425 * @param[in] linkChId
426 * EDMA link id used to copy data buffer
427 * @param[in] config
428 * EDMA param set used to copy data buffer
429 * @param[in] transferCompletionCallbackFxn
430 * Callback function when data copy is completed
431 *
432 * @retval
433 * Success - 0
434 * Fail < 0 (ErrorCode)
435 */
436 static int32_t Test_ADCBUFEDMA_setup_shadow_link (EDMA_Handle handle, uint32_t chId, uint32_t linkChId,
437 EDMA_paramSetConfig_t *config, EDMA_transferCompletionCallbackFxn_t transferCompletionCallbackFxn)
438 {
439 EDMA_paramConfig_t paramConfig;
440 int32_t errorCode = EDMA_NO_ERROR;
442 paramConfig.paramSetConfig = *config;
443 paramConfig.transferCompletionCallbackFxn = transferCompletionCallbackFxn;
444 paramConfig.transferCompletionCallbackFxnArg = (uintptr_t) handle;
445 if ((errorCode = EDMA_configParamSet(handle, linkChId, ¶mConfig)) != EDMA_NO_ERROR)
446 {
447 printf("Error: EDMA_configParamSet() failed with error code = %d\n", errorCode);
448 goto exit;
449 }
451 if ((errorCode = EDMA_linkParamSets(handle, chId, linkChId)) != EDMA_NO_ERROR)
452 {
453 printf("Error: EDMA_linkParamSets() failed with error code = %d\n", errorCode);
454 goto exit;
455 }
457 if ((errorCode = EDMA_linkParamSets(handle, linkChId, linkChId)) != EDMA_NO_ERROR)
458 {
459 printf("Error: EDMA_linkParamSets() failed with error code = %d\n", errorCode);
460 goto exit;
461 }
464 exit:
465 return(errorCode);
466 }
468 /**
469 * @b Description
470 * @n
471 * Verify the test data pattern .
472 *
473 * @param[in] memAddr
474 * Memory base address that holds the data copied from ADC buffer
475 * @param[in] ptrDataFormat
476 * Pointer to the ADCBuf Data format configuration
477 *
478 * @retval
479 * Not Applicable.
480 */
481 uint32_t Test_ADCBUFVerifyDataPattern(void *memAddr, ADCBuf_dataFormat *ptrDataFormat)
482 {
483 volatile uint32_t* ptrDataAddress;
484 uint8_t channel;
485 uint32_t sampleIdx;
486 volatile uint32_t addrOffset;
487 uint32_t data, firstSample;
488 uint16_t idata, qdata;
489 uint32_t incr = 2;
490 uint32_t failFlag = 0;
491 uint32_t dataIncr;
492 uint32_t numSamples;
494 ptrDataAddress = (volatile uint32_t *)memAddr;
495 printf("Debug: First 4 32 bit words 0x%x 0x%x 0x%x 0x%x\n", ptrDataAddress[0],
496 ptrDataAddress[1], ptrDataAddress[2], ptrDataAddress[3]);
498 /* Set the address offset */
499 addrOffset = 0;
501 /* Get number of samples from test params */
502 numSamples = gADCBUFTestParam.numSamples;
504 /* Get the first sample */
505 firstSample = *ptrDataAddress;
507 /* Channel interleaved-mode */
508 if (ptrDataFormat->channelInterleave == 0)
509 {
510 /* Test 10 samples for all channels */
511 for (sampleIdx=0; sampleIdx < numSamples; sampleIdx++)
512 {
513 for (channel = 0; channel < 4; channel++)
514 {
515 addrOffset = sampleIdx * 4;
516 if(ptrDataFormat->adcOutFormat == 0)
517 {
518 data = ptrDataAddress[addrOffset + channel];
520 /* Complex data format, get I and Q data */
521 if(ptrDataFormat->sampleInterleave == 0)
522 {
523 qdata = (data & 0xffff0000) >> 16;
524 idata = (data & 0xffff);
525 }
526 else
527 {
528 idata = (data & 0xffff0000) >> 16;
529 qdata = (data & 0xffff);
530 }
532 /* Verify data 1: increment = 2, */
533 dataIncr =( ( sampleIdx * incr)<<16) + (incr * sampleIdx);
534 if((data - firstSample) != dataIncr)
535 {
536 failFlag = 1;
537 }
539 /* Verify data 2: Q = I + 0x1000 */
540 if( (idata + 0x1000) != qdata)
541 {
542 failFlag = 1;
543 }
544 }
545 else
546 {
547 uint16_t *ptrRealData = (uint16_t *)ptrDataAddress;
548 uint16_t realData;
549 uint16_t firstRealSample;
551 /* Address offset in terms of 16bits real data */
552 addrOffset = sampleIdx * 4;
553 realData = ptrRealData[addrOffset + channel];
554 firstRealSample = ptrRealData[channel];
556 /* Verify data 1: increment = 2, */
557 dataIncr =incr * sampleIdx;
558 if((realData - firstRealSample) != dataIncr)
559 {
560 failFlag = 1;
561 }
562 }
563 }
564 }
566 }
567 else
568 {
569 for (channel = 0; channel < 4; channel++)
570 {
571 addrOffset = (channel * numSamples) ;
572 firstSample = ptrDataAddress[addrOffset];
574 for (sampleIdx=0; sampleIdx<numSamples; sampleIdx++)
575 {
576 data = ptrDataAddress[addrOffset + sampleIdx];
578 if(ptrDataFormat->adcOutFormat == 0)
579 {
580 /* Complex data format, get I and Q data */
581 if(ptrDataFormat->sampleInterleave == 0)
582 {
583 qdata = (data & 0xffff0000) >> 16;
584 idata = (data & 0xffff);
585 }
586 else
587 {
588 idata = (data & 0xffff0000) >> 16;
589 qdata = (data & 0xffff);
590 }
592 /* Verify data 1: increment = 2, */
593 dataIncr =( ( sampleIdx * incr)<<16) + (incr * sampleIdx);
594 if((data - firstSample) != dataIncr)
595 {
596 failFlag = 1;
597 }
599 /* Verify data 2: Q = I + 0x1000 */
600 if( (idata + 0x1000) != qdata)
601 {
602 failFlag = 1;
603 }
604 }
605 else
606 {
607 volatile uint16_t *ptrRealData = (uint16_t *)ptrDataAddress;
608 uint16_t realData;
609 uint16_t firstRealSample;
611 /* Address offset in terms of 16bits real data */
612 addrOffset = (channel * numSamples * 2) ;
613 realData = ptrRealData[addrOffset + sampleIdx];
614 firstRealSample = ptrRealData[addrOffset];
616 /* Verify data 1: increment = 2, */
617 dataIncr =incr * sampleIdx;
618 if((realData - firstRealSample) != dataIncr)
619 {
620 failFlag = 1;
621 }
622 }
623 }
625 }
626 }
627 return ((failFlag == 0) ? 0 : 1);
628 }
630 /**
631 * @b Description
632 * @n
633 * Close EDMA driver instance
634 *
635 * @param[in] handle
636 * EDMA driver instance Handle
637 *
638 * @retval
639 * Not applicable
640 */
641 void Test_ADCBUFCloseEDMA(EDMA_Handle handle)
642 {
643 int32_t retVal = 0;
645 if ((retVal = EDMA_close(handle)) != EDMA_NO_ERROR)
646 {
647 printf("Debug: edma Instance %p closing error, errorCode = %d\n", handle, retVal);
648 }
649 }
652 /**
653 * @b Description
654 * @n
655 * ADCBuf driver API test.
656 *
657 * @retval
658 * =0 Test passed
659 * <0 Test Failed
660 */
661 static int32_t Test_ADCBUFApiTest(void)
662 {
663 ADCBuf_Params params;
664 ADCBuf_Handle handle;
665 int32_t retVal = 0;
667 /* Setup the default ADCBUF Parameters */
668 ADCBuf_Params_init(¶ms);
670 /* Open the first ADCBUF Instance */
671 handle = ADCBuf_open(0, ¶ms);
672 if (handle == NULL)
673 {
674 printf("Error: Unable to open the ADCBUF Instance\n");
675 retVal = -1;
676 goto Exit;
677 }
678 printf("Debug: ADCBUF Instance(0) %p has been opened successfully\n", handle);
680 /**************************************************************************
681 * Test: Graceful shutdown
682 **************************************************************************/
683 ADCBuf_close(handle);
684 printf("Debug: ADCBUF Instance %p has been closed successfully\n", handle);
686 Exit:
687 return retVal;
688 }
690 /**
691 * @b Description
692 * @n
693 * ADCBuf driver test to validate command parameters.
694 *
695 * @retval
696 * =0 Test passed
697 * <0 Test Failed
698 */
699 static int32_t Test_ADCBUFCmdParamsCheckTest(void)
700 {
701 ADCBuf_Params params;
702 ADCBuf_Handle handle;
703 uint32_t arg;
704 int32_t retVal = 0;
705 ADCBufMMWave_CMD command;
706 ADCBuf_dataFormat dataFormat;
707 ADCBuf_RxChanConf rxChanConf;
708 ADCBuf_CQConf cqConf;
709 int32_t testResult = 0;
711 /* Setup the default ADCBUF Parameters */
712 ADCBuf_Params_init(¶ms);
714 /* Open the first ADCBUF Instance */
715 handle = ADCBuf_open(0, ¶ms);
716 if (handle == NULL)
717 {
718 printf("Error: Unable to open the ADCBUF Instance\n");
719 testResult = -1;
720 goto Exit;
721 }
722 printf("Debug: ADCBUF Instance(0) %p has been opened successfully\n", handle);
724 /* Params check Test */
725 command = ADCBufMMWave_CMD_SET_SRC;
726 arg = 0x5;
727 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
728 printf("Debug: Passed the param check for command=%d with arg=%d\n", command, arg);
729 else
730 {
731 printf("Error: Failed the param check for command=%d with arg=%d\n", command, arg);
732 testResult = -1;
733 }
735 command = ADCBufMMWave_CMD_SET_CONTINUOUS_MODE;
736 arg = 0x8;
737 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
738 printf("Debug: Passed the param check for command=%d with arg=%d\n", command, arg);
739 else
740 {
741 printf("Error: Failed the param check for command=%d with arg=%d\n", command, arg);
742 testResult = -1;
743 }
745 command = ADCBufMMWave_CMD_CONF_DATA_FORMAT;
746 memset ((void *)&dataFormat, 0, sizeof(dataFormat));
747 dataFormat.adcOutFormat = 2;
748 if ((retVal = ADCBuf_control(handle, command, (void *)&dataFormat)) < 0)
749 printf("Debug: Passed the param check for command=%d with adcOutFormat=%d \n", command, dataFormat.adcOutFormat);
750 else
751 {
752 printf("Error: Failed the param check for command=%d with adcOutFormat=%d\n", command, dataFormat.adcOutFormat);
753 testResult = -1;
754 }
756 memset ((void *)&dataFormat, 0, sizeof(dataFormat));
757 dataFormat.sampleInterleave = 2;
758 if ((retVal = ADCBuf_control(handle, command, (void *)&dataFormat)) < 0)
759 printf("Debug: Passed the param check for command=%d with sampleInterleave=%d\n", command, dataFormat.sampleInterleave);
760 else
761 {
762 printf("Error: Failed the param check for command=%d with sampleInterleave=%d\n", command, dataFormat.sampleInterleave);
763 testResult = -1;
764 }
766 memset ((void *)&dataFormat, 0, sizeof(dataFormat));
767 dataFormat.channelInterleave = 2;
768 if ((retVal = ADCBuf_control(handle, command, (void *)&dataFormat)) < 0)
769 printf("Debug: Passed the param check for command=%d channelInterleave=%d\n", command, dataFormat.channelInterleave);
770 else
771 {
772 printf("Error: Failed the param check for command=%d with channelInterleave=%d\n", command, dataFormat.channelInterleave);
773 testResult = -1;
774 }
776 command = ADCBufMMWave_CMD_CONF_CQ;
777 memset ((void *)&cqConf, 0, sizeof(cqConf));
778 cqConf.cqDataWidth= 5;
779 if ((retVal = ADCBuf_control(handle, command, (void *)&cqConf)) < 0)
780 printf("Debug: Passed the param check for command=%d with cqDataWidth=%d \n", command, cqConf.cqDataWidth);
781 else
782 {
783 printf("Error: Failed the param check for command=%d with cqDataWidth=%d\n", command, cqConf.cqDataWidth);
784 testResult = -1;
785 }
787 command = ADCBufMMWave_CMD_CONF_CQ;
788 memset ((void *)&cqConf, 0, sizeof(cqConf));
789 cqConf.cq96BitPackEn = 4;
790 if ((retVal = ADCBuf_control(handle, command, (void *)&cqConf)) < 0)
791 printf("Debug: Passed the param check for command=%d with cq96BitPackEn=%d \n", command, cqConf.cqDataWidth);
792 else
793 {
794 printf("Error: Failed the param check for command=%d with cq96BitPackEn=%d\n", command, cqConf.cq96BitPackEn);
795 testResult = -1;
796 }
798 command = ADCBufMMWave_CMD_START_CONTINUOUS_MODE;
799 arg = 0x1U<<16;
800 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
801 printf("Debug: Passed the param check for command=%d \n", command);
802 else
803 {
804 printf("Error: Failed the param check for command=%d with arg=%d\n", command, arg);
805 testResult = -1;
806 }
808 command = ADCBufMMWave_CMD_CHANNEL_ENABLE;
809 memset ((void *)&rxChanConf, 0, sizeof(rxChanConf));
810 rxChanConf.channel = 6;
811 if ((retVal = ADCBuf_control(handle, command, (void *)&rxChanConf)) < 0)
812 printf("Debug: Passed the param check for command=%d with channel = %d\n", command, rxChanConf.channel);
813 else
814 {
815 printf("Error: Failed the param check for command=%d with channel=%d\n", command, rxChanConf.channel);
816 testResult = -1;
817 }
819 memset ((void *)&rxChanConf, 0, sizeof(rxChanConf));
820 rxChanConf.channel = 2;
821 rxChanConf.offset = 0x1U << 15U;
822 if ((retVal = ADCBuf_control(handle, command, (void *)&rxChanConf)) < 0)
823 printf("Debug: Passed the param check for command=%d with offset = %d\n", command, rxChanConf.offset);
824 else
825 {
826 printf("Error: Failed the param check for command=%d with offset=%d\n", command, rxChanConf.offset);
827 testResult = -1;
828 }
830 command = ADCBufMMWave_CMD_SET_CHIRP_THRESHHOLD;
831 arg = 35;
832 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
833 printf("Debug: Passed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
834 else
835 {
836 printf("Error: Failed the param check for command=%d with arg = %d , retVal=%d\n", command, arg, retVal);
837 testResult = -1;
838 }
840 command = ADCBufMMWave_CMD_SET_PING_CHIRP_THRESHHOLD;
841 arg = 35;
842 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
843 printf("Debug: Passed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
844 else
845 {
846 printf("Error: Failed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
847 testResult = -1;
848 }
850 command = ADCBufMMWave_CMD_SET_PONG_CHIRP_THRESHHOLD;
851 arg = 35;
852 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
853 printf("Debug: Passed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
854 else
855 {
856 printf("Error: Failed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
857 testResult = -1;
858 }
860 command = ADCBufMMWave_CMD_CHANNEL_DISABLE;
861 arg = 0xc;
862 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
863 {
864 printf("Error: Failed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
865 testResult = -1;
866 }
867 else
868 {
869 printf("Debug: Passed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
870 }
872 command = ADCBufMMWave_CMD_CHANNEL_DISABLE;
873 arg = 0x1c;
874 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
875 printf("Debug: Passed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
876 else
877 {
878 printf("Error: Failed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
879 testResult = -1;
880 }
882 command = ADCBufMMWave_CMD_CHANNEL_DISABLE;
883 arg = 0x0;
884 if ((retVal = ADCBuf_control(handle, command, (void *)&arg)) < 0)
885 printf("Debug: Passed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
886 else
887 {
888 printf("Error: Failed the param check for command=%d with arg = %d, retVal=%d\n", command, arg, retVal);
889 testResult = -1;
890 }
892 /* Close ADCbuf driver */
893 ADCBuf_close(handle);
894 printf("Debug: ADCBUF Instance %p has been closed successfully\n", handle);
896 Exit:
897 return testResult;
898 }
900 /**
901 * @b Description
902 * @n
903 * Init EDMA driver for data buffer copy.
904 *
905 * @retval
906 * Success - EDMA handle
907 * Fail - NULL pointer
908 */
909 EDMA_Handle Test_ADCBUFInitEDMA(void)
910 {
911 EDMA_errorInfo_t EDMAErrorInfo;
912 EDMA_transferControllerErrorInfo_t EDMATransferControllerErrorInfo;
913 EDMA_Handle EdmaHandle = NULL;
914 EDMA_instanceInfo_t instanceInfo;
915 EDMA_errorConfig_t errorConfig;
917 /*******************/
918 EDMA3CCInitParams initParam;
919 int8_t gInstanceId = EDMA_DRV_INST_DSS_A;
921 int32_t retVal = 0;
923 EDMA3CCInitParams_init(&initParam);
924 initParam.initParamSet = TRUE;
926 retVal = EDMA_init(gInstanceId, &initParam);
927 if (retVal != EDMA_NO_ERROR)
928 {
929 printf ("Debug: EDMA instance 0 initialization returned error %d\n", retVal);
930 return NULL;
931 }
932 printf ("Debug: EDMA instance 0 has been initialized\n");
934 memset(&EDMAErrorInfo, 0, sizeof(EDMAErrorInfo));
935 memset(&EDMATransferControllerErrorInfo, 0, sizeof(EDMATransferControllerErrorInfo));
937 /* Open the first EDMA Instance */
938 EdmaHandle = EDMA_open(gInstanceId, &retVal, &instanceInfo);
939 if (EdmaHandle == NULL)
940 {
941 printf("Error: Unable to open the edma Instance, erorCode = %d\n", retVal);
942 }
944 /* Configure EDMA Error Monitor */
945 errorConfig.isConfigAllEventQueues = true;
946 errorConfig.isConfigAllTransferControllers = true;
947 errorConfig.isEventQueueThresholdingEnabled = true;
948 errorConfig.eventQueueThreshold = EDMA_EVENT_QUEUE_THRESHOLD_MAX;
949 errorConfig.isEnableAllTransferControllerErrors = true;
950 errorConfig.callbackFxn = Test_edmaErrorCallbackFxn;
951 errorConfig.transferControllerCallbackFxn = Test_edmaTransferControllerErrorCallbackFxn;
952 if ((retVal = EDMA_configErrorMonitoring(EdmaHandle, &errorConfig)) != EDMA_NO_ERROR)
953 {
954 printf("Debug: EDMA_configErrorMonitoring() failed with errorCode = %d\n", retVal);
955 return NULL;
956 }
958 return EdmaHandle;
959 }
961 /**
962 * @b Description
963 * @n
964 * System Initialization Task which initializes the various
965 * components in the system.
966 *
967 * @retval
968 * Not Applicable.
969 */
970 void Test_ADCBUFInitTask(void* arg0, void* arg1)
971 {
972 EDMA_Handle EdmaHandle = NULL;
973 SemaphoreP_Params semParams;
974 ADCBuf_Params params;
975 ADCBuf_Handle handle;
976 ADCBuf_dataFormat dataFormat;
977 bool edmaTransComplete ;
978 uint8_t index;
979 volatile uint32_t srcMemAddr;
980 volatile uint32_t dstMemAddr;
981 uint32_t numSamples;
982 ADCBuf_dataFormat *ptrDataFormat = &dataFormat;
983 int32_t retVal = 0;
985 OsalRegisterIntrParams_t intrPrms;
986 HwiP_Handle hwiHandle = NULL;
987 uint32_t intrPriority;
989 printf("\n/*******************************************************************/ \n");
990 printf("/************************* ADCBUF Test *****************************/ \n");
991 printf("/*******************************************************************/ \n");
993 /* Initialize the ADCBUF */
994 ADCBuf_init();
996 if(gADCBUFTestParam.enableEdma)
997 {
998 EdmaHandle = Test_ADCBUFInitEDMA();
999 if(EdmaHandle == NULL)
1000 {
1001 printf("Debug: EDMA Init failed \n");
1002 goto Exit;
1003 }
1004 }
1006 /**************************************************************************
1007 * Test: Basic API test
1008 **************************************************************************/
1010 /* Basic API Test */
1011 if(Test_ADCBUFApiTest() < 0)
1012 printf ("ADCBUF Basic API test failed\n");
1013 else
1014 printf ("ADCBUF Basic API test passed\n");
1016 /**************************************************************************
1017 * Test: Parameter validation test
1018 **************************************************************************/
1020 /* Test input parameters */
1021 if (Test_ADCBUFCmdParamsCheckTest() < 0)
1022 printf ("ADCBUF Input Parameters Validation Test failed\n");
1023 else
1024 printf ("ADCBUF Input Parameters Validation Test passed\n");
1026 /**************************************************************************
1027 * Test: Reopen the driver to test in Continuous Mode
1028 **************************************************************************/
1030 /* YES: Create a binary semaphore which is used to handle interrupt handling. */
1031 SemaphoreP_Params_init(&semParams);
1032 semParams.mode = SemaphoreP_Mode_BINARY;
1033 gIntSemaHandle = SemaphoreP_create(0, &semParams);
1035 /* Setup the default ADCBUF Parameters */
1036 ADCBuf_Params_init(¶ms);
1037 params.continousMode = 1;
1039 /* Go through different data format test cases */
1040 for (index = 0; index < TOTAL_TEST_CASES; index++)
1041 {
1042 handle = ADCBuf_open(0, ¶ms);
1043 if (handle == NULL)
1044 {
1045 printf("Error: Unable to open the ADCBUF Instance\n");
1046 return;
1047 }
1048 printf("Debug: ADCBUF Instance %p has been reopened successfully\n", handle);
1050 /* Register chirp interrupt */
1051 #if defined(_TMS320C6X)
1052 intrPriority = OSAL_DEFAULT_PRIORITY;
1053 #else
1054 intrPriority = 0x1U;
1055 #endif
1057 Osal_RegisterInterrupt_initParams(&intrPrms);
1059 /* Populate the interrupt parameters */
1060 intrPrms.corepacConfig.arg = (uintptr_t) handle;
1061 intrPrms.corepacConfig.isrRoutine = Test_ADCBUFIntCallBackFunc;
1062 intrPrms.corepacConfig.priority = intrPriority;
1063 intrPrms.corepacConfig.name = "ADC_CAPTURE_COMPLETE";
1065 #if defined (_TMS320C6X)
1066 /* On C66x, we use Event Combiner to map the interrupt to the CPU Intc. To
1067 * do this, OSAL expects that event number holds the interrupt number and we
1068 * use the macro for interrupt number to specify we wish to use Event
1069 * Combiner.
1070 */
1071 intrPrms.corepacConfig.corepacEventNum = (int32_t)gADCBUFTestParam.chirpIntNumber;
1072 intrPrms.corepacConfig.intVecNum = OSAL_REGINT_INTVEC_EVENT_COMBINER;
1073 #else
1074 /* Other (non-C66x) CPUs don't use event number and interrupt number is
1075 * passed in and programmed to CPU Intc directly.
1076 */
1077 intrPrms.corepacConfig.corepacEventNum = (int32_t)0;
1078 intrPrms.corepacConfig.intVecNum = (int32_t)gADCBUFTestParam.chirpIntNumber;
1079 #endif
1081 /* Register interrupts */
1082 if(OSAL_INT_SUCCESS != Osal_RegisterInterrupt(&intrPrms, &hwiHandle))
1083 {
1084 printf("Error: Unable to register Chirp interrupt\n");
1085 hwiHandle = NULL;
1086 goto Exit;
1087 }
1089 /* Initialize the data format for the test */
1090 dataFormat = dataFmtTestCase_awr2944[index];
1092 /* Print out the test params */
1093 printf("ADCBUF Test Pattern with dataFormat=%d, sampleSwap=%d, interleave=%d \n",
1094 dataFormat.adcOutFormat, dataFormat.sampleInterleave,
1095 dataFormat.channelInterleave);
1097 /* Number of loops that test run for current data Format
1098 Data is validated for every 10 ping/pong buffer swap.
1099 */
1100 gTestRun = 20;
1102 /* ADCBuf Test Pattern Test, this function will be blocked until gTestRun is set to 0 */
1103 Test_ADCBUFContDataPathWithTestPattern(handle, &dataFormat);
1105 /* Assign memory base address to save the ADC samples */
1106 dstMemAddr = CSL_locToGlobAddr(gADCBUFTestParam.dstMemAddr);
1107 srcMemAddr = CSL_locToGlobAddr(gADCBUFTestParam.ADCBUFMemAddr);
1108 numSamples = gADCBUFTestParam.numSamples;
1110 while(gTestRun)
1111 {
1112 /* Wait for the Semaphore */
1113 SemaphoreP_pend(gIntSemaHandle, SemaphoreP_WAIT_FOREVER);
1116 if(gADCBUFTestParam.enableEdma)
1117 {
1118 edmaTransComplete = false;
1119 /* Trigger DMA copy */
1120 Test_ADCBUFConfigEdma(EdmaHandle, EDMA_DSS_TPCC_A_EVT_FREE_0,
1121 (uint32_t *)srcMemAddr, (uint32_t *)dstMemAddr,
1122 16 * numSamples, 1, 1, EDMA_NUM_DMA_CHANNELS);
1124 EDMA_startDmaTransfer(EdmaHandle, EDMA_DSS_TPCC_A_EVT_FREE_0);
1126 /* Polling transfer completion */
1127 while(edmaTransComplete == false)
1128 {
1129 EDMA_isTransferComplete(EdmaHandle, 0, &edmaTransComplete);
1130 TaskP_sleepInMsecs(1);
1131 }
1132 }
1133 else
1134 {
1135 /* Copy the adcbuf data to memory */
1136 memcpy( (void *)(dstMemAddr), (void *)(srcMemAddr), 16 * numSamples );
1138 CacheP_wbInv ((const void*)dstMemAddr, 16 * numSamples);
1139 }
1141 CacheP_Inv((const void*)srcMemAddr, (16 * numSamples));
1142 CacheP_Inv((const void*)dstMemAddr, (16 * numSamples));
1144 /* Verify data integrity */
1145 if (Test_ADCBUFVerifyDataPattern((void *)dstMemAddr, ptrDataFormat) !=0 )
1146 {
1147 gVerifyFailCount++;
1148 }
1150 gTestRun--;
1152 /* Re-Start Test Pattern generation if test is not stopped */
1153 if(gTestRun)
1154 {
1155 uint32_t rxChanMask;
1157 /* Disable all channels */
1158 rxChanMask = 0xF;
1159 if ((retVal = ADCBuf_control(handle, ADCBufMMWave_CMD_CHANNEL_DISABLE, (void *)&rxChanMask)) < 0)
1160 {
1161 printf("Error: ADCBufMMWave_CMD_CHANNEL_DISABLE failed with [Error=%d]\n", retVal);
1162 }
1164 /* ADCBuf Test Pattern Test, this function will be blocked until gTestRun is set to 0 */
1165 Test_ADCBUFContDataPathWithTestPattern(handle, &dataFormat);
1166 }
1167 }
1169 /* StopTest Pattern generation */
1170 if (( retVal = ADCBuf_control(handle, ADCBufMMWave_CMD_STOP_TEST_PATTERN, NULL)) < 0)
1171 printf("Error: ADCBufMMWave_CMD_STOP_TEST_PATTERN failed with [Error=%d]\n", retVal);
1173 /* Close ADCBuf driver */
1174 ADCBuf_close(handle);
1175 printf("Debug: ADCBUF Instance %p has been closed successfully\n", handle);
1177 /* Deregister chirp interrupt listener */
1178 #if defined (_TMS3206X)
1179 corepacEventNum = (int32_t)gADCBUFTestParam.chirpIntNumber;
1180 Osal_DisableInterrupt(corepacEventNum, (int32_t)OSAL_REGINT_INTVEC_EVENT_COMBINER);
1181 #else
1182 Osal_DisableInterrupt(0, (int32_t)gADCBUFTestParam.chirpIntNumber);
1183 #endif
1185 #if defined (_TMS320C6x)
1186 corepacEventNum = (int32_t)coreIntrNum;
1187 #endif
1189 /* Delete interrupts */
1190 #if defined (_TMS3206X)
1191 corepacEventNum = (int32_t)gADCBUFTestParam.chirpIntNumber;
1192 (void) Osal_DeleteInterrupt((HwiP_Handle) hwiHandle, corepacEventNum);
1193 #else
1194 (void) Osal_DeleteInterrupt((HwiP_Handle) hwiHandle, gADCBUFTestParam.chirpIntNumber);
1196 #endif
1198 /* Send test results to logger */
1199 if (gVerifyFailCount > 0)
1200 {
1201 printf ("ADCBUF Test Pattern failed\n");
1202 printf ("gVerifyFailCount = %d\n", gVerifyFailCount);
1203 }
1204 else
1205 printf ("ADCBUF Test Pattern passed\n");
1207 /* Clear the counter */
1208 gIntCounter = 0;
1209 gVerifyFailCount = 0;
1211 }
1213 /**************************************************************************
1214 * Test: Graceful shutdown
1215 **************************************************************************/
1216 /* Close EDMA driver */
1217 if(EdmaHandle != NULL)
1218 Test_ADCBUFCloseEDMA(EdmaHandle);
1219 /* Delete semaphore */
1220 SemaphoreP_delete(gIntSemaHandle);
1221 printf("Debug: Semaphore Instance %p has been closed successfully\n", gIntSemaHandle);
1223 Exit:
1224 /* Stop OS */
1225 OS_stop();
1227 return;
1228 }
1230 /**
1231 * @b Description
1232 * @n
1233 * Entry point into the test code.
1234 *
1235 * @retval
1236 * Not Applicable.
1237 */
1238 int main (void)
1239 {
1240 TaskP_Params taskParams;
1242 /* Initialize the Task Parameters. */
1243 TaskP_Params_init(&taskParams);
1244 taskParams.stack = gAppTskStackMain;
1245 taskParams.stacksize = sizeof(gAppTskStackMain);
1246 TaskP_create(Test_ADCBUFInitTask, &taskParams);
1248 /* Start OS */
1249 OS_start();
1251 return 0;
1252 }