d5af04410457374029689965cad07581e4150a28
[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 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 /**
52  *  \brief   EDMA3 mem-to-mem data copy test case, using a DMA channel.
53  *              This test case doesnot rely on the callback mechanism.
54  *              Instead, it Polls the IPR register to check the transfer
55  *              completion status.
56  *
57  *  \param  acnt        [IN]      Number of bytes in an array
58  *  \param  bcnt        [IN]      Number of arrays in a frame
59  *  \param  ccnt        [IN]      Number of frames in a block
60  *  \param  syncType    [IN]      Synchronization type (A/AB Sync)
61  *
62  *  \return  EDMA3_DRV_SOK or EDMA3_DRV Error Code
63  */
64 EDMA3_DRV_Result edma3_test_poll_mode(
65                                                         EDMA3_DRV_Handle hEdma,
66                                         unsigned int acnt,
67                                         unsigned int bcnt,
68                                         unsigned int ccnt,
69                                         EDMA3_DRV_SyncType syncType)
70     {
71     EDMA3_DRV_Result result = EDMA3_DRV_SOK;
72     unsigned int chId = 0;
73     unsigned int tcc = 0;
74     int i;
75     unsigned int count;
76     unsigned int Istestpassed = 0u;
77     unsigned int numenabled = 0;
78     unsigned int BRCnt = 0;
79     int srcbidx = 0, desbidx = 0;
80     int srccidx = 0, descidx = 0;
83     srcBuff1 = (signed char*)_srcBuff1;
84     dstBuff1 = (signed char*)_dstBuff1;
87     /* Initalize source and destination buffers */
88     for (count = 0u; count < (acnt*bcnt*ccnt); count++)
89         {
90         srcBuff1[count] = (int)count+5;
91         /**
92          * No need to initialize the destination buffer as it is being invalidated.
93         dstBuff1[count] = initval;
94         */
95         }
98 #ifdef EDMA3_ENABLE_DCACHE
99     /*
100     * Note: These functions are required if the buffer is in DDR.
101     * For other cases, where buffer is NOT in DDR, user
102     * may or may not require the below functions.
103     */
104     /* Flush the Source Buffer */
105     if (result == EDMA3_DRV_SOK)
106         {
107         result = Edma3_CacheFlush((unsigned int)srcBuff1, (acnt*bcnt*ccnt));
108         }
110     /* Invalidate the Destination Buffer */
111     if (result == EDMA3_DRV_SOK)
112         {
113         result = Edma3_CacheInvalidate((unsigned int)dstBuff1, (acnt*bcnt*ccnt));
114         }
115 #endif  /* EDMA3_ENABLE_DCACHE */
118     /* Set B count reload as B count. */
119     BRCnt = bcnt;
121     /* Setting up the SRC/DES Index */
122     srcbidx = (int)acnt;
123     desbidx = (int)acnt;
125     if (syncType == EDMA3_DRV_SYNC_A)
126         {
127         /* A Sync Transfer Mode */
128         srccidx = (int)acnt;
129         descidx = (int)acnt;
130         }
131     else
132         {
133         /* AB Sync Transfer Mode */
134         srccidx = ((int)acnt * (int)bcnt);
135         descidx = ((int)acnt * (int)bcnt);
136         }
139     /* Setup for Channel 1*/
140     tcc = EDMA3_DRV_TCC_ANY;
141     chId = EDMA3_DRV_DMA_CHANNEL_ANY;
144     /* Request any DMA channel and any TCC */
145     if (result == EDMA3_DRV_SOK)
146         {
147         result = EDMA3_DRV_requestChannel (hEdma, &chId, &tcc,
148                                             (EDMA3_RM_EventQueue)0,
149                                             NULL, NULL);
150         }
152     if (result == EDMA3_DRV_SOK)
153         {
154         result = EDMA3_DRV_setSrcParams (hEdma, chId, (unsigned int)(srcBuff1),
155                                         EDMA3_DRV_ADDR_MODE_INCR,
156                                         EDMA3_DRV_W8BIT);
157         }
159     if (result == EDMA3_DRV_SOK)
160         {
161         result = EDMA3_DRV_setDestParams (hEdma, chId, (unsigned int)(dstBuff1),
162                                             EDMA3_DRV_ADDR_MODE_INCR,
163                                             EDMA3_DRV_W8BIT);
164         }
166     if (result == EDMA3_DRV_SOK)
167         {
168         result = EDMA3_DRV_setSrcIndex (hEdma, chId, srcbidx, srccidx);
169         }
171     if (result == EDMA3_DRV_SOK)
172         {
173         result =  EDMA3_DRV_setDestIndex (hEdma, chId, desbidx, descidx);
174         }
176     if (result == EDMA3_DRV_SOK)
177         {
178         if (syncType == EDMA3_DRV_SYNC_A)
179             {
180             result = EDMA3_DRV_setTransferParams (hEdma, chId, acnt, bcnt, ccnt,
181                                                 BRCnt, EDMA3_DRV_SYNC_A);
182             }
183         else
184             {
185             result = EDMA3_DRV_setTransferParams (hEdma, chId, acnt, bcnt, ccnt,
186                                                 BRCnt, EDMA3_DRV_SYNC_AB);
187             }
188         }
190     if (result == EDMA3_DRV_SOK)
191         {
192         result = EDMA3_DRV_setOptField (hEdma, chId,
193                                         EDMA3_DRV_OPT_FIELD_TCINTEN, 1u);
194         }
196     if (result == EDMA3_DRV_SOK)
197         {
198         result = EDMA3_DRV_setOptField (hEdma, chId,
199                                         EDMA3_DRV_OPT_FIELD_ITCINTEN, 1u);
200         }
202     /*
203      * Since the transfer is going to happen in Manual mode of EDMA3
204      * operation, we have to 'Enable the Transfer' multiple times.
205      * Number of times depends upon the Mode (A/AB Sync)
206      * and the different counts.
207      */
208     if (result == EDMA3_DRV_SOK)
209         {
210         /*Need to activate next param*/
211         if (syncType == EDMA3_DRV_SYNC_A)
212             {
213             numenabled = bcnt * ccnt;
214             }
215         else
216             {
217             /* AB Sync Transfer Mode */
218             numenabled = ccnt;
219             }
222         for (i = 0; i < numenabled; i++)
223             {
224             /*
225              * Now enable the transfer as many times as calculated above.
226              */
227             result = EDMA3_DRV_enableTransfer (hEdma, chId,
228                                                 EDMA3_DRV_TRIG_MODE_MANUAL);
229             if (result != EDMA3_DRV_SOK)
230                 {
231 #ifdef EDMA3_DRV_DEBUG
232                 EDMA3_DRV_PRINTF ("edma3_test_poll_mode: EDMA3_DRV_enableTransfer " \
233                                     "Failed, error code: %d\r\n", result);
234 #endif  /* EDMA3_DRV_DEBUG */
235                 break;
236                 }
239             /* Wait for the Completion Bit to be SET in the IPR/IPRH register. */
240             result = EDMA3_DRV_waitAndClearTcc (hEdma, tcc);
241             if (result != EDMA3_DRV_SOK)
242                 {
243 #ifdef EDMA3_DRV_DEBUG
244                 EDMA3_DRV_PRINTF ("edma3_test_poll_mode: EDMA3_DRV_waitAndClearTcc " \
245                                     "Failed, error code: %d\r\n", result);
246 #endif  /* EDMA3_DRV_DEBUG */
247                 break;
248                 }
249             }
250         }
253     /* Match the Source and Destination Buffers. */
254     if (EDMA3_DRV_SOK == result)
255         {
256         for (i = 0; i < (acnt*bcnt*ccnt); i++)
257             {
258             if (srcBuff1[i] != dstBuff1[i])
259                 {
260                 Istestpassed = 0u;
261 #ifdef EDMA3_DRV_DEBUG
262                 EDMA3_DRV_PRINTF("edma3_test_poll_mode: Data write-read matching" \
263                                      "FAILED at i = %d\r\n", i);
264 #endif  /* EDMA3_DRV_DEBUG */
265                 break;
266                 }
267             }
268         if (i == (acnt*bcnt*ccnt))
269             {
270             Istestpassed = 1u;
271             }
274         /* Free the previously allocated channel. */
275         result = EDMA3_DRV_freeChannel (hEdma, chId);
276         if (result != EDMA3_DRV_SOK)
277             {
278 #ifdef EDMA3_DRV_DEBUG
279             EDMA3_DRV_PRINTF("edma3_test_poll_mode: EDMA3_DRV_freeChannel() FAILED, " \
280                                 "error code: %d\r\n", result);
281 #endif  /* EDMA3_DRV_DEBUG */
282             }
283         }
286     if(Istestpassed == 1u)
287         {
288 #ifdef EDMA3_DRV_DEBUG
289         EDMA3_DRV_PRINTF("edma3_test_poll_mode PASSED\r\n");
290 #endif  /* EDMA3_DRV_DEBUG */
291         }
292     else
293         {
294 #ifdef EDMA3_DRV_DEBUG
295         EDMA3_DRV_PRINTF("edma3_test_poll_mode FAILED\r\n");
296 #endif  /* EDMA3_DRV_DEBUG */
297         result = ((EDMA3_DRV_SOK == result) ?
298                                 EDMA3_DATA_MISMATCH_ERROR : result);
299         }
302     return result;