summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorSivaraj R2019-09-24 21:30:35 -0500
committerSivaraj R2019-09-25 00:28:10 -0500
commit002c86cec5f9ff61cf321f542e1718980177c82f (patch)
tree09f3dc578024a8268e85e4fac9a5be94dafc21f0
parent4a68d7e8e427df2840bee47c3fb060b08e33f7b4 (diff)
downloadudma-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.c12
-rw-r--r--src/udma_priv.h1
-rw-r--r--src/udma_rm.c138
-rw-r--r--udma.h4
-rw-r--r--unit_test/udma_ut/src/udma_test.h1
-rw-r--r--unit_test/udma_ut/src/udma_test_bug.c87
-rw-r--r--unit_test/udma_ut/src/udma_testcases.h37
7 files changed, 275 insertions, 5 deletions
diff --git a/src/udma.c b/src/udma.c
index 1831505..392ce94 100644
--- a/src/udma.c
+++ b/src/udma.c
@@ -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 */
105int32_t Udma_rmInit(Udma_DrvHandle drvHandle); 105int32_t Udma_rmInit(Udma_DrvHandle drvHandle);
106int32_t Udma_rmDeinit(Udma_DrvHandle drvHandle);
106/* Channel RM APIs */ 107/* Channel RM APIs */
107uint32_t Udma_rmAllocBlkCopyCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle); 108uint32_t Udma_rmAllocBlkCopyCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle);
108void Udma_rmFreeBlkCopyCh(uint32_t chNum, Udma_DrvHandle drvHandle); 109void 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 */ 63static 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
238int32_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
235uint32_t Udma_rmAllocBlkCopyCh(uint32_t preferredChNum, Udma_DrvHandle drvHandle) 336uint32_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
1563static 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}
diff --git a/udma.h b/udma.h
index fb242f2..1f0008a 100644
--- a/udma.h
+++ b/udma.h
@@ -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 */
616int32_t udmaTestBugTcPDK_3863(UdmaTestTaskObj *taskObj); 616int32_t udmaTestBugTcPDK_3863(UdmaTestTaskObj *taskObj);
617int32_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
133int32_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