[processor-sdk/pdk.git] / packages / ti / drv / udma / unit_test / udma_ut / src / udma_test_common.c
1 /*
2 * Copyright (c) Texas Instruments Incorporated 2018
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 * \file udma_test_common.c
35 *
36 * \brief Common code that can be shared across test case files.
37 *
38 */
40 /* ========================================================================== */
41 /* Include Files */
42 /* ========================================================================== */
44 #include <udma_test.h>
46 /* ========================================================================== */
47 /* Macros & Typedefs */
48 /* ========================================================================== */
50 #if defined (__C7100__)
51 /* UART not yet supported */
52 #else
53 #define APPUTILS_UART_INPUT
54 #endif
56 /* ========================================================================== */
57 /* Structure Declarations */
58 /* ========================================================================== */
60 /* None */
62 /* ========================================================================== */
63 /* Function Declarations */
64 /* ========================================================================== */
66 /* None */
68 /* ========================================================================== */
69 /* Global Variables */
70 /* ========================================================================== */
72 static uint32_t gUdmaTestCounter = 0;
73 static uint32_t gUdmaPassCounter = 0;
74 static uint32_t gUdmaFailCounter = 0;
76 /* ========================================================================== */
77 /* Function Definitions */
78 /* ========================================================================== */
80 /**
81 * Initialize driver for all instances
82 */
83 int32_t udmaTestInitDriver(UdmaTestObj *testObj)
84 {
85 int32_t retVal = UDMA_SOK;
86 uint32_t instId;
87 Udma_InitPrms initPrms;
88 Udma_DrvHandle drvHandle;
90 for(instId = 0U; instId < UDMA_INST_ID_MAX; instId++)
91 {
92 /* UDMA driver init */
93 drvHandle = &testObj->drvObj[instId];
94 UdmaInitPrms_init(instId, &initPrms);
95 initPrms.virtToPhyFxn = &Udma_appVirtToPhyFxn;
96 initPrms.phyToVirtFxn = &Udma_appPhyToVirtFxn;
97 initPrms.printFxn = &udmaDrvPrint;
98 /* Override RM params for HC and UHC blockcpy channels as they are not
99 * part of default table */
100 if(UDMA_INST_ID_MAIN_0 == instId)
101 {
102 initPrms.rmInitPrms.startBlkCopyUhcCh = UDMA_TEST_MAIN_UHC_START;
103 initPrms.rmInitPrms.numBlkCopyUhcCh = UDMA_TEST_MAX_MAIN_BC_UHC_CH;
104 initPrms.rmInitPrms.startBlkCopyHcCh = UDMA_TEST_MAIN_HC_START;
105 initPrms.rmInitPrms.numBlkCopyHcCh = UDMA_TEST_MAX_MAIN_BC_HC_CH;
106 }
107 else
108 {
109 initPrms.rmInitPrms.startBlkCopyUhcCh = UDMA_TEST_MCU_UHC_START;
110 initPrms.rmInitPrms.numBlkCopyUhcCh = UDMA_TEST_MAX_MCU_BC_UHC_CH;
111 initPrms.rmInitPrms.startBlkCopyHcCh = UDMA_TEST_MCU_HC_START;
112 initPrms.rmInitPrms.numBlkCopyHcCh = UDMA_TEST_MAX_MCU_BC_HC_CH;
113 }
115 retVal += Udma_init(drvHandle, &initPrms);
116 if(UDMA_SOK != retVal)
117 {
118 GT_1trace(testObj->traceMask, GT_ERR,
119 " UDMA instance %d init failed!!\n", instId);
120 }
121 }
123 return (retVal);
124 }
126 int32_t udmaTestDeinitDriver(UdmaTestObj *testObj)
127 {
128 int32_t retVal = UDMA_SOK;
129 uint32_t instId;
130 Udma_DrvHandle drvHandle;
132 for(instId = 0U; instId < UDMA_INST_ID_MAX; instId++)
133 {
134 /* UDMA driver deinit */
135 drvHandle = &testObj->drvObj[instId];
136 retVal += Udma_deinit(drvHandle);
137 if(UDMA_SOK != retVal)
138 {
139 GT_1trace(testObj->traceMask, GT_ERR,
140 " UDMA instance %d deinit failed!!\n", instId);
141 }
142 }
144 return (retVal);
145 }
147 /**
148 * udmaTestInitVariables
149 * Initialize the global variables and pointers.
150 */
151 int32_t udmaTestInitVariables(const UdmaTestObj *testObj)
152 {
153 int32_t retVal = UDMA_SOK;
155 return (retVal);
156 }
158 /**
159 * udmaTestFreeVariables
160 * Free the allocated handles and buffers.
161 */
162 void udmaTestFreeVariables(const UdmaTestObj *testObj)
163 {
164 return;
165 }
167 void udmaTestLogTestResult(const UdmaTestObj *testObj,
168 int32_t testResult,
169 uint32_t testCaseId,
170 char *testcaseInfo)
171 {
172 if(UDMA_SOK == testResult)
173 {
174 gUdmaPassCounter++;
175 GT_1trace(testObj->traceMask, GT_INFO,
176 " |TEST RESULT|PASS|%d|\r\n", testCaseId);
177 }
178 else
179 {
180 gUdmaFailCounter++;
181 GT_1trace(testObj->traceMask, GT_INFO,
182 " |TEST RESULT|FAIL|%d|\r\n", testCaseId);
183 }
185 gUdmaTestCounter++;
186 GT_1trace(testObj->traceMask, GT_INFO,
187 " |TEST END|:: %d ::\r\n", testCaseId);
189 return;
190 }
192 void udmaTestPrintTestResult(const UdmaTestObj *testObj,
193 uint32_t skipCount,
194 uint32_t disableCount)
195 {
196 GT_0trace(testObj->traceMask, GT_INFO,
197 "\r\n *********Test Case Statistics*****************");
198 GT_1trace(testObj->traceMask, GT_INFO,
199 "\r\n Total Test Case : %d",
200 (gUdmaTestCounter + skipCount + disableCount));
201 GT_1trace(testObj->traceMask, GT_INFO,
202 "\r\n Total Test Case Executed: %d", gUdmaTestCounter);
203 GT_1trace(testObj->traceMask, GT_INFO,
204 "\r\n Total Test Case Passed : %d", gUdmaPassCounter);
205 GT_1trace(testObj->traceMask, GT_INFO,
206 "\r\n Total Test Case Failed : %d", gUdmaFailCounter);
207 GT_1trace(testObj->traceMask, GT_INFO,
208 "\r\n Total Test Case Skipped : %d", skipCount);
209 GT_1trace(testObj->traceMask, GT_INFO,
210 "\r\n Total Test Case Disabled: %d", disableCount);
211 GT_0trace(testObj->traceMask, GT_INFO,
212 "\r\n *********************************************\r\n \r\n");
214 if(gUdmaFailCounter > 0U)
215 {
216 GT_0trace(testObj->traceMask, GT_INFO,
217 "\r\n Some tests have failed. \r\n");
218 }
219 else
220 {
221 GT_0trace(testObj->traceMask, GT_INFO,
222 "\r\n All tests have passed. \r\n");
223 }
225 return;
226 }
228 void udmaTestResetTestResult(void)
229 {
230 gUdmaTestCounter = 0;
231 gUdmaPassCounter = 0;
232 gUdmaFailCounter = 0;
234 return;
235 }
237 char AppUtils_getChar(void)
238 {
239 char ch;
241 #if defined (APPUTILS_UART_INPUT)
242 UART_scanFmt("%c", &ch);
243 #else
244 scanf("%c", &ch);
245 #endif
247 return (ch);
248 }
250 int32_t AppUtils_getCharTimeout(char *ch, uint32_t msec)
251 {
252 int32_t retVal = UDMA_EFAIL;
253 #if defined (APPUTILS_UART_INPUT)
254 /* Timeout not yet supported in UART console */
255 #if 0
256 uint32_t startTime, elaspsedTime;
258 startTime = AppUtils_getCurTimeInMsec();
259 do
260 {
261 retVal = UARTGetcNonBlocking((uint8 *) ch);
262 if(retVal == 0U)
263 {
264 retVal = UDMA_SOK;
265 break;
266 }
267 retVal = UDMA_EFAIL;
268 elaspsedTime = AppUtils_getElapsedTimeInMsec(startTime);
269 } while(elaspsedTime <= msec);
270 #else
271 UART_scanFmt("%c", ch);
272 retVal = UDMA_SOK;
273 #endif
274 #else
275 /* Timeout not supported by stdio scanf */
276 scanf("%c", ch);
277 retVal = UDMA_SOK;
278 #endif
280 return (retVal);
281 }
283 int32_t AppUtils_getNum(void)
284 {
285 int32_t num;
287 #if defined (APPUTILS_UART_INPUT)
288 UART_scanFmt("%d", &num);
289 #else
290 scanf("%d", &num);
291 #endif
293 return (num);
294 }
296 uint32_t AppUtils_getCurTimeInMsec(void)
297 {
298 uint64_t curTimeMsec = 0, curTimeUsec = 0;
300 #if defined (UDMA_UT_BAREMETAL) && defined (BUILD_C7X_1)
301 /* C7x baremetal doesnot support getting time timestamp */
302 #else
303 curTimeUsec = TimerP_getTimeInUsecs();
304 #endif
305 curTimeMsec = (curTimeUsec / 1000U);
307 return ((uint32_t) curTimeMsec);
308 }
310 uint32_t AppUtils_getElapsedTimeInMsec(uint32_t startTime)
311 {
312 uint32_t elapsedTimeMsec = 0U, currTime;
314 currTime = AppUtils_getCurTimeInMsec();
315 if (currTime < startTime)
316 {
317 /* Counter overflow occured */
318 elapsedTimeMsec = (0xFFFFFFFFU - startTime) + currTime + 1U;
319 }
320 else
321 {
322 elapsedTimeMsec = currTime - startTime;
323 }
325 return (elapsedTimeMsec);
326 }
328 void udmaTestCalcPerformance(UdmaTestTaskObj *taskObj, uint32_t durationMs)
329 {
330 uint32_t chCnt;
331 uint64_t totalTransfer, curTransfer;
332 UdmaTestChObj *chObj;
334 totalTransfer = 0u;
335 for(chCnt = 0U ; chCnt < taskObj->numCh; chCnt++)
336 {
337 chObj = taskObj->chObj[chCnt];
338 GT_assert(taskObj->traceMask, chObj != NULL);
340 curTransfer = ((uint64_t) chObj->icnt[0] * (uint64_t) chObj->icnt[1] *
341 (uint64_t) chObj->icnt[2] * (uint64_t) chObj->icnt[3] *
342 (uint64_t) taskObj->loopCnt);
343 if((UDMA_TT_BLK_CPY == taskObj->testType) ||
344 (UDMA_TT_DRU_DIRECT == taskObj->testType) ||
345 (UDMA_TT_DRU_INDIRECT == taskObj->testType))
346 {
347 /* Memcpy is for both read and write */
348 curTransfer *= 2U;
349 }
350 totalTransfer += curTransfer;
351 }
353 /* Calculate performance */
354 taskObj->durationMs = durationMs;
355 taskObj->totalTransfer = totalTransfer;
356 taskObj->mps = (uint64_t)
357 ((totalTransfer / (uint64_t) 1000) / (uint64_t) durationMs);
359 GT_0trace(taskObj->traceMask, GT_INFO1, " \r\n");
360 GT_2trace(taskObj->traceMask, GT_INFO1,
361 " |TEST RESULT|:: Task:%d: Throughput: %d MB/s ::\r\n", taskObj->taskId, taskObj->mps);
363 return;
364 }
366 void udmaTestCalcTotalPerformance(UdmaTestObj *testObj, uint32_t durationMs)
367 {
368 uint32_t taskCnt;
369 uint64_t totalTransfer, mps;
370 UdmaTestTaskObj *taskObj;
372 totalTransfer = 0u;
373 for(taskCnt = 0U; taskCnt < testObj->testPrms->numTasks; taskCnt++)
374 {
375 taskObj = &testObj->taskObj[taskCnt];
376 totalTransfer += taskObj->totalTransfer;
377 }
379 /* Calculate performance */
380 mps = (uint64_t) ((totalTransfer / (uint64_t) 1000) / (uint64_t) durationMs);
382 GT_0trace(testObj->traceMask, GT_INFO, " \r\n");
383 GT_1trace(testObj->traceMask, GT_INFO,
384 " |TEST RESULT|:: Throughput: %d MB/s ::\r\n", mps);
386 return;
387 }
389 int32_t udmaTestCompareRingHwOccDriver(Udma_RingHandle ringHandle, uint32_t cnt)
390 {
391 int32_t retVal = UDMA_EFAIL;
392 uint32_t retry = 10000U;
394 /* There is some delay expected between HWOCC update and ring push */
395 while(retry > 0U)
396 {
397 if(CSL_REG32_RD(&ringHandle->pRtRegs->HWOCC) == cnt)
398 {
399 retVal = UDMA_SOK;
400 break;
401 }
402 retry--;
403 }
405 return (retVal);
406 }