372bf35c65b1ca7261e3d4d73f9e12519928f9d3
1 /*
2 * dma_misc_test.c
3 *
4 * Miscellaneous EDMA3 test cases.
5 *
6 * Copyright (C) 2009 Texas Instruments Incorporated - http://www.ti.com/
7 *
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
11 * are met:
12 *
13 * Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 *
16 * Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the
19 * distribution.
20 *
21 * Neither the name of Texas Instruments Incorporated nor the names of
22 * its contributors may be used to endorse or promote products derived
23 * from this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 *
37 */
39 #include "sample.h"
41 /**
42 * \brief EDMA3 misc test cases.
43 * This test case will read/write to some CC registers.
44 *
45 * \return EDMA3_DRV_SOK or EDMA3_DRV Error Code
46 */
47 EDMA3_DRV_Result edma3_misc_test(EDMA3_DRV_Handle hEdma)
48 {
49 EDMA3_DRV_Result drvResult = EDMA3_DRV_SOK;
50 uint32_t ccRegOffset = 0u;
51 uint32_t ccRegVal = 0u;
52 uint32_t newRegVal = 0u;
53 uint32_t origRegVal = 0u;
56 /**
57 *1. Try fetching some CC registers value.
58 * It should PASS.
59 */
60 /* PID Register */
61 ccRegOffset = 0x0u;
62 ccRegVal = 0;
63 drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &ccRegVal);
65 if (drvResult != EDMA3_DRV_SOK)
66 {
67 #ifdef EDMA3_DRV_DEBUG
68 EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Failed, test FAILED\r\n", ccRegOffset);
69 #endif
70 }
71 else
72 {
73 #ifdef EDMA3_DRV_DEBUG
74 EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Passed, test PASSED\r\n", ccRegOffset);
75 #endif
77 #ifdef EDMA3_DEBUG_PRINT
78 EDMA3_DEBUG_PRINTF ("Fetched CC Register at Offset 0X%x, Value = 0X%x\r\n", ccRegOffset, ccRegVal);
79 #endif /* EDMA3_DEBUG_PRINT */
80 }
83 if (drvResult == EDMA3_DRV_SOK)
84 {
85 /* Fetch DRAE1 Register */
86 ccRegOffset = 0x0348u;
87 ccRegVal = 0;
88 drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &ccRegVal);
90 if (drvResult != EDMA3_DRV_SOK)
91 {
92 #ifdef EDMA3_DRV_DEBUG
93 EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Failed, test FAILED\r\n", ccRegOffset);
94 #endif
95 }
96 else
97 {
98 #ifdef EDMA3_DRV_DEBUG
99 EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Passed, test PASSED\r\n", ccRegOffset);
100 #endif
102 #ifdef EDMA3_DEBUG_PRINT
103 EDMA3_DEBUG_PRINTF ("Fetched CC Register at Offset 0X%x, Value = 0X%x\r\n", ccRegOffset, ccRegVal);
104 #endif /* EDMA3_DEBUG_PRINT */
105 }
106 }
109 if (drvResult == EDMA3_DRV_SOK)
110 {
111 /* Fetch QWMTHRA Register */
112 ccRegOffset = 0x0620u;
113 ccRegVal = 0;
114 drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &ccRegVal);
116 if (drvResult != EDMA3_DRV_SOK)
117 {
118 #ifdef EDMA3_DRV_DEBUG
119 EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Failed, test FAILED\r\n", ccRegOffset);
120 #endif
121 return drvResult;
122 }
123 else
124 {
125 #ifdef EDMA3_DRV_DEBUG
126 EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Passed, test PASSED\r\n", ccRegOffset);
127 #endif
129 #ifdef EDMA3_DEBUG_PRINT
130 EDMA3_DEBUG_PRINTF ("Fetched CC Register at Offset 0X%x, Value = 0X%x\r\n", ccRegOffset, ccRegVal);
131 #endif /* EDMA3_DEBUG_PRINT */
132 }
133 }
137 /**
138 * 2. Try fetching some CC registers value, whose offset is not 4-bytes
139 * aligned. It should FAIL.
140 */
141 if (drvResult == EDMA3_DRV_SOK)
142 {
143 ccRegOffset = 0x1002u;
144 ccRegVal = 0x0u;
145 drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &ccRegVal);
147 if (drvResult == EDMA3_DRV_E_INVALID_PARAM)
148 {
149 #ifdef EDMA3_DEBUG_PRINT
150 EDMA3_DEBUG_PRINTF ("Fetching Invalid CC Register (offset 0X%x) Failed, test PASSED\r\n", ccRegOffset);
151 #endif /* EDMA3_DEBUG_PRINT */
152 drvResult = EDMA3_DRV_SOK;
153 }
154 else
155 {
156 #ifdef EDMA3_DEBUG_PRINT
157 EDMA3_DEBUG_PRINTF ("Fetching Invalid CC Register (offset 0X%x) Passed, test FAILED\r\n", ccRegOffset);
158 #endif /* EDMA3_DEBUG_PRINT */
159 }
160 }
164 /**
165 * 3. Read CC Register QWMTHRA. Store the current value. Write a different
166 * value on it. Read it back. Write the original value again. Read it back to
167 * cross-check. It should PASS.
168 */
169 if (drvResult == EDMA3_DRV_SOK)
170 {
171 ccRegOffset = 0x0620u;
172 origRegVal = 0x0u;
173 drvResult = EDMA3_DRV_getCCRegister(hEdma, ccRegOffset, &origRegVal);
175 if (drvResult != EDMA3_DRV_SOK)
176 {
177 #ifdef EDMA3_DRV_DEBUG
178 EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Failed, test FAILED\r\n", ccRegOffset);
179 #endif
180 }
181 else
182 {
183 #ifdef EDMA3_DRV_DEBUG
184 EDMA3_DRV_PRINTF ("Fetching CC Register (offset 0X%x) Passed, test PASSED\r\n", ccRegOffset);
185 #endif
187 #ifdef EDMA3_DEBUG_PRINT
188 EDMA3_DEBUG_PRINTF ("Fetched CC Register at Offset 0X%x, Value = 0X%x\r\n", ccRegOffset, origRegVal);
189 #endif /* EDMA3_DEBUG_PRINT */
191 /* Find the new value to be written, it depends on the no of event queues */
192 switch (origRegVal)
193 {
194 /* Write a new value on the same register */
195 case 0x10:
196 /* 1 TC */
197 newRegVal = 0x0Fu;
198 break;
200 case 0x1010:
201 /* 2 TC */
202 newRegVal = 0x0F0Fu;
203 break;
205 case 0x101010:
206 /* 3 TC */
207 newRegVal = 0x0F0F0Fu;
208 break;
210 case 0x10101010:
211 /* 4 TC */
212 newRegVal = 0x0F0F0F0Fu;
213 break;
215 default:
216 newRegVal = origRegVal;
217 break;
218 }
220 drvResult = EDMA3_DRV_setCCRegister (hEdma, ccRegOffset, newRegVal);
221 if (drvResult == EDMA3_DRV_SOK)
222 {
223 /* If write is successful, read it back to check */
224 ccRegVal = 0x0u;
226 drvResult = EDMA3_DRV_getCCRegister (hEdma, ccRegOffset, &ccRegVal);
227 if (drvResult == EDMA3_DRV_SOK)
228 {
229 /* Check with the value which we have written */
230 if (newRegVal == ccRegVal)
231 {
232 #ifdef EDMA3_DEBUG_PRINT
233 EDMA3_DEBUG_PRINTF ("Value written successfully \r\n");
234 #endif /* EDMA3_DEBUG_PRINT */
235 }
236 else
237 {
238 #ifdef EDMA3_DRV_DEBUG
239 EDMA3_DRV_PRINTF ("QWMTHRA write FAILED \r\n");
240 #endif
241 drvResult = EDMA3_DRV_E_INVALID_PARAM;
242 }
243 }
245 /* Restore the original value */
246 if (drvResult == EDMA3_DRV_SOK)
247 {
248 drvResult = EDMA3_DRV_setCCRegister (hEdma, ccRegOffset, origRegVal);
249 if (drvResult != EDMA3_DRV_SOK)
250 {
251 #ifdef EDMA3_DEBUG_PRINT
252 EDMA3_DEBUG_PRINTF ("QWMTHRA Restore FAILED\r\n");
253 #endif /* EDMA3_DEBUG_PRINT */
254 }
255 else
256 {
257 #ifdef EDMA3_DEBUG_PRINT
258 EDMA3_DEBUG_PRINTF ("QWMTHRA Restore Successful\r\n");
259 #endif /* EDMA3_DEBUG_PRINT */
260 }
261 }
262 }
263 }
264 }
267 return drvResult;
268 }