[PDK-9595] UDMA UT: Added new testcase for Udma_eventEnable/Udma_eventDisable
[processor-sdk/pdk.git] / packages / ti / drv / udma / unit_test / udma_ut / src / udma_test_event.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_event.c
35  *
36  *  \brief UDMA event related test case file.
37  *
38  */
40 /* ========================================================================== */
41 /*                             Include Files                                  */
42 /* ========================================================================== */
44 #include <udma_test.h>
46 /* ========================================================================== */
47 /*                           Macros & Typedefs                                */
48 /* ========================================================================== */
50 /* None */
52 /* ========================================================================== */
53 /*                         Structure Declarations                             */
54 /* ========================================================================== */
56 /* None */
58 /* ========================================================================== */
59 /*                          Function Declarations                             */
60 /* ========================================================================== */
62 static int32_t udmaTestEventOutOfRangeFlowLoop(UdmaTestTaskObj *taskObj,
63                                                uint32_t loopCnt);
64 static int32_t udmaTestEventDisableEnableSanityLoop(UdmaTestTaskObj *taskObj,
65                                                     uint32_t loopCnt);
66 static int32_t udmaTestEventDisableEnableFxns(UdmaTestTaskObj *taskObj,
67                                               Udma_EventHandle eventHandle);
68 static void udmaTestEventCb(Udma_EventHandle eventHandle,
69                             uint32_t eventType,
70                             void *appData);
72 /* ========================================================================== */
73 /*                            Global Variables                                */
74 /* ========================================================================== */
76 /* Global test pass/fail flag */
77 static volatile int32_t gUdmaTestEventResult = UDMA_SOK;
79 /* ========================================================================== */
80 /*                          Function Definitions                              */
81 /* ========================================================================== */
83 int32_t udmaTestEventOutOfRangeFlow(UdmaTestTaskObj *taskObj)
84 {
85     int32_t     retVal = UDMA_SOK;
86     uint32_t    loopCnt = 0U;
88     GT_1trace(taskObj->traceMask, GT_INFO1,
89               " |TEST INFO|:: Task:%d: Out Of Range Flow Event Testcase ::\r\n", taskObj->taskId);
90     GT_2trace(taskObj->traceMask, GT_INFO1,
91               " |TEST INFO|:: Task:%d: Loop count           : %d ::\r\n", taskObj->taskId, taskObj->loopCnt);
93     gUdmaTestEventResult = UDMA_SOK;
94     while(loopCnt < taskObj->loopCnt)
95     {
96         /* Perform flow event test */
97         retVal = udmaTestEventOutOfRangeFlowLoop(taskObj, loopCnt);
98         if(UDMA_SOK != retVal)
99         {
100             break;
101         }
103         loopCnt++;
104     }
106     retVal += gUdmaTestEventResult;
108     return (retVal);
111 int32_t udmaTestEventDisableEnableSanity(UdmaTestTaskObj *taskObj)
113     int32_t     retVal = UDMA_SOK;
114     uint32_t    loopCnt = 0U;
116     GT_1trace(taskObj->traceMask, GT_INFO1,
117               " |TEST INFO|:: Task:%d: Event Disable and Enable Sanity check Testcase ::\r\n", taskObj->taskId);
118     GT_2trace(taskObj->traceMask, GT_INFO1,
119               " |TEST INFO|:: Task:%d: Loop count           : %d ::\r\n", taskObj->taskId, taskObj->loopCnt);
121     gUdmaTestEventResult = UDMA_SOK;
122     while(loopCnt < taskObj->loopCnt)
123     {
124         retVal = udmaTestEventDisableEnableSanityLoop(taskObj, loopCnt);
125         if(UDMA_SOK != retVal)
126         {
127             break;
128         }
130         loopCnt++;
131     }
133     retVal += gUdmaTestEventResult;
135     return (retVal);
138 static int32_t udmaTestEventOutOfRangeFlowLoop(UdmaTestTaskObj *taskObj,
139                                                uint32_t loopCnt)
141     int32_t                     retVal = UDMA_SOK;
142     uint32_t                    instId;
143     Udma_DrvHandle              drvHandle;
144     Udma_EventPrms              eventPrms;
145     struct Udma_EventObj        eventObj;
146     Udma_EventHandle            eventHandle = NULL;
147     Udma_EventRxFlowIdFwStatus  status;
148     char                       *instanceIdStr[] = {"MAIN", "MCU", "BCDMA", "PKTDMA"};
150     for(instId = UDMA_INST_ID_START; instId <= UDMA_INST_ID_MAX; instId++)
151     {
152         if(0U == loopCnt)
153         {
154             GT_1trace(taskObj->traceMask, GT_INFO1,
155                       " Testing for NAVSS Inst: %s ...\r\n", instanceIdStr[instId]);
156         }
158         drvHandle = &taskObj->testObj->drvObj[instId];
160         /* Register flow error event */
161         eventHandle = &eventObj;
162         UdmaEventPrms_init(&eventPrms);
163         eventPrms.eventType         = UDMA_EVENT_TYPE_ERR_OUT_OF_RANGE_FLOW;
164         eventPrms.eventMode         = UDMA_EVENT_MODE_SHARED;
165         eventPrms.masterEventHandle = Udma_eventGetGlobalHandle(drvHandle);
166         eventPrms.eventCb           = &udmaTestEventCb;
167         retVal = Udma_eventRegister(drvHandle, eventHandle, &eventPrms);
168         if(UDMA_SOK != retVal)
169         {
170             GT_0trace(taskObj->traceMask, GT_ERR,
171                 " UDMA Flow error event register failed!!\n");
172             break;
173         }
175         /* Note: Since this event can't be reproduced in a standalone UDMA
176          * level testcase, this test doesn't wait for the event to happen.
177          * This just checks register and unregister check
178          */
180         /* Just check status API sanity */
181         retVal = Udma_eventGetRxFlowIdFwStatus(eventHandle, &status);
182         if(UDMA_SOK != retVal)
183         {
184             GT_0trace(taskObj->traceMask, GT_ERR, " RX flow ID FW status get failed!!\n");
185         }
186         else
187         {
188             if(0U == loopCnt)
189             {
190                 GT_1trace(taskObj->traceMask, GT_INFO1,
191                     " Rx Flow ID Status : %d\r\n", status.isException);
192                 GT_1trace(taskObj->traceMask, GT_INFO1,
193                     " Rx Flow ID        : %d\r\n", status.flowId);
194                 GT_1trace(taskObj->traceMask, GT_INFO1,
195                     " Rx Channel        : %d\r\n", status.chNum);
196             }
197         }
199         retVal += Udma_eventUnRegister(eventHandle);
200         if(UDMA_SOK != retVal)
201         {
202             GT_0trace(taskObj->traceMask, GT_ERR, " Event unregister failed!!\n");
203             break;
204         }
206         if(0U == loopCnt)
207         {
208             GT_1trace(taskObj->traceMask, GT_INFO1,
209                       " Testing for NAVSS Inst: %s passed!!\r\n", instanceIdStr[instId]);
210         }
211     }
213     return (retVal);
216 static int32_t udmaTestEventDisableEnableSanityLoop(UdmaTestTaskObj *taskObj,
217                                                     uint32_t loopCnt)
219     int32_t                     retVal = UDMA_SOK;
220     uint32_t                    instId;
221     Udma_DrvHandle              drvHandle;
222     Udma_EventPrms              eventPrms;
223     struct Udma_EventObj        eventObj;
224     Udma_EventHandle            eventHandle = NULL;
225     char                       *instanceIdStr[] = {"MAIN", "MCU", "BCDMA", "PKTDMA"};
227     for(instId = UDMA_INST_ID_START; instId <= UDMA_INST_ID_MAX; instId++)
228     {
229         if(0U == loopCnt)
230         {
231             GT_1trace(taskObj->traceMask, GT_INFO1,
232                       " Testing for NAVSS Inst: %s ...\r\n", instanceIdStr[instId]);
233         }
235         drvHandle = &taskObj->testObj->drvObj[instId];
237         eventHandle = &eventObj;
239         /* Exclusive Event Enable/Disable Test */
240         UdmaEventPrms_init(&eventPrms);
241         eventPrms.eventType         = UDMA_EVENT_TYPE_ERR_OUT_OF_RANGE_FLOW;
242         eventPrms.eventMode         = UDMA_EVENT_MODE_EXCLUSIVE;
243         eventPrms.masterEventHandle = NULL;
244         eventPrms.eventCb           = &udmaTestEventCb;
245         retVal = Udma_eventRegister(drvHandle, eventHandle, &eventPrms);
246         if(UDMA_SOK != retVal)
247         {
248             GT_0trace(taskObj->traceMask, GT_ERR,
249                 " UDMA exclusive event register failed!!\n");
250         }
251         
252         retVal += udmaTestEventDisableEnableFxns(taskObj, eventHandle);
253         if(UDMA_SOK == retVal)
254         {
255             GT_0trace(taskObj->traceMask, GT_ERR, " Exclusive Event Disable/Enable passed!!\n");
256         }
258         retVal += Udma_eventUnRegister(eventHandle);
259         if(UDMA_SOK != retVal)
260         {
261             GT_0trace(taskObj->traceMask, GT_ERR, " Exclusive Event unregister failed!!\n");
262         }
264         /* Shared Event Enable/Disable Test */
265         UdmaEventPrms_init(&eventPrms);
266         eventPrms.eventType         = UDMA_EVENT_TYPE_ERR_OUT_OF_RANGE_FLOW;
267         eventPrms.eventMode         = UDMA_EVENT_MODE_SHARED;
268         eventPrms.masterEventHandle = Udma_eventGetGlobalHandle(drvHandle);
269         eventPrms.eventCb           = &udmaTestEventCb;
270         retVal += Udma_eventRegister(drvHandle, eventHandle, &eventPrms);
271         if(UDMA_SOK != retVal)
272         {
273             GT_0trace(taskObj->traceMask, GT_ERR,
274                 " UDMA shared event register failed!!\n");
275         }
277         retVal += udmaTestEventDisableEnableFxns(taskObj, eventHandle);
278         if(UDMA_SOK == retVal)
279         {
280             GT_0trace(taskObj->traceMask, GT_ERR, " Shared Event Disable/Enable passed!!\n");
281         }
283         retVal += Udma_eventUnRegister(eventHandle);
284         if(UDMA_SOK != retVal)
285         {
286             GT_0trace(taskObj->traceMask, GT_ERR, " Shared Event unregister failed!!\n");
287         }
288         
290         if(0U == loopCnt)
291         {
292             GT_1trace(taskObj->traceMask, GT_INFO1,
293                       " Testing for NAVSS Inst: %s passed!!\r\n", instanceIdStr[instId]);
294         }
295     }
297     return (retVal);
300 static int32_t udmaTestEventDisableEnableFxns(UdmaTestTaskObj *taskObj,
301                                               Udma_EventHandle eventHandle)
303     int32_t                     retVal = UDMA_SOK;
305     /* Note: This sanity just checks event disable and enable API's.
306      * This test doesn't wait for the event to happen.
307      */
309     /* Just check API sanity */
310     retVal = Udma_eventDisable(eventHandle);
311     if(UDMA_SOK != retVal)
312     {
313         GT_0trace(taskObj->traceMask, GT_ERR,
314             " UDMA event disable failed!!\n");
315     }
316     retVal += Udma_eventEnable(eventHandle);
317     if(UDMA_SOK != retVal)
318     {
319         GT_0trace(taskObj->traceMask, GT_ERR,
320             " UDMA event enable failed!!\n");
321     }
323     return (retVal);
326 static void udmaTestEventCb(Udma_EventHandle eventHandle,
327                             uint32_t eventType,
328                             void *appData)
330     SemaphoreP_Handle   transferDoneSem = (SemaphoreP_Handle) appData;
332     if(transferDoneSem != NULL)
333     {
334         if(UDMA_EVENT_TYPE_ERR_OUT_OF_RANGE_FLOW == eventType)
335         {
336             SemaphoreP_post(transferDoneSem);
337         }
338         else
339         {
340             gUdmaTestEventResult = UDMA_EFAIL;
341         }
342     }
343     else
344     {
345         gUdmaTestEventResult = UDMA_EFAIL;
346     }
348     return;