summary | shortlog | log | commit | commitdiff | tree
raw | patch | inline | side by side (parent: c39c4b1)
raw | patch | inline | side by side (parent: c39c4b1)
author | Don Dominic <a0486429@ti.com> | |
Fri, 4 Dec 2020 11:05:56 +0000 (16:35 +0530) | ||
committer | Sivaraj R <sivaraj@ti.com> | |
Fri, 4 Dec 2020 11:33:21 +0000 (05:33 -0600) |
- Updated the TC "PDK-3726 - Ring attach and detach testcase"
- Tests various PKTDMA mapped ring groups too
- Along with minor updates in:
- Mapped Flow Attach Test case:
- Added more prints
- Renamed/Updated API to get mappedChNum
- udma_rm.c for Mapped Ring allocate
- Added check for numFreRings for the mapped channel
- added assert
Signed-off-by: Don Dominic <a0486429@ti.com>
- Tests various PKTDMA mapped ring groups too
- Along with minor updates in:
- Mapped Flow Attach Test case:
- Added more prints
- Renamed/Updated API to get mappedChNum
- udma_rm.c for Mapped Ring allocate
- Added check for numFreRings for the mapped channel
- added assert
Signed-off-by: Don Dominic <a0486429@ti.com>
index cb4763398e5702df29ce8fa0a30c7ff2f2619f71..3295860b24eb296f59e20bbac549ee98e451e323 100755 (executable)
retVal = Udma_getMappedChRingAttributes(drvHandle, mappedRingGrp, mappedChNum, &chAttr);
- if(UDMA_SOK == retVal)
+ if((UDMA_SOK == retVal) && (0U != chAttr.numFreeRing))
{
/* Derive the intersecting pool (loopStart and loopMax) based on the rings reserved for the core (rmcfg)
* and the permissible range for the given channel(free rings reserved for specific channels).
/* Update loopMax to stop at Channel_ring_End,
* so as to skip the last rings which are reserved for the core,
* but can't be used for the current channel */
+ Udma_assert(drvHandle, (chAttr.startFreeRing + chAttr.numFreeRing) >= rmInitPrms->startMappedRing[mappedRingGrp]);
loopMax = (chAttr.startFreeRing + chAttr.numFreeRing) - rmInitPrms->startMappedRing[mappedRingGrp];
}
/* For all other CASE 'B's, loopMax should be rmInitPrms->numMappedRing[mappedRingGrp] itself. */
diff --git a/packages/ti/drv/udma/unit_test/udma_ut/src/soc/am64x/udma_test_soc.c b/packages/ti/drv/udma/unit_test/udma_ut/src/soc/am64x/udma_test_soc.c
index f25b600431c297e9f37c0ff2be19784ce4f567fa..84960f0d4eecde0511be3ce506f28b547e77c50a 100644 (file)
return (retVal);
}
-uint32_t udmaTestGetMappedFlowChNum(Udma_DrvHandle drvHandle, uint32_t mappedFlowGrp, uint32_t mappedFlowNum)
+uint32_t udmaTestGetMappedRingChNum(Udma_DrvHandle drvHandle, uint32_t mappedRingGrp, uint32_t mappedRingNum)
{
int32_t retVal = UDMA_SOK;
Udma_MappedChRingAttributes chAttr;
- uint32_t mappedChNum = 0U;
+ uint32_t mappedChNum = 0U, mappedeChNumStart, mappedChNumMax;
- for(mappedChNum = CSL_DMSS_PKTDMA_RX_CHANS_CPSW_START; mappedChNum < CSL_DMSS_PKTDMA_NUM_RX_CHANS; mappedChNum++)
+ if(mappedRingGrp < UDMA_NUM_MAPPED_TX_GROUP) /* Mapped TX Channel */
{
- retVal = Udma_getMappedChRingAttributes(drvHandle, mappedFlowGrp, mappedChNum, &chAttr);
+ mappedeChNumStart = CSL_DMSS_PKTDMA_TX_CHANS_CPSW_START;
+ mappedChNumMax = CSL_DMSS_PKTDMA_NUM_TX_CHANS;
+ }
+ else /* Mapped RX Channel */
+ {
+ mappedeChNumStart = CSL_DMSS_PKTDMA_RX_CHANS_CPSW_START;
+ mappedChNumMax = CSL_DMSS_PKTDMA_NUM_RX_CHANS;
+ }
+
+ for(mappedChNum = mappedeChNumStart; mappedChNum < mappedChNumMax; mappedChNum++)
+ {
+ retVal = Udma_getMappedChRingAttributes(drvHandle, mappedRingGrp, mappedChNum, &chAttr);
if(UDMA_SOK == retVal)
{
- if((chAttr.defaultRing == mappedFlowNum) ||
- ((mappedFlowNum >= chAttr.startFreeRing) &&
- (mappedFlowNum < chAttr.startFreeRing + chAttr.numFreeRing)))
+ if((chAttr.defaultRing == mappedRingNum) ||
+ ((mappedRingNum >= chAttr.startFreeRing) &&
+ (mappedRingNum < chAttr.startFreeRing + chAttr.numFreeRing)))
{
break;
}
diff --git a/packages/ti/drv/udma/unit_test/udma_ut/src/soc/am64x/udma_test_soc.h b/packages/ti/drv/udma/unit_test/udma_ut/src/soc/am64x/udma_test_soc.h
index a8a15ebd168d37c5df7e4a690fea26da55fb1d69..dea2a7641349249f9c5133858f7132e2303fec4c 100644 (file)
/* Function Declarations */
/* ========================================================================== */
-uint32_t udmaTestGetMappedFlowChNum(Udma_DrvHandle drvHandle, uint32_t mappedFlowGrp, uint32_t mappedFlowNum);
+uint32_t udmaTestGetMappedRingChNum(Udma_DrvHandle drvHandle, uint32_t mappedRingGrp, uint32_t mappedRingNum);
#ifdef __cplusplus
}
diff --git a/packages/ti/drv/udma/unit_test/udma_ut/src/udma_test_flow.c b/packages/ti/drv/udma/unit_test/udma_ut/src/udma_test_flow.c
index 3763e844a72ae7df58c263f4ba4fa3c7e8303938..2208e1bf0642a6b200654c0ad57fa75fca8d0923 100644 (file)
Udma_FlowPrms flowPrms;
Udma_FlowAllocMappedPrms flowAllocMappedPrms;
Udma_RmInitPrms *rmInitPrms;
+ char *mappedFlowGrpStr[] = { "CPSW RX", "SAUL RX", "ICSSG0 RX", "ICSSG1_RX"};
if(UDMA_SOK == retVal)
{
for(mappedFlowGrp = UDMA_NUM_MAPPED_TX_GROUP; mappedFlowGrp < numMappedFlowGrp; mappedFlowGrp++)
{
+
+ GT_1trace(taskObj->traceMask, GT_INFO1,
+ " Testing for PKTDMA Mapped Flow Group : %s ...\r\n",
+ mappedFlowGrpStr[mappedFlowGrp - UDMA_NUM_MAPPED_TX_GROUP]);
+
rmInitPrms = &drvHandle->initPrms.rmInitPrms;
if(0U == rmInitPrms->numMappedRing[mappedFlowGrp])
{
- /* Skip the test since, no rings are reserved for the core */
+ GT_1trace(taskObj->traceMask, GT_INFO1,
+ " Skipping the Test for PKTDMA Mapped Flow Group : %s , since no rings are reserved!!\r\n",
+ mappedFlowGrpStr[mappedFlowGrp - UDMA_NUM_MAPPED_TX_GROUP]);
continue;
}
/* Allocate mapped free flows */
flowAllocMappedPrms.mappedFlowGrp = mappedFlowGrp;
- flowAllocMappedPrms.mappedChNum = udmaTestGetMappedFlowChNum(drvHandle, mappedFlowGrp, rmInitPrms->startMappedRing[mappedFlowGrp]);
+ flowAllocMappedPrms.mappedChNum = udmaTestGetMappedRingChNum(drvHandle, mappedFlowGrp, rmInitPrms->startMappedRing[mappedFlowGrp]);
retVal = Udma_flowAllocMapped(drvHandle, flowHandle, &flowAllocMappedPrms);
if(UDMA_SOK != retVal)
{
mappedFlowAllocated = FALSE;
}
}
+
+ if(UDMA_SOK == retVal)
+ {
+ GT_1trace(taskObj->traceMask, GT_INFO1,
+ " Testing for PKTDMA Mapped Flow Group : %s passed!!\r\n",
+ mappedFlowGrpStr[mappedFlowGrp - UDMA_NUM_MAPPED_TX_GROUP]);
+ }
+ else
+ {
+ break;
+ }
}
}
#endif
diff --git a/packages/ti/drv/udma/unit_test/udma_ut/src/udma_test_ring.c b/packages/ti/drv/udma/unit_test/udma_ut/src/udma_test_ring.c
index 8d24f93c1ae639dbcd195ce92a7b4dbcb8439631..1d4168d5f4aaecb856d8111ecfff289db6216e7c 100755 (executable)
uint32_t instId, qCnt, ringMode;
uint32_t elemCnt = 100U, ringMemSize;
uint32_t heapId = UTILS_MEM_HEAP_ID_MSMC;
+ uint32_t numMappedRingGrp, ringGrp, mappedRingGrp = 0U;
Udma_DrvHandle drvHandle;
Udma_RingPrms ringPrms;
struct Udma_RingObj ringObj, attachRingObj;
void *ringMem = NULL;
uint64_t ringData;
Udma_RmInitPrms *rmInitPrms;
- char *instanceIdStr[] = {"MAIN", "MCU", "BCDMA", "PKTDMA"};
- char *ringModeString[] = {"RING", "MESSAGE"};
+ char *instanceIdStr[] = {"MAIN", "MCU", "BCDMA", "PKTDMA"};
+ char *mappedRingGrpStr[] = { "CPSW TX", "SAUL TX", "ICSSG0 TX", "ICSSG1_TX",
+ "CPSW RX", "SAUL RX", "ICSSG0 RX", "ICSSG1_RX"};
+ char *ringModeString[] = {"RING", "MESSAGE"};
+#if ((UDMA_NUM_MAPPED_TX_GROUP + UDMA_NUM_MAPPED_RX_GROUP) > 0)
+ Udma_MappedChRingAttributes chAttr;
+#endif
ringMemSize = elemCnt * sizeof (uint64_t);
ringMem = Utils_memAlloc(heapId, ringMemSize, UDMA_CACHELINE_ALIGNMENT);
" Testing for Inst: %s, Ring Mode: %s...\r\n",
instanceIdStr[instId], ringModeString[ringMode]);
drvHandle = &taskObj->testObj->drvObj[instId];
-
- UdmaRingPrms_init(&ringPrms);
- ringPrms.ringMem = ringMem;
- ringPrms.ringMemSize = ringMemSize;
- ringPrms.mode = ringMode;
- ringPrms.elemCnt = elemCnt;
- if(UDMA_INST_TYPE_NORMAL != drvHandle->instType)
+
+#if ((UDMA_NUM_MAPPED_TX_GROUP + UDMA_NUM_MAPPED_RX_GROUP) > 0)
+ if(UDMA_INST_ID_PKTDMA_0 == instId)
{
- /* Since no free/extra rings are available in BCDMA/PKTDMA(Unmapped Channels)
- #Udma_ringAlloc with #UDMA_RING_ANY will fail.
- So get the default ringNum for a channel */
- rmInitPrms = &drvHandle->initPrms.rmInitPrms;
- ringNum = (uint16_t) (rmInitPrms->startTxCh + drvHandle->txChOffset);
+ numMappedRingGrp = UDMA_NUM_MAPPED_TX_GROUP + UDMA_NUM_MAPPED_RX_GROUP;
}
else
+#endif
{
- ringNum = UDMA_RING_ANY;
+ numMappedRingGrp = 0U;
}
- /* Allocate ring */
- retVal = Udma_ringAlloc(drvHandle, ringHandle, ringNum, &ringPrms);
- if(UDMA_SOK != retVal)
+
+ for(ringGrp = 0U; ringGrp <= numMappedRingGrp; ringGrp++)
{
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring alloc failed!!\n");
- break;
- }
+ ringNum = UDMA_RING_ANY;
- /* Attach to the allocated ring */
- ringNum = Udma_ringGetNum(ringHandle);
- retVal = Udma_ringAttach(drvHandle, attachRingHandle, ringNum);
- if(UDMA_SOK != retVal)
- {
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring attach failed!!\n");
- break;
- }
+ rmInitPrms = &drvHandle->initPrms.rmInitPrms;
- /* Queue and check ring operation through attach handle */
- for(qCnt = 0U; qCnt < elemCnt; qCnt++)
- {
- ringData = ((uint64_t) qCnt | (uint64_t) 0xDEADBEEF00000000UL);
- retVal = Udma_ringQueueRaw(attachRingHandle, ringData);
+ UdmaRingPrms_init(&ringPrms);
+ ringPrms.ringMem = ringMem;
+ ringPrms.ringMemSize = ringMemSize;
+ ringPrms.mode = ringMode;
+ ringPrms.elemCnt = elemCnt;
+
+#if ((UDMA_NUM_MAPPED_TX_GROUP + UDMA_NUM_MAPPED_RX_GROUP) > 0)
+ if(ringGrp != 0U)
+ {
+ mappedRingGrp = ringGrp - 1U;
+
+ GT_1trace(taskObj->traceMask, GT_INFO1,
+ " Testing for PKTDMA Mapped Ring Group : %s ...\r\n",
+ mappedRingGrpStr[mappedRingGrp]);
+
+
+ if(0U == rmInitPrms->numMappedRing[mappedRingGrp])
+ {
+ GT_1trace(taskObj->traceMask, GT_INFO1,
+ " Skipping the Test for PKTDMA Mapped Ring Group : %s , since no rings are reserved!!\r\n",
+ mappedRingGrpStr[mappedRingGrp]);
+ continue;
+ }
+
+ ringPrms.mappedRingGrp = mappedRingGrp;
+ ringPrms.mappedChNum = udmaTestGetMappedRingChNum(drvHandle, mappedRingGrp, rmInitPrms->startMappedRing[mappedRingGrp]);
+ Udma_getMappedChRingAttributes(drvHandle, mappedRingGrp, ringPrms.mappedChNum, &chAttr);
+ if(0U == chAttr.numFreeRing)
+ {
+ /* When no free mapped rings are avilable for PKTDMA Mapped Channels,
+ * #Udma_ringAlloc with #UDMA_RING_ANY will fail.
+ * So use the default ring for that mapped channel */
+ ringNum = chAttr.defaultRing;
+ }
+ }
+#endif
+ if((UDMA_INST_TYPE_NORMAL != drvHandle->instType) && (ringGrp == 0U))
+ {
+ /* Since no free/extra rings are available in BCDMA/PKTDMA-Unmapped Channels,
+ * #Udma_ringAlloc with #UDMA_RING_ANY will fail.
+ * So get the default ringNum for a channel */
+ ringNum = (uint16_t) (rmInitPrms->startTxCh + drvHandle->txChOffset);
+ }
+
+ /* Allocate ring */
+ retVal = Udma_ringAlloc(drvHandle, ringHandle, ringNum, &ringPrms);
if(UDMA_SOK != retVal)
{
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring queue failed!!\n");
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring alloc failed!!\n");
break;
}
- }
- if(UDMA_SOK != retVal)
- {
- break;
- }
- /* Check if the HW occupancy is same as what is queued */
- if(udmaTestCompareRingHwOccDriver(attachRingHandle, elemCnt, UDMA_TEST_RING_ACC_DIRECTION_FORWARD) != UDMA_SOK)
- {
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring element count mismatch!!\n");
- retVal = UDMA_EFAIL;
- break;
- }
+ /* Attach to the allocated ring */
+ ringNum = Udma_ringGetNum(ringHandle);
+ retVal = Udma_ringAttach(drvHandle, attachRingHandle, ringNum);
+ if(UDMA_SOK != retVal)
+ {
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring attach failed!!\n");
+ break;
+ }
- /* Dequeue and flush the ring */
- for(qCnt = 0U; qCnt < elemCnt; qCnt++)
- {
- ringData = 0UL;
- if(UDMA_INST_TYPE_NORMAL == drvHandle->instType)
+ /* Queue and check ring operation through attach handle */
+ for(qCnt = 0U; qCnt < elemCnt; qCnt++)
+ {
+ ringData = ((uint64_t) qCnt | (uint64_t) 0xDEADBEEF00000000UL);
+ retVal = Udma_ringQueueRaw(attachRingHandle, ringData);
+ if(UDMA_SOK != retVal)
+ {
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring queue failed!!\n");
+ break;
+ }
+ }
+ if(UDMA_SOK != retVal)
{
- retVal = Udma_ringDequeueRaw(attachRingHandle, &ringData);
+ break;
}
- else
+
+ /* Check if the HW occupancy is same as what is queued */
+ if(udmaTestCompareRingHwOccDriver(attachRingHandle, elemCnt, UDMA_TEST_RING_ACC_DIRECTION_FORWARD) != UDMA_SOK)
{
- /* In case of LCDMA, #Udma_ringDequeueRaw will dequeue from the
- * reverse direction in Dual ring. So it can't be used to dequeue the
- * descriptors in the forward direction. In this casse use #Udma_ringFlushRaw */
- retVal = Udma_ringFlushRaw(attachRingHandle, &ringData);
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring element count mismatch!!\n");
+ retVal = UDMA_EFAIL;
+ break;
+ }
+
+ /* Dequeue and flush the ring */
+ for(qCnt = 0U; qCnt < elemCnt; qCnt++)
+ {
+ ringData = 0UL;
+ if(UDMA_INST_TYPE_NORMAL == drvHandle->instType)
+ {
+ retVal = Udma_ringDequeueRaw(attachRingHandle, &ringData);
+ }
+ else
+ {
+ /* In case of LCDMA, #Udma_ringDequeueRaw will dequeue from the
+ * reverse direction in Dual ring. So it can't be used to dequeue the
+ * descriptors in the forward direction. In this casse use #Udma_ringFlushRaw */
+ retVal = Udma_ringFlushRaw(attachRingHandle, &ringData);
+ }
+ if(UDMA_SOK != retVal)
+ {
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring dequeue failed!!\n");
+ break;
+ }
+
+ if(ringData != ((uint64_t) qCnt | (uint64_t) 0xDEADBEEF00000000UL))
+ {
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring data mismatch!!\n");
+ break;
+ }
}
if(UDMA_SOK != retVal)
{
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring dequeue failed!!\n");
break;
}
- if(ringData != ((uint64_t) qCnt | (uint64_t) 0xDEADBEEF00000000UL))
+ /* Check if the HW occupancy is zero */
+ if(udmaTestCompareRingHwOccDriver(attachRingHandle, 0U, UDMA_TEST_RING_ACC_DIRECTION_FORWARD) != UDMA_SOK)
{
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring data mismatch!!\n");
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring not empty!!\n");
+ retVal = UDMA_EFAIL;
break;
}
- }
- if(UDMA_SOK != retVal)
- {
- break;
- }
- /* Check if the HW occupancy is zero */
- if(udmaTestCompareRingHwOccDriver(attachRingHandle, 0U, UDMA_TEST_RING_ACC_DIRECTION_FORWARD) != UDMA_SOK)
- {
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring not empty!!\n");
- retVal = UDMA_EFAIL;
- break;
+ retVal = Udma_ringDetach(attachRingHandle);
+ if(UDMA_SOK != retVal)
+ {
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring detach failed!!\n");
+ break;
+ }
+
+ retVal = Udma_ringFree(ringHandle);
+ if(UDMA_SOK != retVal)
+ {
+ GT_0trace(taskObj->traceMask, GT_ERR, " Ring free failed!!\n");
+ break;
+ }
+
+ if(ringGrp != 0U)
+ {
+ GT_1trace(taskObj->traceMask, GT_INFO1,
+ " Testing for PKTDMA Mapped Ring Group : %s passed!!\r\n",
+ mappedRingGrpStr[mappedRingGrp]);
+ }
+
}
- retVal = Udma_ringDetach(attachRingHandle);
- if(UDMA_SOK != retVal)
+ if(UDMA_SOK == retVal)
{
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring detach failed!!\n");
- break;
+ GT_2trace(taskObj->traceMask, GT_INFO1,
+ " Testing for Inst: %s, Ring Mode: %s passed!!\r\n",
+ instanceIdStr[instId], ringModeString[ringMode]);
}
-
- retVal = Udma_ringFree(ringHandle);
- if(UDMA_SOK != retVal)
+ else
{
- GT_0trace(taskObj->traceMask, GT_ERR, " Ring free failed!!\n");
break;
}
-
- GT_2trace(taskObj->traceMask, GT_INFO1,
- " Testing for Inst: %s, Ring Mode: %s passed!!\r\n",
- instanceIdStr[instId], ringModeString[ringMode]);
}
if(UDMA_SOK != retVal)