PRSDK-415 Address review comments.
[keystone-rtos/edma3_lld.git] / examples / edma3_driver / src / dma_poll_test.c
1 /*
2 * dma_poll_test.c
3 *
4 * Test case demonstrating the poll mode scenario. User has requested a data 
5 * transfer without giving any callback function. After programming and 
6 * enabling the channel, he uses different APIs (meant to be used in poll mode)
7 * to check the status of ongoing transfer. Interrupt will NOT occur in this 
8 * case.
9 *
10 * Copyright (C) 2009-2018 Texas Instruments Incorporated - http://www.ti.com/
11
12
13 *  Redistribution and use in source and binary forms, with or without 
14 *  modification, are permitted provided that the following conditions 
15 *  are met:
16 *
17 *    Redistributions of source code must retain the above copyright 
18 *    notice, this list of conditions and the following disclaimer.
19 *
20 *    Redistributions in binary form must reproduce the above copyright
21 *    notice, this list of conditions and the following disclaimer in the 
22 *    documentation and/or other materials provided with the   
23 *    distribution.
24 *
25 *    Neither the name of Texas Instruments Incorporated nor the names of
26 *    its contributors may be used to endorse or promote products derived
27 *    from this software without specific prior written permission.
28 *
29 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
30 *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
31 *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
32 *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
33 *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
34 *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
35 *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
36 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
37 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
38 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
39 *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 *
41 */
43 #include "sample.h"
45 extern signed char   _srcBuff1[MAX_BUFFER_SIZE];
46 extern signed char   _dstBuff1[MAX_BUFFER_SIZE];
48 extern signed char *srcBuff1;
49 extern signed char *dstBuff1;
51 #define EDMA3_DRV_DMA_CHANNEL_USR_REQ     (10)
52 /**
53 *  \brief   EDMA3 mem-to-mem data copy test case, using a DMA channel.
54 *              This test case doesnot rely on the callback mechanism.
55 *              Instead, it Polls the IPR register to check the transfer
56 *              completion status.
57 *
58 *  \param  acnt        [IN]      Number of bytes in an array
59 *  \param  bcnt        [IN]      Number of arrays in a frame
60 *  \param  ccnt        [IN]      Number of frames in a block
61 *  \param  syncType    [IN]      Synchronization type (A/AB Sync)
62 *
63 *  \return  EDMA3_DRV_SOK or EDMA3_DRV Error Code
64 */
65 EDMA3_DRV_Result edma3_test_poll_mode(
66                                       EDMA3_DRV_Handle hEdma,
67                                       uint32_t acnt,
68                                       uint32_t bcnt,
69                                       uint32_t ccnt,
70                                       EDMA3_DRV_SyncType syncType)
71 {
72     EDMA3_DRV_Result result = EDMA3_DRV_SOK;
73     uint32_t chId = 0;
74     uint32_t tcc = 0;
75     int i;
76     uint32_t count;
77     uint32_t Istestpassed = 0u;
78     uint32_t numenabled = 0;
79     uint32_t BRCnt = 0;
80     int srcbidx = 0, desbidx = 0;
81     int srccidx = 0, descidx = 0;
82 #ifdef EDMA3_RES_USER_REQ
83     uint32_t paRAMId = 0;
84 #endif
87     srcBuff1 = (signed char*) GLOBAL_ADDR(_srcBuff1);
88     dstBuff1 = (signed char*) GLOBAL_ADDR(_dstBuff1);
90     /* Initalize source and destination buffers */
91     for (count = 0u; count < (acnt*bcnt*ccnt); count++)
92     {
93         srcBuff1[count] = (int)count+5;
94         /**
95         * No need to initialize the destination buffer as it is being invalidated.
96         dstBuff1[count] = initval;
97         */
98     }
101 #ifdef EDMA3_ENABLE_DCACHE
102     /*
103     * Note: These functions are required if the buffer is in DDR.
104     * For other cases, where buffer is NOT in DDR, user
105     * may or may not require the below functions.
106     */
107     /* Flush the Source Buffer */
108     if (result == EDMA3_DRV_SOK)
109     {
110         result = Edma3_CacheFlush((uint32_t)srcBuff1, (acnt*bcnt*ccnt));
111     }
113     /* Invalidate the Destination Buffer */
114     if (result == EDMA3_DRV_SOK)
115     {
116         result = Edma3_CacheInvalidate((uint32_t)dstBuff1, (acnt*bcnt*ccnt));
117     }
118 #endif  /* EDMA3_ENABLE_DCACHE */
121     /* Set B count reload as B count. */
122     BRCnt = bcnt;
124     /* Setting up the SRC/DES Index */
125     srcbidx = (int)acnt;
126     desbidx = (int)acnt;
128     if (syncType == EDMA3_DRV_SYNC_A)
129     {
130         /* A Sync Transfer Mode */
131         srccidx = (int)acnt;
132         descidx = (int)acnt;
133     }
134     else
135     {
136         /* AB Sync Transfer Mode */
137         srccidx = ((int)acnt * (int)bcnt);
138         descidx = ((int)acnt * (int)bcnt);
139     }
142     /* Setup for Channel 1*/
143     tcc = EDMA3_DRV_TCC_ANY;
144 #ifdef EDMA3_RES_USER_REQ
145     chId = EDMA3_DRV_DMA_CHANNEL_USR_REQ;
146 #else
147     chId = EDMA3_DRV_DMA_CHANNEL_ANY;
148 #endif
151     /* Request any DMA channel and any TCC */
152     if (result == EDMA3_DRV_SOK)
153     {
154         result = EDMA3_DRV_requestChannel (hEdma, &chId, &tcc,
155             (EDMA3_RM_EventQueue)0,
156             NULL, NULL);
157 #ifdef EDMA3_RES_USER_REQ
158         result = EDMA3_DRV_getAllocatedPARAMId(hEdma, chId, &paRAMId);
159         if(result == EDMA3_DRV_SOK)
160         {
161             printf("\nReserved Channel ID Test\n");
162             printf ("The Requested Channel ID: %d \nThe allocated PARAM Id:%d\n",chId,paRAMId);
164             if (chId == paRAMId)
165             {
166                 printf("The Requested Param ID is allocated for the given Channel\n");
167             }
168             printf("\n");
169         }
170 #endif
171     }
173     if (result == EDMA3_DRV_SOK)
174     {
175         result = EDMA3_DRV_setSrcParams (hEdma, chId, (uint32_t)(srcBuff1),
176             EDMA3_DRV_ADDR_MODE_INCR,
177             EDMA3_DRV_W8BIT);
178     }
180     if (result == EDMA3_DRV_SOK)
181     {
182         result = EDMA3_DRV_setDestParams (hEdma, chId, (uint32_t)(dstBuff1),
183             EDMA3_DRV_ADDR_MODE_INCR,
184             EDMA3_DRV_W8BIT);
185     }
187     if (result == EDMA3_DRV_SOK)
188     {
189         result = EDMA3_DRV_setSrcIndex (hEdma, chId, srcbidx, srccidx);
190     }
192     if (result == EDMA3_DRV_SOK)
193     {
194         result =  EDMA3_DRV_setDestIndex (hEdma, chId, desbidx, descidx);
195     }
197     if (result == EDMA3_DRV_SOK)
198     {
199         if (syncType == EDMA3_DRV_SYNC_A)
200         {
201             result = EDMA3_DRV_setTransferParams (hEdma, chId, acnt, bcnt, ccnt,
202                 BRCnt, EDMA3_DRV_SYNC_A);
203         }
204         else
205         {
206             result = EDMA3_DRV_setTransferParams (hEdma, chId, acnt, bcnt, ccnt,
207                 BRCnt, EDMA3_DRV_SYNC_AB);
208         }
209     }
211     if (result == EDMA3_DRV_SOK)
212     {
213         result = EDMA3_DRV_setOptField (hEdma, chId,
214             EDMA3_DRV_OPT_FIELD_TCINTEN, 1u);
215     }
217     if (result == EDMA3_DRV_SOK)
218     {
219         result = EDMA3_DRV_setOptField (hEdma, chId,
220             EDMA3_DRV_OPT_FIELD_ITCINTEN, 1u);
221     }
223     /*
224     * Since the transfer is going to happen in Manual mode of EDMA3
225     * operation, we have to 'Enable the Transfer' multiple times.
226     * Number of times depends upon the Mode (A/AB Sync)
227     * and the different counts.
228     */
229     if (result == EDMA3_DRV_SOK)
230     {
231         /*Need to activate next param*/
232         if (syncType == EDMA3_DRV_SYNC_A)
233         {
234             numenabled = bcnt * ccnt;
235         }
236         else
237         {
238             /* AB Sync Transfer Mode */
239             numenabled = ccnt;
240         }
243         for (i = 0; i < numenabled; i++)
244         {
245             /*
246             * Now enable the transfer as many times as calculated above.
247             */
248             result = EDMA3_DRV_enableTransfer (hEdma, chId,
249                 EDMA3_DRV_TRIG_MODE_MANUAL);
250             if (result != EDMA3_DRV_SOK)
251             {
252 #ifdef EDMA3_DRV_DEBUG
253                 EDMA3_DRV_PRINTF ("edma3_test_poll_mode: EDMA3_DRV_enableTransfer " \
254                     "Failed, error code: %d\r\n", result);
255 #endif  /* EDMA3_DRV_DEBUG */
256                 break;
257             }
260             /* Wait for the Completion Bit to be SET in the IPR/IPRH register. */
261             result = EDMA3_DRV_waitAndClearTcc (hEdma, tcc);
262             if (result != EDMA3_DRV_SOK)
263             {
264 #ifdef EDMA3_DRV_DEBUG
265                 EDMA3_DRV_PRINTF ("edma3_test_poll_mode: EDMA3_DRV_waitAndClearTcc " \
266                     "Failed, error code: %d\r\n", result);
267 #endif  /* EDMA3_DRV_DEBUG */
268                 break;
269             }
270         }
271     }
274     /* Match the Source and Destination Buffers. */
275     if (EDMA3_DRV_SOK == result)
276     {
277         for (i = 0; i < (acnt*bcnt*ccnt); i++)
278         {
279             if (srcBuff1[i] != dstBuff1[i])
280             {
281                 Istestpassed = 0u;
282 #ifdef EDMA3_DRV_DEBUG
283                 EDMA3_DRV_PRINTF("edma3_test_poll_mode: Data write-read matching" \
284                     "FAILED at i = %d\r\n", i);
285 #endif  /* EDMA3_DRV_DEBUG */
286                 break;
287             }
288         }
289         if (i == (acnt*bcnt*ccnt))
290         {
291             Istestpassed = 1u;
292         }
295         /* Free the previously allocated channel. */
296         result = EDMA3_DRV_freeChannel (hEdma, chId);
297         if (result != EDMA3_DRV_SOK)
298         {
299 #ifdef EDMA3_DRV_DEBUG
300             EDMA3_DRV_PRINTF("edma3_test_poll_mode: EDMA3_DRV_freeChannel() FAILED, " \
301                 "error code: %d\r\n", result);
302 #endif  /* EDMA3_DRV_DEBUG */
303         }
304     }
307     if(Istestpassed == 1u)
308     {
309 #ifdef EDMA3_DRV_DEBUG
310         EDMA3_DRV_PRINTF("edma3_test_poll_mode PASSED\r\n");
311 #endif  /* EDMA3_DRV_DEBUG */
312     }
313     else
314     {
315 #ifdef EDMA3_DRV_DEBUG
316         EDMA3_DRV_PRINTF("edma3_test_poll_mode FAILED\r\n");
317 #endif  /* EDMA3_DRV_DEBUG */
318         result = ((EDMA3_DRV_SOK == result) ?
319                     EDMA3_DATA_MISMATCH_ERROR : result);
320     }
321     return result;