diff options
author | Sivaraj R | 2019-09-24 21:30:35 -0500 |
---|---|---|
committer | Sivaraj R | 2019-09-25 00:28:10 -0500 |
commit | 002c86cec5f9ff61cf321f542e1718980177c82f (patch) | |
tree | 09f3dc578024a8268e85e4fac9a5be94dafc21f0 | |
parent | 4a68d7e8e427df2840bee47c3fb060b08e33f7b4 (diff) | |
download | udma-lld-002c86cec5f9ff61cf321f542e1718980177c82f.tar.gz udma-lld-002c86cec5f9ff61cf321f542e1718980177c82f.tar.xz udma-lld-002c86cec5f9ff61cf321f542e1718980177c82f.zip |
PDK-4654: UDMA deinit doesn't check for allocated resources
- Added negative testcase to test this
Signed-off-by: Sivaraj R <sivaraj@ti.com>
-rw-r--r-- | src/udma.c | 12 | ||||
-rw-r--r-- | src/udma_priv.h | 1 | ||||
-rw-r--r-- | src/udma_rm.c | 138 | ||||
-rw-r--r-- | udma.h | 4 | ||||
-rw-r--r-- | unit_test/udma_ut/src/udma_test.h | 1 | ||||
-rw-r--r-- | unit_test/udma_ut/src/udma_test_bug.c | 87 | ||||
-rw-r--r-- | unit_test/udma_ut/src/udma_testcases.h | 37 |
7 files changed, 275 insertions, 5 deletions
@@ -178,14 +178,26 @@ int32_t Udma_deinit(Udma_DrvHandle drvHandle) | |||
178 | retVal = Udma_eventUnRegister(drvHandle->globalEventHandle); | 178 | retVal = Udma_eventUnRegister(drvHandle->globalEventHandle); |
179 | drvHandle->globalEventHandle = NULL_PTR; | 179 | drvHandle->globalEventHandle = NULL_PTR; |
180 | } | 180 | } |
181 | |||
182 | retVal = Udma_rmDeinit(drvHandle); | ||
183 | if(UDMA_SOK != retVal) | ||
184 | { | ||
185 | Udma_printf(drvHandle, "[Error] RM deinit failed!!!\n"); | ||
186 | } | ||
187 | } | ||
188 | |||
189 | if(UDMA_SOK == retVal) | ||
190 | { | ||
181 | Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.deleteMutex != NULL_PTR); | 191 | Udma_assert(drvHandle, drvHandle->initPrms.osalPrms.deleteMutex != NULL_PTR); |
182 | if(NULL_PTR != drvHandle->rmLock) | 192 | if(NULL_PTR != drvHandle->rmLock) |
183 | { | 193 | { |
184 | drvHandle->initPrms.osalPrms.deleteMutex(drvHandle->rmLock); | 194 | drvHandle->initPrms.osalPrms.deleteMutex(drvHandle->rmLock); |
195 | drvHandle->rmLock = NULL_PTR; | ||
185 | } | 196 | } |
186 | if(NULL_PTR != drvHandle->printLock) | 197 | if(NULL_PTR != drvHandle->printLock) |
187 | { | 198 | { |
188 | drvHandle->initPrms.osalPrms.deleteMutex(drvHandle->printLock); | 199 | drvHandle->initPrms.osalPrms.deleteMutex(drvHandle->printLock); |
200 | drvHandle->printLock = NULL_PTR; | ||
189 | } | 201 | } |
190 | (void) memset(drvHandle, 0, sizeof(*drvHandle)); | 202 | (void) memset(drvHandle, 0, sizeof(*drvHandle)); |
191 | drvHandle->drvInitDone = UDMA_DEINIT_DONE; | 203 | drvHandle->drvInitDone = UDMA_DEINIT_DONE; |
diff --git a/src/udma_priv.h b/src/udma_priv.h index 3bbecb6..707aa19 100644 --- a/src/udma_priv.h +++ b/src/udma_priv.h | |||
@@ -103,6 +103,7 @@ void Udma_ringaccMemOps(void *pVirtAddr, uint32_t size, uint32_t opsType); | |||
103 | * RM APIs | 103 | * RM APIs |
104 | */ | 104 | */ |
105 | int32_t Udma_rmInit(Udma_DrvHandle drvHandle); | 105 | int32_t Udma_rmInit(Udma_DrvHandle drvHandle); |
106 | int32_t Udma_rmDeinit(Udma_DrvHandle drvHandle); | ||
106 | /* Channel RM APIs */ | 107 | /* Channel RM APIs */ |
107 | uint32_t Udma_rmAllocBlkCopyCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle); | 108 | uint32_t Udma_rmAllocBlkCopyCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle); |
108 | void Udma_rmFreeBlkCopyCh(uint32_t chNum, Udma_DrvHandle drvHandle); | 109 | void Udma_rmFreeBlkCopyCh(uint32_t chNum, Udma_DrvHandle drvHandle); |
diff --git a/src/udma_rm.c b/src/udma_rm.c index 019c33d..52bc022 100644 --- a/src/udma_rm.c +++ b/src/udma_rm.c | |||
@@ -60,7 +60,10 @@ | |||
60 | /* Function Declarations */ | 60 | /* Function Declarations */ |
61 | /* ========================================================================== */ | 61 | /* ========================================================================== */ |
62 | 62 | ||
63 | /* None */ | 63 | static int32_t Udma_rmCheckResLeak(Udma_DrvHandle drvHandle, |
64 | const uint32_t *allocFlag, | ||
65 | uint32_t numRes, | ||
66 | uint32_t arrSize); | ||
64 | 67 | ||
65 | /* ========================================================================== */ | 68 | /* ========================================================================== */ |
66 | /* Global Variables */ | 69 | /* Global Variables */ |
@@ -232,6 +235,104 @@ int32_t Udma_rmInit(Udma_DrvHandle drvHandle) | |||
232 | return (retVal); | 235 | return (retVal); |
233 | } | 236 | } |
234 | 237 | ||
238 | int32_t Udma_rmDeinit(Udma_DrvHandle drvHandle) | ||
239 | { | ||
240 | int32_t retVal = UDMA_SOK; | ||
241 | uint32_t utcId; | ||
242 | Udma_RmInitPrms *rmInitPrms = &drvHandle->initPrms.rmInitPrms; | ||
243 | |||
244 | retVal += Udma_rmCheckResLeak( | ||
245 | drvHandle, | ||
246 | &drvHandle->blkCopyChFlag[0U], | ||
247 | rmInitPrms->numBlkCopyCh, | ||
248 | UDMA_RM_BLK_COPY_CH_ARR_SIZE); | ||
249 | retVal += Udma_rmCheckResLeak( | ||
250 | drvHandle, | ||
251 | &drvHandle->blkCopyHcChFlag[0U], | ||
252 | rmInitPrms->numBlkCopyHcCh, | ||
253 | UDMA_RM_BLK_COPY_HC_CH_ARR_SIZE); | ||
254 | retVal += Udma_rmCheckResLeak( | ||
255 | drvHandle, | ||
256 | &drvHandle->blkCopyUhcChFlag[0U], | ||
257 | rmInitPrms->numBlkCopyUhcCh, | ||
258 | UDMA_RM_BLK_COPY_UHC_CH_ARR_SIZE); | ||
259 | retVal += Udma_rmCheckResLeak( | ||
260 | drvHandle, | ||
261 | &drvHandle->txChFlag[0U], | ||
262 | rmInitPrms->numTxCh, | ||
263 | UDMA_RM_TX_CH_ARR_SIZE); | ||
264 | retVal += Udma_rmCheckResLeak( | ||
265 | drvHandle, | ||
266 | &drvHandle->txHcChFlag[0U], | ||
267 | rmInitPrms->numTxHcCh, | ||
268 | UDMA_RM_TX_HC_CH_ARR_SIZE); | ||
269 | retVal += Udma_rmCheckResLeak( | ||
270 | drvHandle, | ||
271 | &drvHandle->txUhcChFlag[0U], | ||
272 | rmInitPrms->numTxUhcCh, | ||
273 | UDMA_RM_TX_UHC_CH_ARR_SIZE); | ||
274 | retVal += Udma_rmCheckResLeak( | ||
275 | drvHandle, | ||
276 | &drvHandle->rxChFlag[0U], | ||
277 | rmInitPrms->numRxCh, | ||
278 | UDMA_RM_RX_CH_ARR_SIZE); | ||
279 | retVal += Udma_rmCheckResLeak( | ||
280 | drvHandle, | ||
281 | &drvHandle->rxHcChFlag[0U], | ||
282 | rmInitPrms->numRxHcCh, | ||
283 | UDMA_RM_RX_HC_CH_ARR_SIZE); | ||
284 | retVal += Udma_rmCheckResLeak( | ||
285 | drvHandle, | ||
286 | &drvHandle->rxUhcChFlag[0U], | ||
287 | rmInitPrms->numRxUhcCh, | ||
288 | UDMA_RM_RX_UHC_CH_ARR_SIZE); | ||
289 | for(utcId = 0U; utcId < UDMA_NUM_UTC_INSTANCE; utcId++) | ||
290 | { | ||
291 | retVal += Udma_rmCheckResLeak( | ||
292 | drvHandle, | ||
293 | &drvHandle->utcChFlag[utcId][0U], | ||
294 | rmInitPrms->numUtcCh[utcId], | ||
295 | UDMA_RM_UTC_CH_ARR_SIZE); | ||
296 | } | ||
297 | retVal += Udma_rmCheckResLeak( | ||
298 | drvHandle, | ||
299 | &drvHandle->freeRingFlag[0U], | ||
300 | rmInitPrms->numFreeRing, | ||
301 | UDMA_RM_FREE_RING_ARR_SIZE); | ||
302 | retVal += Udma_rmCheckResLeak( | ||
303 | drvHandle, | ||
304 | &drvHandle->freeFlowFlag[0U], | ||
305 | rmInitPrms->numFreeFlow, | ||
306 | UDMA_RM_FREE_FLOW_ARR_SIZE); | ||
307 | retVal += Udma_rmCheckResLeak( | ||
308 | drvHandle, | ||
309 | &drvHandle->globalEventFlag[0U], | ||
310 | rmInitPrms->numGlobalEvent, | ||
311 | UDMA_RM_GLOBAL_EVENT_ARR_SIZE); | ||
312 | retVal += Udma_rmCheckResLeak( | ||
313 | drvHandle, | ||
314 | &drvHandle->vintrFlag[0U], | ||
315 | rmInitPrms->numVintr, | ||
316 | UDMA_RM_VINTR_ARR_SIZE); | ||
317 | retVal += Udma_rmCheckResLeak( | ||
318 | drvHandle, | ||
319 | &drvHandle->coreIntrFlag[0U], | ||
320 | rmInitPrms->numIrIntr, | ||
321 | UDMA_RM_CORE_INTR_ARR_SIZE); | ||
322 | retVal += Udma_rmCheckResLeak( | ||
323 | drvHandle, | ||
324 | &drvHandle->proxyFlag[0U], | ||
325 | rmInitPrms->numProxy, | ||
326 | UDMA_RM_PROXY_ARR_SIZE); | ||
327 | retVal += Udma_rmCheckResLeak( | ||
328 | drvHandle, | ||
329 | &drvHandle->ringMonFlag[0U], | ||
330 | rmInitPrms->numRingMon, | ||
331 | UDMA_RM_RING_MON_ARR_SIZE); | ||
332 | |||
333 | return (retVal); | ||
334 | } | ||
335 | |||
235 | uint32_t Udma_rmAllocBlkCopyCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle) | 336 | uint32_t Udma_rmAllocBlkCopyCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle) |
236 | { | 337 | { |
237 | uint32_t i, offset, bitPos, bitMask; | 338 | uint32_t i, offset, bitPos, bitMask; |
@@ -1458,3 +1559,38 @@ void Udma_rmFreeRingMon(uint16_t ringMonNum, Udma_DrvHandle drvHandle) | |||
1458 | 1559 | ||
1459 | return; | 1560 | return; |
1460 | } | 1561 | } |
1562 | |||
1563 | static int32_t Udma_rmCheckResLeak(Udma_DrvHandle drvHandle, | ||
1564 | const uint32_t *allocFlag, | ||
1565 | uint32_t numRes, | ||
1566 | uint32_t arrSize) | ||
1567 | { | ||
1568 | int32_t retVal = UDMA_SOK; | ||
1569 | uint32_t i, offset, bitMask; | ||
1570 | |||
1571 | offset = 0; | ||
1572 | i = numRes; | ||
1573 | while(i > 0U) | ||
1574 | { | ||
1575 | if(i >= (uint32_t)32U) /* 32 resource per array element */ | ||
1576 | { | ||
1577 | bitMask = (uint32_t) 0xFFFFFFFFU; | ||
1578 | i -= 32U; | ||
1579 | } | ||
1580 | else | ||
1581 | { | ||
1582 | bitMask = ((uint32_t)1U << i) - ((uint32_t)1U); | ||
1583 | i = 0U; | ||
1584 | } | ||
1585 | |||
1586 | Udma_assert(drvHandle, offset < arrSize); | ||
1587 | if((allocFlag[offset] & bitMask) != bitMask) | ||
1588 | { | ||
1589 | retVal = UDMA_EFAIL; /* Some resources not freed */ | ||
1590 | break; | ||
1591 | } | ||
1592 | offset++; | ||
1593 | } | ||
1594 | |||
1595 | return (retVal); | ||
1596 | } | ||
@@ -411,9 +411,9 @@ struct Udma_DrvObj | |||
411 | */ | 411 | */ |
412 | uint32_t blkCopyChFlag[UDMA_RM_BLK_COPY_CH_ARR_SIZE]; | 412 | uint32_t blkCopyChFlag[UDMA_RM_BLK_COPY_CH_ARR_SIZE]; |
413 | /**< UDMA Block copy channel allocation flag */ | 413 | /**< UDMA Block copy channel allocation flag */ |
414 | uint32_t blkCopyHcChFlag[UDMA_RM_MAX_BLK_COPY_HC_CH]; | 414 | uint32_t blkCopyHcChFlag[UDMA_RM_BLK_COPY_HC_CH_ARR_SIZE]; |
415 | /**< UDMA high capacity Block copy channel allocation flag */ | 415 | /**< UDMA high capacity Block copy channel allocation flag */ |
416 | uint32_t blkCopyUhcChFlag[UDMA_RM_MAX_BLK_COPY_UHC_CH]; | 416 | uint32_t blkCopyUhcChFlag[UDMA_RM_BLK_COPY_UHC_CH_ARR_SIZE]; |
417 | /**< UDMA ultra high capacity Block copy channel allocation flag */ | 417 | /**< UDMA ultra high capacity Block copy channel allocation flag */ |
418 | 418 | ||
419 | uint32_t txChFlag[UDMA_RM_TX_CH_ARR_SIZE]; | 419 | uint32_t txChFlag[UDMA_RM_TX_CH_ARR_SIZE]; |
diff --git a/unit_test/udma_ut/src/udma_test.h b/unit_test/udma_ut/src/udma_test.h index 63a6349..1b3b869 100644 --- a/unit_test/udma_ut/src/udma_test.h +++ b/unit_test/udma_ut/src/udma_test.h | |||
@@ -614,6 +614,7 @@ int32_t udmaTestStructSizeTc(UdmaTestTaskObj *taskObj); | |||
614 | * UDMA bug test functions | 614 | * UDMA bug test functions |
615 | */ | 615 | */ |
616 | int32_t udmaTestBugTcPDK_3863(UdmaTestTaskObj *taskObj); | 616 | int32_t udmaTestBugTcPDK_3863(UdmaTestTaskObj *taskObj); |
617 | int32_t udmaTestBugTcPDK_4654(UdmaTestTaskObj *taskObj); | ||
617 | 618 | ||
618 | /* | 619 | /* |
619 | * UDMA Negative test case functions | 620 | * UDMA Negative test case functions |
diff --git a/unit_test/udma_ut/src/udma_test_bug.c b/unit_test/udma_ut/src/udma_test_bug.c index ea0b6b2..84479be 100644 --- a/unit_test/udma_ut/src/udma_test_bug.c +++ b/unit_test/udma_ut/src/udma_test_bug.c | |||
@@ -92,8 +92,7 @@ int32_t udmaTestBugTcPDK_3863(UdmaTestTaskObj *taskObj) | |||
92 | retVal = Udma_chOpen(chObj->drvHandle, &chObj->drvChObj, chType, &chPrms); | 92 | retVal = Udma_chOpen(chObj->drvHandle, &chObj->drvChObj, chType, &chPrms); |
93 | if(UDMA_SOK != retVal) | 93 | if(UDMA_SOK != retVal) |
94 | { | 94 | { |
95 | GT_0trace(taskObj->traceMask, GT_ERR, | 95 | GT_0trace(taskObj->traceMask, GT_ERR, " UDMA channel open failed!!\n"); |
96 | " UDMA channel open failed!!\n"); | ||
97 | } | 96 | } |
98 | else | 97 | else |
99 | { | 98 | { |
@@ -131,3 +130,87 @@ int32_t udmaTestBugTcPDK_3863(UdmaTestTaskObj *taskObj) | |||
131 | return (retVal); | 130 | return (retVal); |
132 | } | 131 | } |
133 | 132 | ||
133 | int32_t udmaTestBugTcPDK_4654(UdmaTestTaskObj *taskObj) | ||
134 | { | ||
135 | int32_t retVal = UDMA_SOK; | ||
136 | uint32_t instId; | ||
137 | Udma_DrvHandle drvHandle; | ||
138 | struct Udma_ProxyObj proxyObj; | ||
139 | Udma_ProxyHandle proxyHandle = &proxyObj; | ||
140 | |||
141 | GT_1trace(taskObj->traceMask, GT_INFO1, | ||
142 | " |TEST INFO|:: Task:%d: PDK-4654 Bug Testcase: Deinit RM check ::\r\n", taskObj->taskId); | ||
143 | |||
144 | /* Deinit already init driver */ | ||
145 | retVal = udmaTestDeinitDriver(taskObj->testObj); | ||
146 | if(UDMA_SOK != retVal) | ||
147 | { | ||
148 | GT_0trace(taskObj->traceMask, GT_ERR, " UDMA deinit failed!!\n"); | ||
149 | } | ||
150 | |||
151 | if(UDMA_SOK == retVal) | ||
152 | { | ||
153 | /* Do a fresh init */ | ||
154 | retVal = udmaTestInitDriver(taskObj->testObj); | ||
155 | if(UDMA_SOK != retVal) | ||
156 | { | ||
157 | GT_0trace(taskObj->traceMask, GT_ERR, " UDMA re-init failed!!\n"); | ||
158 | } | ||
159 | |||
160 | if(UDMA_SOK == retVal) | ||
161 | { | ||
162 | for(instId = 0U; instId < UDMA_INST_ID_MAX; instId++) | ||
163 | { | ||
164 | drvHandle = &taskObj->testObj->drvObj[instId]; | ||
165 | |||
166 | /* Alloc a proxy */ | ||
167 | retVal = Udma_proxyAlloc(drvHandle, proxyHandle, UDMA_PROXY_ANY); | ||
168 | if(UDMA_SOK != retVal) | ||
169 | { | ||
170 | GT_0trace(taskObj->traceMask, GT_ERR, " Proxy alloc failed!!\n"); | ||
171 | } | ||
172 | |||
173 | if(UDMA_SOK == retVal) | ||
174 | { | ||
175 | /* Deinit with a resource not-freed */ | ||
176 | retVal = Udma_deinit(drvHandle); | ||
177 | if(UDMA_SOK == retVal) | ||
178 | { | ||
179 | GT_0trace(taskObj->traceMask, GT_ERR, | ||
180 | " UDMA passed when it should have failed!!\n"); | ||
181 | } | ||
182 | else | ||
183 | { | ||
184 | retVal = Udma_proxyFree(proxyHandle); | ||
185 | if(UDMA_SOK != retVal) | ||
186 | { | ||
187 | GT_0trace(taskObj->traceMask, GT_ERR, | ||
188 | " Proxy free failed!!\n"); | ||
189 | } | ||
190 | } | ||
191 | } | ||
192 | |||
193 | if(UDMA_SOK != retVal) | ||
194 | { | ||
195 | break; | ||
196 | } | ||
197 | } | ||
198 | |||
199 | /* This deinit should pass */ | ||
200 | retVal += udmaTestDeinitDriver(taskObj->testObj); | ||
201 | if(UDMA_SOK != retVal) | ||
202 | { | ||
203 | GT_0trace(taskObj->traceMask, GT_ERR, " UDMA deinit failed!!\n"); | ||
204 | } | ||
205 | } | ||
206 | |||
207 | /* Init before ending the testcase */ | ||
208 | retVal = udmaTestInitDriver(taskObj->testObj); | ||
209 | if(UDMA_SOK != retVal) | ||
210 | { | ||
211 | GT_0trace(taskObj->traceMask, GT_ERR, " UDMA re-init failed!!\n"); | ||
212 | } | ||
213 | } | ||
214 | |||
215 | return (retVal); | ||
216 | } | ||
diff --git a/unit_test/udma_ut/src/udma_testcases.h b/unit_test/udma_ut/src/udma_testcases.h index 57edf52..ea7a2fc 100644 --- a/unit_test/udma_ut/src/udma_testcases.h +++ b/unit_test/udma_ut/src/udma_testcases.h | |||
@@ -2790,6 +2790,43 @@ static UdmaTestParams gUdmaTestCases[] = | |||
2790 | .runFlag = (UDMA_TEST_RF_MCU_BC_HC_MT), | 2790 | .runFlag = (UDMA_TEST_RF_MCU_BC_HC_MT), |
2791 | .ringPrmId = UDMA_TEST_RING_PRMID_INVALID, | 2791 | .ringPrmId = UDMA_TEST_RING_PRMID_INVALID, |
2792 | }, | 2792 | }, |
2793 | { | ||
2794 | .enableTest = TEST_ENABLE, | ||
2795 | .tcId = 4656U, | ||
2796 | .tcName = "PDK-4654 bug testcase: UDMA deinit resource check", | ||
2797 | .disableInfo= NULL, | ||
2798 | .printEnable= PRINT_ENABLE, | ||
2799 | .prfEnable = PRF_DISABLE, | ||
2800 | .tcType = (UDMA_TCT_FULL | UDMA_TCT_NEGATIVE), | ||
2801 | .dcEnable = DATA_CHECK_ENABLE, | ||
2802 | .loopCnt = USE_DEF_LP_CNT, | ||
2803 | .numTasks = 1U, | ||
2804 | .testType = {UDMA_TT_BLK_CPY}, | ||
2805 | .testFxnPtr = {&udmaTestBugTcPDK_4654}, | ||
2806 | .pacingTime = {PACING_NONE}, | ||
2807 | .numCh = {1U}, | ||
2808 | .instId = {UDMA_TEST_DEFAULT_UDMA_INST}, | ||
2809 | .chPrmId = {UDMA_TEST_CH_PRMID_DEF}, | ||
2810 | .qdepth = {USE_DEF_QDEPTH}, | ||
2811 | .icnt = { | ||
2812 | {UDMA_TEST_DEF_ICNT0, 1U, 1U, 1U} | ||
2813 | }, | ||
2814 | .dicnt = { | ||
2815 | {UDMA_TEST_DEF_DICNT0, 1U, 1U, 1U} | ||
2816 | }, | ||
2817 | .dim = { | ||
2818 | {0U, 0U, 0U} | ||
2819 | }, | ||
2820 | .ddim = { | ||
2821 | {0U, 0U, 0U} | ||
2822 | }, | ||
2823 | .heapIdSrc = {DEF_HEAP_ID}, | ||
2824 | .heapIdDest = {DEF_HEAP_ID}, | ||
2825 | .srcBufSize = {UDMA_TEST_DEF_ICNT0}, | ||
2826 | .destBufSize= {UDMA_TEST_DEF_DICNT0}, | ||
2827 | .runFlag = (UDMA_TEST_RF_SOC_ALL | UDMA_TEST_RF_CORE_ALL | UDMA_TEST_RF_CFG_ALL), | ||
2828 | .ringPrmId = UDMA_TEST_RING_PRMID_INVALID, | ||
2829 | }, | ||
2793 | }; | 2830 | }; |
2794 | 2831 | ||
2795 | #ifdef __cplusplus | 2832 | #ifdef __cplusplus |