/** This is the function to write data to PCAP interface
*
* @param WrSize: Number of 32bit words that the DMA should write to
* the PCAP interface
* @param WrAddr: Linear memory space from where CSUDMA will read
* the data to be written to PCAP interface
*
* @return None
*
*****************************************************************************/
u32 XFsbl_WriteToPcap(u32 WrSize, u8 *WrAddr) {
u32 RegVal;
u32 Status = XFSBL_SUCCESS;
/*
* Setup the SSS, setup the PCAP to receive from DMA source
*/
RegVal = XFsbl_In32(CSU_CSU_SSS_CFG) & CSU_CSU_SSS_CFG_PCAP_SSS_MASK;
RegVal = RegVal
| (XFSBL_CSU_SSS_SRC_SRC_DMA << CSU_CSU_SSS_CFG_PCAP_SSS_SHIFT);
XFsbl_Out32(CSU_CSU_SSS_CFG, RegVal);
/* Setup the source DMA channel */
XCsuDma_Transfer(&CsuDma, XCSUDMA_SRC_CHANNEL, (PTRSIZE) WrAddr, WrSize, 0);
/* wait for the SRC_DMA to complete and the pcap to be IDLE */
XCsuDma_WaitForDone(&CsuDma, XCSUDMA_SRC_CHANNEL);
/* Acknowledge the transfer has completed */
XCsuDma_IntrClear(&CsuDma, XCSUDMA_SRC_CHANNEL, XCSUDMA_IXR_DONE_MASK);
XFsbl_Printf(DEBUG_GENERAL, "DMA transfer done \r\n");
Status = XFsbl_PcapWaitForDone();
if (Status != XFSBL_SUCCESS) {
goto END;
}
END: return Status;
}
/**
*
* Sending the last data and padding when blocksize is not multiple of 104
* bytes
*
* @param InstancePtr is a pointer to the XSecure_Sha3 instance.
* @param Hash is the pointer to location where resulting hash will be
* written
*
* @return None
*
* @note None
*
*****************************************************************************/
void XSecure_Sha3Finish(XSecure_Sha3 *InstancePtr, u8 *Hash)
{
/* Asserts validate the input arguments */
Xil_AssertVoid(InstancePtr != NULL);
Xil_AssertVoid(Hash != NULL);
u32 *HashPtr = (u32 *)Hash;
u32 PartialLen = InstancePtr->Sha3Len % XSECURE_SHA3_BLOCK_LEN;
u8 XSecure_RsaSha3Array[512] = {0U};
PartialLen = (PartialLen == 0U)?(XSECURE_SHA3_BLOCK_LEN) :
(XSECURE_SHA3_BLOCK_LEN - PartialLen);
XSecure_Sha3Padd(InstancePtr, XSecure_RsaSha3Array, PartialLen);
XCsuDma_Transfer(InstancePtr->CsuDmaPtr, XCSUDMA_SRC_CHANNEL,
(UINTPTR)XSecure_RsaSha3Array, PartialLen/4, 1);
/* Check the SHA3 DONE bit. */
XSecure_Sha3WaitForDone(InstancePtr);
/* If requested, read out the Hash in reverse order. */
if (Hash)
{
u32 Index = 0U;
u32 Val = 0U;
for (Index=0U; Index < 12U; Index++)
{
Val = XSecure_ReadReg(InstancePtr->BaseAddress,
XSECURE_CSU_SHA3_DIGEST_0_OFFSET + (Index * 4));
HashPtr[11U - Index] = Val;
}
}
}
/******************************************************************************
*
* This function is used to copy data to AES/PL.
*
* @param InstancePtr is an instance of CSUDMA
* @param Src holds the source Address
* @param Size of the data
* @param EnLast - 0 or 1
*
* @return None
*
* @note None
*
******************************************************************************/
static void XFsbl_DmaPlCopy(XCsuDma *InstancePtr, UINTPTR Src, u32 Size,
u8 EnLast)
{
/* Data transfer */
XCsuDma_Transfer(InstancePtr, XCSUDMA_SRC_CHANNEL, (UINTPTR)Src,
Size, EnLast);
/* Polling for transfer to be done */
XCsuDma_WaitForDone(InstancePtr, XCSUDMA_SRC_CHANNEL);
/* To acknowledge the transfer has completed */
XCsuDma_IntrClear(InstancePtr, XCSUDMA_SRC_CHANNEL,
XCSUDMA_IXR_DONE_MASK);
}
/**
*
* Update hash for new input data block
*
* @param InstancePtr is a pointer to the XSecure_Sha3 instance.
* @param Data is the pointer to the input data for hashing
* @param Size of the input data in bytes
*
* @return None
*
* @note None
*
******************************************************************************/
void XSecure_Sha3Update(XSecure_Sha3 *InstancePtr, const u8 *Data,
const u32 Size)
{
/* Asserts validate the input arguments */
Xil_AssertVoid(InstancePtr != NULL);
Xil_AssertVoid(Size != (u32)0x00U);
InstancePtr->Sha3Len += Size;
XCsuDma_Transfer(InstancePtr->CsuDmaPtr, XCSUDMA_SRC_CHANNEL,
(UINTPTR)Data, (u32)Size/4, 0);
/* Checking the CSU DMA done bit should be enough. */
XCsuDma_WaitForDone(InstancePtr->CsuDmaPtr, XCSUDMA_SRC_CHANNEL);
/* Acknowledge the transfer has completed */
XCsuDma_IntrClear(InstancePtr->CsuDmaPtr, XCSUDMA_SRC_CHANNEL,
XCSUDMA_IXR_DONE_MASK);
}
/**
*
* This function performs data transfer in loop back mode in polled mode
* and verify the data.
*
* @param DeviceId is the XPAR_<CSUDMA Instance>_DEVICE_ID value from
* xparameters.h.
*
* @return
* - XST_SUCCESS if successful.
* - XST_FAILURE if failed.
*
* @note None.
*
******************************************************************************/
int XCsuDma_PolledExample(u16 DeviceId)
{
int Status;
XCsuDma_Config *Config;
u32 Index = 0;
u32 *SrcPtr = (u32 *)SRC_ADDR;
u32 *DstPtr = (u32 *)DST_ADDR;
u32 Test_Data = 0xABCD1234;
u32 *Ptr = (u32 *)SRC_ADDR;
u32 EnLast = 0;
/*
* Initialize the CsuDma driver so that it's ready to use
* look up the configuration in the config table,
* then initialize it.
*/
Config = XCsuDma_LookupConfig(DeviceId);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XCsuDma_CfgInitialize(&CsuDma, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Performs the self-test to check hardware build.
*/
Status = XCsuDma_SelfTest(&CsuDma);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setting CSU_DMA in loop back mode.
*/
Xil_Out32(XCSU_BASEADDRESS + CSU_SSS_CONFIG_OFFSET,
((Xil_In32(XCSU_BASEADDRESS + CSU_SSS_CONFIG_OFFSET) & 0xF0000) |
CSUDMA_LOOPBACK_CFG));
/* Data writing at source address location */
for(Index = 0; Index < SIZE; Index++)
{
*Ptr = Test_Data;
Test_Data += 0x1;
Ptr++;
}
/* Data transfer in loop back mode */
XCsuDma_Transfer(&CsuDma, XCSUDMA_DST_CHANNEL, DST_ADDR, SIZE, EnLast);
XCsuDma_Transfer(&CsuDma, XCSUDMA_SRC_CHANNEL, SRC_ADDR, SIZE, EnLast);
/* Polling for transfer to be done */
XCsuDma_WaitForDone(&CsuDma, XCSUDMA_DST_CHANNEL);
/* To acknowledge the transfer has completed */
XCsuDma_IntrClear(&CsuDma, XCSUDMA_SRC_CHANNEL, XCSUDMA_IXR_DONE_MASK);
XCsuDma_IntrClear(&CsuDma, XCSUDMA_DST_CHANNEL, XCSUDMA_IXR_DONE_MASK);
/*
* Verifying data of transfered by comparing data at source
* and address locations.
*/
for (Index = 0; Index < SIZE; Index++) {
if (*SrcPtr != *DstPtr) {
return XST_FAILURE;
}
else {
SrcPtr++;
DstPtr++;
}
}
return XST_SUCCESS;
}
/**
*
* This function performs data transfer in loop back mode in interrupt mode
* and verify the data.
*
* @param DeviceId is the XPAR_<CSUDMA Instance>_DEVICE_ID value from
* xparameters.h.
*
* @return
* - XST_SUCCESS if successful.
* - XST_FAILURE if failed.
*
* @note None.
*
******************************************************************************/
int XCsuDma_IntrExample(u16 DeviceId)
{
int Status;
XCsuDma_Config *Config;
u32 Index = 0;
u32 *SrcPtr = (u32 *)SRC_ADDR;
u32 *DstPtr = (u32 *)DST_ADDR;
u32 Test_Data = 0xABCD1234;
u32 *Ptr = (u32 *)SRC_ADDR;
u32 EnLast = 0;
/*
* Initialize the CsuDma driver so that it's ready to use
* look up the configuration in the config table,
* then initialize it.
*/
Config = XCsuDma_LookupConfig(DeviceId);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XCsuDma_CfgInitialize(&CsuDma, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Performs the self-test to check hardware build.
*/
Status = XCsuDma_SelfTest(&CsuDma);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect to the interrupt controller.
*/
Status = SetupInterruptSystem(&Intc, &CsuDma,
INTG_CSUDMA_INTR_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/* Enable interrupts */
XCsuDma_EnableIntr(&CsuDma, XCSUDMA_DST_CHANNEL,
XCSUDMA_IXR_DONE_MASK);
/*
* Setting CSU_DMA in loop back mode.
*/
Xil_Out32(XCSU_BASEADDRESS + CSU_SSS_CONFIG_OFFSET,
(Xil_In32(XCSU_BASEADDRESS + CSU_SSS_CONFIG_OFFSET) |
CSUDMA_LOOPBACK_CFG));
/* Data writing at source address location */
for(Index = 0; Index < SIZE; Index++)
{
*Ptr = Test_Data;
Test_Data += 0x1;
Ptr++;
}
/* Data transfer in loop back mode */
XCsuDma_Transfer(&CsuDma, XCSUDMA_DST_CHANNEL, DST_ADDR, SIZE, EnLast);
XCsuDma_Transfer(&CsuDma, XCSUDMA_SRC_CHANNEL, SRC_ADDR, SIZE, EnLast);
/* Wait for generation of destination work is done */
while(DstDone == 0);
/* Disable interrupts */
XCsuDma_DisableIntr(&CsuDma, XCSUDMA_DST_CHANNEL,
XCSUDMA_IXR_DONE_MASK);
/* To acknowledge the transfer has completed */
XCsuDma_IntrClear(&CsuDma, XCSUDMA_SRC_CHANNEL, XCSUDMA_IXR_DONE_MASK);
XCsuDma_IntrClear(&CsuDma, XCSUDMA_DST_CHANNEL, XCSUDMA_IXR_DONE_MASK);
/*
* Verifying data of transfered by comparing data at
* source and address locations.
*/
for (Index = 0; Index < SIZE; Index++) {
if (*SrcPtr != *DstPtr) {
return XST_FAILURE;
}
else {
SrcPtr++;
DstPtr++;
}
}
return XST_SUCCESS;
}
