Copyright � 1995-2014 Xilinx, Inc. All rights reserved.
+
+
diff --git a/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_linear_example.c b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_linear_example.c
new file mode 100644
index 00000000..74fe731e
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_linear_example.c
@@ -0,0 +1,375 @@
+/******************************************************************************
+*
+* Copyright (C) 2014 Xilinx, Inc. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* Use of the Software is limited solely to applications:
+* (a) running on a Xilinx device, or
+* (b) that interact with a Xilinx device through a bus or interconnect.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*
+* Except as contained in this notice, the name of the Xilinx shall not be used
+* in advertising or otherwise to promote the sale, use or other dealings in
+* this Software without prior written authorization from Xilinx.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file xzdma_linear_example.c
+*
+* This file contains the example using XZDma driver to do data transfer in
+* Linear mode on ZDMA device.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- -----------------------------------------------------
+* 1.0 vns 2/27/15 First release
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include "xzdma.h"
+#include "xparameters.h"
+#include "xscugic.h"
+
+/************************** Function Prototypes ******************************/
+
+int XZDma_LinearExample(u16 DeviceId);
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId);
+static void DoneHandler(void *CallBackRef);
+static void ErrorHandler(void *CallBackRef, u32 Mask);
+
+/************************** Constant Definitions ******************************/
+
+/*
+ * The following constants map to the XPAR parameters created in the
+ * xparameters.h file. They are defined here such that a user can easily
+ * change all the needed parameters in one place.
+ */
+#define ZDMA_DEVICE_ID XPAR_XZDMA_0_DEVICE_ID /* ZDMA device Id */
+#define ZDMA_INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID
+ /**< SCUGIC Device ID */
+#define ZDMA_INTR_DEVICE_ID XPAR_XADMAPS_0_INTR/**< ZDMA Interrupt Id */
+
+/**************************** Type Definitions *******************************/
+
+
+/************************** Variable Definitions *****************************/
+
+XZDma ZDma; /**_DEVICE_ID value from
+* xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful.
+* - XST_FAILURE if failed.
+*
+* @note None.
+*
+******************************************************************************/
+int XZDma_LinearExample(u16 DeviceId)
+{
+ int Status;
+ XZDma_Config *Config;
+ XZDma_DataConfig Configure; /**< Configuration values */
+ XZDma_Transfer Data[2];
+ u32 Value;
+ u32 Index;
+
+ /*
+ * Initialize the ZDMA driver so that it's ready to use.
+ * Look up the configuration in the config table,
+ * then initialize it.
+ */
+ Config = XZDma_LookupConfig(DeviceId);
+ if (NULL == Config) {
+ return XST_FAILURE;
+ }
+
+ Status = XZDma_CfgInitialize(&ZDma, Config, Config->BaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ /*
+ * Performs the self-test to check hardware build.
+ */
+ Status = XZDma_SelfTest(&ZDma);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* Filling the buffers for data transfer */
+ Value = 0x1230;
+ for (Index = 0; Index < 5; Index++) {
+ SrcBuf[Index] = Value++;
+ }
+ Value = 0x002345F;
+ for (Index = 0; Index < 5; Index++) {
+ Src1Buf[Index] = Value++;
+ }
+
+ /* ZDMA has set in simple transfer of Normal mode */
+ Status = XZDma_SetMode(&ZDma, TRUE, XZDMA_NORMAL_MODE);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* Allocated memory starting address should be 64 bit aligned */
+ XZDma_CreateBDList(&ZDma, XZDMA_LINEAR, (UINTPTR)AlloMem, 256);
+
+ /* Interrupt call back has been set */
+ XZDma_SetCallBack(&ZDma, XZDMA_HANDLER_DONE,
+ (void *)DoneHandler, &ZDma);
+ XZDma_SetCallBack(&ZDma, XZDMA_HANDLER_ERROR,
+ (void *)ErrorHandler, &ZDma);
+ /*
+ * Connect to the interrupt controller.
+ */
+ Status = SetupInterruptSystem(&Intc, &(ZDma),
+ ZDMA_INTR_DEVICE_ID);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* Configuration settings */
+ XZDma_GetChDataConfig(&ZDma, &Configure);
+ Configure.OverFetch = 0;
+ Configure.SrcIssue = 0x1F;
+ Configure.SrcBurstType = XZDMA_INCR_BURST;
+ Configure.SrcBurstLen = 0xF;
+ Configure.DstBurstType = XZDMA_INCR_BURST;
+ Configure.DstBurstLen = 0xF;
+ XZDma_SetChDataConfig(&ZDma, &Configure);
+
+ /* Enable required interrupts */
+ XZDma_EnableIntr(&ZDma, (XZDMA_IXR_DMA_DONE_MASK |
+ XZDMA_IXR_DMA_PAUSE_MASK));
+
+ /* Filling the data transfer elements */
+ Data[0].SrcAddr = (UINTPTR)SrcBuf;
+ Data[0].Size = 1000;
+ Data[0].DstAddr = (UINTPTR)DstBuf;
+ Data[0].SrcCoherent = 0;
+ Data[0].DstCoherent = 0;
+ Data[0].Pause = 1;
+
+ Data[1].SrcAddr = (UINTPTR)Src1Buf;
+ Data[1].Size = 1200;
+ Data[1].DstAddr = (UINTPTR)Dst1Buf;
+ Data[1].SrcCoherent = 0;
+ Data[1].DstCoherent = 0;
+ Data[1].Pause = 0;
+ /*
+ * Invalidating destination address and flushing
+ * source address in cache before the start of DMA data transfer.
+ */
+ Xil_DCacheFlushRange((INTPTR)Data[0].SrcAddr, Data[0].Size);
+ Xil_DCacheInvalidateRange((INTPTR)Data[0].DstAddr, Data[0].Size);
+ Xil_DCacheFlushRange((INTPTR)Data[1].SrcAddr, Data[1].Size);
+ Xil_DCacheInvalidateRange((INTPTR)Data[1].DstAddr, Data[1].Size);
+
+ XZDma_Start(&ZDma, Data, 2); /* Initiates the data transfer */
+
+ /* wait until pause interrupt is generated and has been resumed */
+ while (Pause == 0);
+
+ /* Resuming the ZDMA core */
+ XZDma_Resume(&ZDma);
+
+ while (Done == 0); /* Wait till DMA done interrupt generated */
+
+ /* Validating the data transfer */
+ for (Index = 0; Index < 250; Index++) {
+ if (SrcBuf[Index] != DstBuf[Index]) {
+ return XST_FAILURE;
+ }
+ }
+ for (Index = 0; Index < 300; Index++) {
+ if (Src1Buf[Index] != Dst1Buf[Index]) {
+ return XST_FAILURE;
+ }
+ }
+
+ return XST_SUCCESS;
+
+}
+
+/*****************************************************************************/
+/**
+* This function sets up the interrupt system so interrupts can occur for the
+* ZDMA. This function is application-specific. The user should modify this
+* function to fit the application.
+*
+* @param IntcInstancePtr is a pointer to the instance of the INTC.
+* @param InstancePtr contains a pointer to the instance of the ZDMA
+* driver which is going to be connected to the interrupt
+* controller.
+* @param IntrId is the interrupt Id and is typically
+* XPAR__INTR value from xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful
+* - XST_FAILURE if failed
+*
+* @note None.
+
+*
+****************************************************************************/
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId)
+{
+ int Status;
+
+#ifndef TESTAPP_GEN
+ XScuGic_Config *IntcConfig; /* Config for interrupt controller */
+
+ /*
+ * Initialize the interrupt controller driver
+ */
+ IntcConfig = XScuGic_LookupConfig(ZDMA_INTC_DEVICE_ID);
+ if (NULL == IntcConfig) {
+ return XST_FAILURE;
+ }
+
+ Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
+ IntcConfig->CpuBaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Connect the interrupt controller interrupt handler to the
+ * hardware interrupt handling logic in the processor.
+ */
+ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
+ (Xil_ExceptionHandler) XScuGic_InterruptHandler,
+ IntcInstancePtr);
+#endif
+
+ /*
+ * Connect a device driver handler that will be called when an
+ * interrupt for the device occurs, the device driver handler
+ * performs the specific interrupt processing for the device
+ */
+ Status = XScuGic_Connect(IntcInstancePtr, IntrId,
+ (Xil_ExceptionHandler) XZDma_IntrHandler,
+ (void *) InstancePtr);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Enable the interrupt for the device
+ */
+ XScuGic_Enable(IntcInstancePtr, IntrId);
+
+
+ /*
+ * Enable interrupts
+ */
+ Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
+
+
+ return XST_SUCCESS;
+}
+
+/*****************************************************************************/
+/**
+* This static function handles ZDMA Done interrupts.
+*
+* @param CallBackRef is the callback reference passed from the interrupt
+* handler, which in our case is a pointer to the driver instance.
+*
+* @return None.
+*
+* @note None.
+*
+******************************************************************************/
+static void DoneHandler(void *CallBackRef)
+{
+ Done = 1;
+
+}
+
+/*****************************************************************************/
+/**
+* This static function handles ZDMA pause interrupts.
+*
+* @param CallBackRef is the callback reference passed from the interrupt
+* handler, which in our case is a pointer to the driver instance.
+* @param Event specifies which interrupts were occurred.
+*
+* @return None.
+*
+* @note None.
+*
+******************************************************************************/
+static void ErrorHandler(void *CallBackRef, u32 Mask)
+{
+ Pause = 1;
+}
diff --git a/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_linkedlist_example.c b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_linkedlist_example.c
new file mode 100644
index 00000000..228c2581
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_linkedlist_example.c
@@ -0,0 +1,353 @@
+/******************************************************************************
+*
+* Copyright (C) 2014 Xilinx, Inc. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* Use of the Software is limited solely to applications:
+* (a) running on a Xilinx device, or
+* (b) that interact with a Xilinx device through a bus or interconnect.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*
+* Except as contained in this notice, the name of the Xilinx shall not be used
+* in advertising or otherwise to promote the sale, use or other dealings in
+* this Software without prior written authorization from Xilinx.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file xzdma_linkedlist_example.c
+*
+* This file contains the example using XZDma driver to do data transfer in
+* Linked list mode on ZDMA device.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- -----------------------------------------------------
+* 1.0 vns 2/27/15 First release
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include "xzdma.h"
+#include "xparameters.h"
+#include "xscugic.h"
+
+/************************** Function Prototypes ******************************/
+
+int XZDma_LinkedListExample(u16 DeviceId);
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId);
+static void DoneHandler(void *CallBackRef);
+
+/************************** Constant Definitions ******************************/
+
+/*
+ * The following constants map to the XPAR parameters created in the
+ * xparameters.h file. They are defined here such that a user can easily
+ * change all the needed parameters in one place.
+ */
+#define ZDMA_DEVICE_ID XPAR_XZDMA_0_DEVICE_ID /* ZDMA device Id */
+#define ZDMA_INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID
+ /**< SCUGIC Device ID */
+#define ZDMA_INTR_DEVICE_ID XPAR_XADMAPS_0_INTR /**< ZDMA Interrupt Id */
+#define TESTDATA1 0xABCD1230 /**< Test data */
+#define TESTDATA2 0x00005000 /**< Test data */
+
+/**************************** Type Definitions *******************************/
+
+
+/************************** Variable Definitions *****************************/
+
+XZDma ZDma; /**_DEVICE_ID value from
+* xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful.
+* - XST_FAILURE if failed.
+*
+* @note None.
+*
+******************************************************************************/
+int XZDma_LinkedListExample(u16 DeviceId)
+{
+ int Status;
+ XZDma_Config *Config;
+ XZDma_DataConfig Configur; /**< Configuration values */
+ XZDma_Transfer Data[2];
+ u32 Value;
+ u32 Index;
+ /*
+ * Initialize the ZDMA driver so that it's ready to use.
+ * Look up the configuration in the config table,
+ * then initialize it.
+ */
+ Config = XZDma_LookupConfig(DeviceId);
+ if (NULL == Config) {
+ return XST_FAILURE;
+ }
+
+ Status = XZDma_CfgInitialize(&ZDma, Config, Config->BaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Performs the self-test to check hardware build.
+ */
+ Status = XZDma_SelfTest(&ZDma);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ /* Filling the buffers for data transfer */
+ Value = TESTDATA1;
+ for (Index = 0; Index < 250; Index++) {
+ SrcBuf[Index] = Value++;
+ }
+ Value = TESTDATA2;
+ for (Index = 0; Index < 4; Index++) {
+ *(Src1Buf+Index) = Value++;
+ }
+
+ /* ZDMA has set in linked list mode for normal transfer */
+ Status = XZDma_SetMode(&ZDma, TRUE, XZDMA_NORMAL_MODE);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* Allocated memory starting address should be 64 bit aligned */
+ XZDma_CreateBDList(&ZDma, XZDMA_LINKEDLIST, (UINTPTR)AlloMem, 256);
+
+ /* Interrupt call back has been set */
+ XZDma_SetCallBack(&ZDma, XZDMA_HANDLER_DONE,
+ (void *)DoneHandler, &ZDma);
+
+ /*
+ * Connect to the interrupt controller.
+ */
+ Status = SetupInterruptSystem(&Intc, &(ZDma),
+ ZDMA_INTR_DEVICE_ID);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ /*
+ * All the configurations are kept as is which was got
+ * through XZDma_GetChDataConfig and only over fetch is disabled
+ */
+ /* Configuration settings */
+ XZDma_GetChDataConfig(&ZDma, &Configur);
+ Configur.OverFetch = 0;
+ XZDma_SetChDataConfig(&ZDma, &Configur);
+
+ /* Enable required interrupts */
+ XZDma_EnableIntr(&ZDma, XZDMA_IXR_DMA_DONE_MASK);
+
+ /* Filling the data transfer elements */
+ Data[0].SrcAddr = (UINTPTR)SrcBuf;
+ Data[0].Size = 1000;
+ Data[0].DstAddr = (UINTPTR)DstBuf;
+ Data[0].SrcCoherent = 0;
+ Data[0].DstCoherent = 0;
+ Data[0].Pause = 0;
+
+ Data[1].SrcAddr = (UINTPTR)Src1Buf;
+ Data[1].Size = 16;
+ Data[1].DstAddr = (UINTPTR)Dst1Buf;
+ Data[1].SrcCoherent = 0;
+ Data[1].DstCoherent = 0;
+ Data[1].Pause = 0;
+ /*
+ * Invalidating destination address and flushing
+ * source address in cache before initiating the data transfer
+ */
+ Xil_DCacheFlushRange((INTPTR)Data[0].SrcAddr, Data[0].Size);
+ Xil_DCacheInvalidateRange((INTPTR)Data[0].DstAddr, Data[0].Size);
+ Xil_DCacheFlushRange((INTPTR)Data[1].SrcAddr, Data[1].Size);
+ Xil_DCacheInvalidateRange((INTPTR)Data[1].DstAddr, Data[1].Size);
+
+ XZDma_Start(&ZDma, Data, 2); /* Initiates the data transfer */
+
+ while (Done == 0); /* Wait till DMA done interrupt generated */
+
+ XZDma_DisableIntr(&ZDma, XZDMA_IXR_DMA_DONE_MASK);
+
+ /* Validating the data transfer */
+ for (Index = 0; Index < 250; Index++) {
+ if (SrcBuf[Index] != DstBuf[Index]) {
+ return XST_FAILURE;
+ }
+ }
+ for (Index = 0; Index < 4; Index++) {
+ if (Src1Buf[Index] != Dst1Buf[Index]) {
+ return XST_FAILURE;
+ }
+ }
+
+ return XST_SUCCESS;
+
+}
+
+/*****************************************************************************/
+/**
+* This function sets up the interrupt system so interrupts can occur for the
+* ZDMA. This function is application-specific. The user should modify this
+* function to fit the application.
+*
+* @param IntcInstancePtr is a pointer to the instance of the INTC.
+* @param InstancePtr contains a pointer to the instance of the ZDMA
+* driver which is going to be connected to the interrupt
+* controller.
+* @param IntrId is the interrupt Id and is typically
+* XPAR__INTR value from xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful
+* - XST_FAILURE if failed
+*
+* @note None.
+
+*
+****************************************************************************/
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId)
+{
+ int Status;
+
+#ifndef TESTAPP_GEN
+ XScuGic_Config *IntcConfig; /* Config for interrupt controller */
+
+ /*
+ * Initialize the interrupt controller driver
+ */
+ IntcConfig = XScuGic_LookupConfig(ZDMA_INTC_DEVICE_ID);
+ if (NULL == IntcConfig) {
+ return XST_FAILURE;
+ }
+
+ Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
+ IntcConfig->CpuBaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Connect the interrupt controller interrupt handler to the
+ * hardware interrupt handling logic in the processor.
+ */
+ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
+ (Xil_ExceptionHandler) XScuGic_InterruptHandler,
+ IntcInstancePtr);
+#endif
+
+ /*
+ * Connect a device driver handler that will be called when an
+ * interrupt for the device occurs, the device driver handler
+ * performs the specific interrupt processing for the device
+ */
+ Status = XScuGic_Connect(IntcInstancePtr, IntrId,
+ (Xil_ExceptionHandler) XZDma_IntrHandler,
+ (void *) InstancePtr);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Enable the interrupt for the device
+ */
+ XScuGic_Enable(IntcInstancePtr, IntrId);
+
+
+ /*
+ * Enable interrupts
+ */
+ Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
+
+
+ return XST_SUCCESS;
+}
+
+/*****************************************************************************/
+/**
+* This static function handles ZDMA Done interrupts.
+*
+* @param CallBackRef is the callback reference passed from the interrupt
+* handler, which in our case is a pointer to the driver instance.
+* @param Event specifies which interrupts were occurred.
+*
+* @return None.
+*
+* @note None.
+*
+******************************************************************************/
+static void DoneHandler(void *CallBackRef)
+{
+
+ Done = 1;
+
+}
diff --git a/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_readonlymode_example.c b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_readonlymode_example.c
new file mode 100644
index 00000000..f9bad52e
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_readonlymode_example.c
@@ -0,0 +1,318 @@
+/******************************************************************************
+*
+* Copyright (C) 2014 Xilinx, Inc. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* Use of the Software is limited solely to applications:
+* (a) running on a Xilinx device, or
+* (b) that interact with a Xilinx device through a bus or interconnect.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*
+* Except as contained in this notice, the name of the Xilinx shall not be used
+* in advertising or otherwise to promote the sale, use or other dealings in
+* this Software without prior written authorization from Xilinx.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file xzdma_simple_example.c
+*
+* This file contains the example using XZDma driver to do simple data read
+* on ZDMA device.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- ------------------------------------------------------
+* 1.0 vns 2/27/15 First release
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include "xzdma.h"
+#include "xparameters.h"
+#include "xscugic.h"
+
+/************************** Function Prototypes ******************************/
+
+int XZDma_SimpleReadOnlyExample(u16 DeviceId);
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId);
+static void DoneHandler(void *CallBackRef);
+
+/************************** Constant Definitions ******************************/
+
+/*
+ * The following constants map to the XPAR parameters created in the
+ * xparameters.h file. They are defined here such that a user can easily
+ * change all the needed parameters in one place.
+ */
+#define ZDMA_DEVICE_ID XPAR_XZDMA_0_DEVICE_ID /* ZDMA device Id */
+#define ZDMA_INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID
+ /**< SCUGIC Device ID */
+#define ZDMA_INTR_DEVICE_ID XPAR_XADMAPS_0_INTR/**< ZDMA Interrupt Id */
+
+#define SIZE 100 /**< Size of the data to be
+ * transferred */
+
+/**************************** Type Definitions *******************************/
+
+
+/************************** Variable Definitions *****************************/
+
+XZDma ZDma; /**_DEVICE_ID value from
+* xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful.
+* - XST_FAILURE if failed.
+*
+* @note None.
+*
+******************************************************************************/
+int XZDma_SimpleReadOnlyExample(u16 DeviceId)
+{
+ int Status;
+ XZDma_Config *Config;
+ XZDma_DataConfig Configur; /**< Configuration values */
+ XZDma_Transfer Data;
+ u32 Value;
+ u32 Index;
+
+ /*
+ * Initialize the ZDMA driver so that it's ready to use.
+ * Look up the configuration in the config table,
+ * then initialize it.
+ */
+ Config = XZDma_LookupConfig(DeviceId);
+ if (NULL == Config) {
+ return XST_FAILURE;
+ }
+
+ Status = XZDma_CfgInitialize(&ZDma, Config, Config->BaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Performs the self-test to check hardware build.
+ */
+ Status = XZDma_SelfTest(&ZDma);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ /* Filling the buffer for data transfer */
+ Value = 0xABCD1230;
+ for (Index = 0; Index < 256; Index++) {
+ SrcBuf[Index] = Value++;
+ }
+ /*
+ * Flushing source address in cache
+ */
+ Xil_DCacheFlushRange((INTPTR)SrcBuf, SIZE);
+
+ /* ZDMA has set in simple transfer of Read only mode */
+ Status = XZDma_SetMode(&ZDma, FALSE, XZDMA_RDONLY_MODE);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ (void)XZDma_SetCallBack(&ZDma, XZDMA_HANDLER_DONE,
+ DoneHandler, &ZDma);
+ /*
+ * Connect to the interrupt controller.
+ */
+ Status = SetupInterruptSystem(&Intc, &(ZDma),
+ ZDMA_INTR_DEVICE_ID);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* Configuration settings */
+ Configur.OverFetch = 0;
+ Configur.SrcIssue = 0x1F;
+ Configur.SrcBurstType = XZDMA_INCR_BURST;
+ Configur.SrcBurstLen = 0xF;
+ Configur.DstBurstType = XZDMA_INCR_BURST;
+ Configur.DstBurstLen = 0xF;
+ XZDma_SetChDataConfig(&ZDma, &Configur);
+
+ /* Enable required interrupts */
+ XZDma_EnableIntr(&ZDma, XZDMA_IXR_DMA_DONE_MASK);
+ /*
+ * Transfer elements
+ */
+ Data.DstAddr = 0;
+ Data.DstCoherent = 0;
+ Data.Pause = 0;
+ Data.SrcAddr = (UINTPTR)SrcBuf;
+ Data.SrcCoherent = 0;
+ Data.Size = SIZE; /* Size in bytes */
+
+ XZDma_Start(&ZDma, &Data, 1); /* Initiates the data transfer */
+ /* Wait till DMA Source done interrupt generated */
+ while (Done == 0);
+
+ /*
+ * Validation of read only mode cannot be performed as it will not
+ * store the values
+ */
+
+ return XST_SUCCESS;
+
+}
+
+/*****************************************************************************/
+/**
+* This function sets up the interrupt system so interrupts can occur for the
+* ZDMA. This function is application-specific. The user should modify this
+* function to fit the application.
+*
+* @param IntcInstancePtr is a pointer to the instance of the INTC.
+* @param InstancePtr contains a pointer to the instance of the ZDMA
+* driver which is going to be connected to the interrupt
+* controller.
+* @param IntrId is the interrupt Id and is typically
+* XPAR__INTR value from xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful
+* - XST_FAILURE if failed
+*
+* @note None.
+
+*
+****************************************************************************/
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId)
+{
+ int Status;
+
+#ifndef TESTAPP_GEN
+ XScuGic_Config *IntcConfig; /* Config for interrupt controller */
+
+ /*
+ * Initialize the interrupt controller driver
+ */
+ IntcConfig = XScuGic_LookupConfig(ZDMA_INTC_DEVICE_ID);
+ if (NULL == IntcConfig) {
+ return XST_FAILURE;
+ }
+
+ Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
+ IntcConfig->CpuBaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Connect the interrupt controller interrupt handler to the
+ * hardware interrupt handling logic in the processor.
+ */
+ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
+ (Xil_ExceptionHandler) XScuGic_InterruptHandler,
+ IntcInstancePtr);
+#endif
+
+ /*
+ * Connect a device driver handler that will be called when an
+ * interrupt for the device occurs, the device driver handler
+ * performs the specific interrupt processing for the device
+ */
+ Status = XScuGic_Connect(IntcInstancePtr, IntrId,
+ (Xil_ExceptionHandler) XZDma_IntrHandler,
+ (void *) InstancePtr);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Enable the interrupt for the device
+ */
+ XScuGic_Enable(IntcInstancePtr, IntrId);
+
+
+ /*
+ * Enable interrupts
+ */
+ Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
+
+
+ return XST_SUCCESS;
+}
+
+/*****************************************************************************/
+/**
+* This static function handles ZDMA Done interrupts.
+*
+* @param CallBackRef is the callback reference passed from the interrupt
+* handler, which in our case is a pointer to the driver instance.
+*
+* @return None.
+*
+* @note None.
+*
+******************************************************************************/
+static void DoneHandler(void *CallBackRef)
+{
+
+ Done = 1;
+
+}
diff --git a/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_selftest_example.c b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_selftest_example.c
new file mode 100644
index 00000000..7775bf70
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_selftest_example.c
@@ -0,0 +1,147 @@
+/******************************************************************************
+*
+* Copyright (C) 2014 Xilinx, Inc. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* Use of the Software is limited solely to applications:
+* (a) running on a Xilinx device, or
+* (b) that interact with a Xilinx device through a bus or interconnect.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*
+* Except as contained in this notice, the name of the Xilinx shall not be used
+* in advertising or otherwise to promote the sale, use or other dealings in
+* this Software without prior written authorization from Xilinx.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file xzdma_selftest_example.c
+*
+* This file contains an example using the XZDma driver to do self test
+* on the device.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- ------------------------------------------------------
+* 1.0 vns 2/27/15 First release
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include "xzdma.h"
+#include "xparameters.h"
+
+/************************** Function Prototypes ******************************/
+
+int XZDma_SelfTestExample(u16 DeviceId);
+
+/************************** Constant Definitions ******************************/
+
+/*
+ * The following constants map to the XPAR parameters created in the
+ * xparameters.h file. They are defined here such that a user can easily
+ * change all the needed parameters in one place.
+ */
+#define ZDMA_DEVICE_ID XPAR_XZDMA_0_DEVICE_ID /* ZDMA device Id */
+
+/**************************** Type Definitions *******************************/
+
+
+/************************** Variable Definitions *****************************/
+
+XZDma ZDma; /**_DEVICE_ID value from
+* xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful.
+* - XST_FAILURE if failed.
+*
+* @note None.
+*
+******************************************************************************/
+int XZDma_SelfTestExample(u16 DeviceId)
+{
+ int Status;
+ XZDma_Config *Config;
+
+ /*
+ * Initialize the ZDMA driver so that it's ready to use.
+ * Look up the configuration in the config table,
+ * then initialize it.
+ */
+ Config = XZDma_LookupConfig(DeviceId);
+ if (NULL == Config) {
+ return XST_FAILURE;
+ }
+
+ Status = XZDma_CfgInitialize(&ZDma, Config, Config->BaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Performs the self-test to check hardware build.
+ */
+
+ Status = XZDma_SelfTest(&ZDma);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ return XST_SUCCESS;
+}
diff --git a/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_simple_example.c b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_simple_example.c
new file mode 100644
index 00000000..92d3c0ca
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_simple_example.c
@@ -0,0 +1,332 @@
+/******************************************************************************
+*
+* Copyright (C) 2014 Xilinx, Inc. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* Use of the Software is limited solely to applications:
+* (a) running on a Xilinx device, or
+* (b) that interact with a Xilinx device through a bus or interconnect.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*
+* Except as contained in this notice, the name of the Xilinx shall not be used
+* in advertising or otherwise to promote the sale, use or other dealings in
+* this Software without prior written authorization from Xilinx.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file xzdma_simple_example.c
+*
+* This file contains the example using XZDma driver to do simple data transfer
+* in Normal mode on ZDMA device for 1GB data transfer.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- ------------------------------------------------------
+* 1.0 vns 2/27/15 First release
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include "xzdma.h"
+#include "xparameters.h"
+#include "xscugic.h"
+#include "xil_cache.h"
+
+/************************** Function Prototypes ******************************/
+
+int XZDma_SimpleExample(u16 DeviceId);
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId);
+static void DoneHandler(void *CallBackRef);
+
+/************************** Constant Definitions ******************************/
+
+/*
+ * The following constants map to the XPAR parameters created in the
+ * xparameters.h file. They are defined here such that a user can easily
+ * change all the needed parameters in one place.
+ */
+#define ZDMA_DEVICE_ID XPAR_XZDMA_0_DEVICE_ID /* ZDMA device Id */
+#define ZDMA_INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID
+ /**< SCUGIC Device ID */
+#define ZDMA_INTR_DEVICE_ID XPAR_XADMAPS_0_INTR /**< ZDMA Interrupt Id */
+
+#define SIZE 1000000000 /**< Size of the data to be transferred */
+#define TESTVALUE 0x1230 /**< For writing into source buffer */
+
+/**************************** Type Definitions *******************************/
+
+
+/************************** Variable Definitions *****************************/
+
+XZDma ZDma; /**_DEVICE_ID value from
+* xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful.
+* - XST_FAILURE if failed.
+*
+* @note None.
+*
+******************************************************************************/
+int XZDma_SimpleExample(u16 DeviceId)
+{
+ int Status;
+ XZDma_Config *Config;
+ XZDma_DataConfig Configure; /**< Configuration values */
+ XZDma_Transfer Data;
+ u32 Index;
+ u32 Value;
+
+ /*
+ * Initialize the ZDMA driver so that it's ready to use.
+ * Look up the configuration in the config table,
+ * then initialize it.
+ */
+ Config = XZDma_LookupConfig(DeviceId);
+ if (NULL == Config) {
+ return XST_FAILURE;
+ }
+
+ Status = XZDma_CfgInitialize(&ZDma, Config, Config->BaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ /*
+ * Performs the self-test to check hardware build.
+ */
+ Status = XZDma_SelfTest(&ZDma);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* Filling the buffer for data transfer */
+ Value = TESTVALUE;
+ for (Index = 0; Index < SIZE/4; Index++) {
+ *(SrcBuf +Index) = Value++;
+ }
+ /*
+ * Invalidating destination address and flushing
+ * source address in cache
+ */
+ Xil_DCacheFlushRange((INTPTR)SrcBuf, SIZE);
+ Xil_DCacheInvalidateRange((INTPTR)DstBuf, SIZE);
+
+ /* ZDMA has set in simple transfer of Normal mode */
+ Status = XZDma_SetMode(&ZDma, FALSE, XZDMA_NORMAL_MODE);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* Interrupt call back has been set */
+ XZDma_SetCallBack(&ZDma, XZDMA_HANDLER_DONE,
+ (void *)DoneHandler, &ZDma);
+ /*
+ * Connect to the interrupt controller.
+ */
+ Status = SetupInterruptSystem(&Intc, &(ZDma),
+ ZDMA_INTR_DEVICE_ID);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ /* Enable required interrupts */
+ XZDma_EnableIntr(&ZDma, (XZDMA_IXR_DMA_DONE_MASK));
+
+ /* Configuration settings */
+ Configure.OverFetch = 1;
+ Configure.SrcIssue = 0x1F;
+ Configure.SrcBurstType = XZDMA_INCR_BURST;
+ Configure.SrcBurstLen = 0xF;
+ Configure.DstBurstType = XZDMA_INCR_BURST;
+ Configure.DstBurstLen = 0xF;
+ Configure.SrcCache = 0x2;
+ Configure.DstCache = 0x2;
+ Configure.SrcQos = 0;
+ Configure.DstQos = 0;
+
+ XZDma_SetChDataConfig(&ZDma, &Configure);
+ /*
+ * Transfer elements
+ */
+ Data.DstAddr = (UINTPTR)DstBuf;
+ Data.DstCoherent = 1;
+ Data.Pause = 0;
+ Data.SrcAddr = (UINTPTR)SrcBuf;
+ Data.SrcCoherent = 1;
+ Data.Size = SIZE; /* Size in bytes */
+
+ XZDma_Start(&ZDma, &Data, 1); /* Initiates the data transfer */
+
+ while (Done == 0); /* Wait till DMA done interrupt generated */
+
+ /* Checking the data transferred */
+ for (Index = 0; Index < SIZE/4; Index++) {
+ if (SrcBuf[Index] != DstBuf[Index]) {
+ return XST_FAILURE;
+ }
+ }
+
+ return XST_SUCCESS;
+}
+
+/*****************************************************************************/
+/**
+* This function sets up the interrupt system so interrupts can occur for the
+* ZDMA. This function is application-specific. The user should modify this
+* function to fit the application.
+*
+* @param IntcInstancePtr is a pointer to the instance of the INTC.
+* @param InstancePtr contains a pointer to the instance of the ZDMA
+* driver which is going to be connected to the interrupt
+* controller.
+* @param IntrId is the interrupt Id and is typically
+* XPAR__INTR value from xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful
+* - XST_FAILURE if failed
+*
+* @note None.
+
+*
+****************************************************************************/
+int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr,
+ u16 IntrId)
+{
+ int Status;
+
+#ifndef TESTAPP_GEN
+ XScuGic_Config *IntcConfig; /* Config for interrupt controller */
+
+ /*
+ * Initialize the interrupt controller driver
+ */
+ IntcConfig = XScuGic_LookupConfig(ZDMA_INTC_DEVICE_ID);
+ if (NULL == IntcConfig) {
+ return XST_FAILURE;
+ }
+
+ Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
+ IntcConfig->CpuBaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Connect the interrupt controller interrupt handler to the
+ * hardware interrupt handling logic in the processor.
+ */
+ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
+ (Xil_ExceptionHandler) XScuGic_InterruptHandler,
+ IntcInstancePtr);
+#endif
+
+ /*
+ * Connect a device driver handler that will be called when an
+ * interrupt for the device occurs, the device driver handler
+ * performs the specific interrupt processing for the device
+ */
+ Status = XScuGic_Connect(IntcInstancePtr, IntrId,
+ (Xil_ExceptionHandler) XZDma_IntrHandler,
+ (void *) InstancePtr);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Enable the interrupt for the device
+ */
+ XScuGic_Enable(IntcInstancePtr, IntrId);
+
+
+ /*
+ * Enable interrupts
+ */
+ Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
+
+
+ return XST_SUCCESS;
+}
+
+
+/*****************************************************************************/
+/**
+* This static function handles ZDMA Done interrupts.
+*
+* @param CallBackRef is the callback reference passed from the interrupt
+* handler, which in our case is a pointer to the driver instance.
+*
+* @return None.
+*
+* @note None.
+*
+******************************************************************************/
+static void DoneHandler(void *CallBackRef)
+{
+ Done = 1;
+
+}
diff --git a/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_writeonlymode_example.c b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_writeonlymode_example.c
new file mode 100644
index 00000000..d14f4590
--- /dev/null
+++ b/XilinxProcessorIPLib/drivers/zdma/examples/xzdma_writeonlymode_example.c
@@ -0,0 +1,339 @@
+/******************************************************************************
+*
+* Copyright (C) 2014 Xilinx, Inc. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining a copy
+* of this software and associated documentation files (the "Software"), to deal
+* in the Software without restriction, including without limitation the rights
+* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+* copies of the Software, and to permit persons to whom the Software is
+* furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in
+* all copies or substantial portions of the Software.
+*
+* Use of the Software is limited solely to applications:
+* (a) running on a Xilinx device, or
+* (b) that interact with a Xilinx device through a bus or interconnect.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+* XILINX CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
+* OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+* SOFTWARE.
+*
+* Except as contained in this notice, the name of the Xilinx shall not be used
+* in advertising or otherwise to promote the sale, use or other dealings in
+* this Software without prior written authorization from Xilinx.
+*
+******************************************************************************/
+/*****************************************************************************/
+/**
+*
+* @file xzdma_writeonlymode_example.c
+*
+* This file contains the example using XZDma driver to do simple data transfer
+* in Write only mode on ZDMA device. In this mode data will be predefined
+* and will be repetitively written into the given address and for given size.
+* For ADMA only 2 words are repeated and for GDMA 4 words are repeated.
+*
+*
+* MODIFICATION HISTORY:
+*
+* Ver Who Date Changes
+* ----- ------ -------- ------------------------------------------------------
+* 1.0 vns 2/27/15 First release
+*
+*
+******************************************************************************/
+
+/***************************** Include Files *********************************/
+
+#include "xzdma.h"
+#include "xparameters.h"
+#include "xscugic.h"
+
+/************************** Function Prototypes ******************************/
+
+int XZDma_WriteOnlyExample(u16 DeviceId);
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId);
+static void DoneHandler(void *CallBackRef);
+
+/************************** Constant Definitions ******************************/
+
+/*
+ * The following constants map to the XPAR parameters created in the
+ * xparameters.h file. They are defined here such that a user can easily
+ * change all the needed parameters in one place.
+ */
+#define ZDMA_DEVICE_ID XPAR_XZDMA_0_DEVICE_ID /* ZDMA device Id */
+#define ZDMA_INTC_DEVICE_ID XPAR_SCUGIC_SINGLE_DEVICE_ID
+ /**< SCUGIC Device ID */
+#define ZDMA_INTR_DEVICE_ID XPAR_XADMAPS_0_INTR /**< ZDMA Interrupt Id */
+
+#define SIZE 1024 /* Size of the data to be written */
+
+/**************************** Type Definitions *******************************/
+
+
+/************************** Variable Definitions *****************************/
+
+XZDma ZDma; /**_DEVICE_ID value from
+* xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful.
+* - XST_FAILURE if failed.
+*
+* @note None.
+*
+******************************************************************************/
+int XZDma_WriteOnlyExample(u16 DeviceId)
+{
+ int Status;
+ XZDma_Config *Config;
+ XZDma_DataConfig Configur; /**< Configuration values */
+ XZDma_Transfer Data;
+ u32 *Buf = (u32 *)DstBuf;
+ u32 Index;
+ u32 Index1;
+
+ /*
+ * Initialize the ZDMA driver so that it's ready to use.
+ * Look up the configuration in the config table,
+ * then initialize it.
+ */
+ Config = XZDma_LookupConfig(DeviceId);
+ if (NULL == Config) {
+ return XST_FAILURE;
+ }
+ Status = XZDma_CfgInitialize(&ZDma, Config, Config->BaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ /*
+ * Performs the self-test to check hardware build.
+ */
+ Status = XZDma_SelfTest(&ZDma);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /* ZDMA has set in simple transfer of Normal mode */
+ Status = XZDma_SetMode(&ZDma, FALSE, XZDMA_WRONLY_MODE);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ XZDma_EnableIntr(&ZDma, XZDMA_IXR_DMA_DONE_MASK);
+ /*
+ * Connect to the interrupt controller.
+ */
+ Status = SetupInterruptSystem(&Intc, &(ZDma),
+ ZDMA_INTR_DEVICE_ID);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+ (void)XZDma_SetCallBack(&ZDma,
+ XZDMA_HANDLER_DONE, (void *)(DoneHandler),
+ &ZDma);
+ /* Configuration settings */
+ Configur.OverFetch = 0;
+ Configur.SrcIssue = 0x1F;
+ Configur.SrcBurstType = XZDMA_INCR_BURST;
+ Configur.SrcBurstLen = 0xF;
+ Configur.DstBurstType = XZDMA_INCR_BURST;
+ Configur.DstBurstLen = 0xF;
+ XZDma_SetChDataConfig(&ZDma, &Configur);
+ /*
+ * Transfer elements
+ */
+ Data.DstAddr = (UINTPTR)DstBuf;
+ Data.DstCoherent = 0;
+ Data.Pause = 0;
+ Data.SrcAddr = (UINTPTR)NULL;
+ Data.SrcCoherent = 0;
+ Data.Size = SIZE; /* Size in bytes */
+
+ if (ZDma.Config.DmaType == 0) { /* For GDMA */
+ SrcBuf[0] = 0x1234;
+ SrcBuf[1] = 0xABCD;
+ SrcBuf[2] = 0x4567;
+ SrcBuf[3] = 0xEF;
+ XZDma_WOData(&ZDma, SrcBuf);
+ }
+ else { /* For ADMA */
+ SrcBuf[0] = 0x1234;
+ SrcBuf[1] = 0xABCD;
+ XZDma_WOData(&ZDma, SrcBuf);
+ }
+
+ Xil_DCacheInvalidateRange((INTPTR)DstBuf, SIZE);
+
+ XZDma_Start(&ZDma, &Data, 1); /* Initiates the data transfer */
+
+ /* Wait till DMA destination done interrupt generated */
+ while (Done == 0);
+
+ /* Validation */
+ if (ZDma.Config.DmaType == 0) { /* For GDMA */
+ for (Index = 0; Index < (SIZE/4)/4; Index++) {
+ for (Index1 = 0; Index1 < 4; Index1++) {
+ if (SrcBuf[Index1] != *Buf++) {
+ return XST_FAILURE;
+ }
+ }
+ }
+ }
+ else { /* For ADMA */
+ for (Index = 0; Index < (SIZE/4)/2; Index++) {
+ for (Index1 = 0; Index1 < 2; Index1++) {
+ if (SrcBuf[Index1] != *Buf++) {
+ return XST_FAILURE;
+ }
+ }
+ }
+ }
+
+return XST_SUCCESS;
+
+}
+
+/*****************************************************************************/
+/**
+* This function sets up the interrupt system so interrupts can occur for the
+* ZDMA. This function is application-specific. The user should modify this
+* function to fit the application.
+*
+* @param IntcInstancePtr is a pointer to the instance of the INTC.
+* @param InstancePtr contains a pointer to the instance of the ZDMA
+* driver which is going to be connected to the interrupt
+* controller.
+* @param IntrId is the interrupt Id and is typically
+* XPAR__INTR value from xparameters.h.
+*
+* @return
+* - XST_SUCCESS if successful
+* - XST_FAILURE if failed
+*
+* @note None.
+
+*
+****************************************************************************/
+static int SetupInterruptSystem(XScuGic *IntcInstancePtr,
+ XZDma *InstancePtr, u16 IntrId)
+{
+ int Status;
+
+#ifndef TESTAPP_GEN
+ XScuGic_Config *IntcConfig; /* Config for interrupt controller */
+
+ /*
+ * Initialize the interrupt controller driver
+ */
+ IntcConfig = XScuGic_LookupConfig(ZDMA_INTC_DEVICE_ID);
+ if (NULL == IntcConfig) {
+ return XST_FAILURE;
+ }
+
+ Status = XScuGic_CfgInitialize(IntcInstancePtr, IntcConfig,
+ IntcConfig->CpuBaseAddress);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Connect the interrupt controller interrupt handler to the
+ * hardware interrupt handling logic in the processor.
+ */
+ Xil_ExceptionRegisterHandler(XIL_EXCEPTION_ID_INT,
+ (Xil_ExceptionHandler) XScuGic_InterruptHandler,
+ IntcInstancePtr);
+#endif
+
+ /*
+ * Connect a device driver handler that will be called when an
+ * interrupt for the device occurs, the device driver handler
+ * performs the specific interrupt processing for the device
+ */
+ Status = XScuGic_Connect(IntcInstancePtr, IntrId,
+ (Xil_ExceptionHandler) XZDma_IntrHandler,
+ (void *) InstancePtr);
+ if (Status != XST_SUCCESS) {
+ return XST_FAILURE;
+ }
+
+ /*
+ * Enable the interrupt for the device
+ */
+ XScuGic_Enable(IntcInstancePtr, IntrId);
+
+
+ /*
+ * Enable interrupts
+ */
+ Xil_ExceptionEnableMask(XIL_EXCEPTION_IRQ);
+
+
+ return XST_SUCCESS;
+}
+
+/*****************************************************************************/
+/**
+* This static function handles ZDMA Done interrupts.
+*
+* @param CallBackRef is the callback reference passed from the interrupt
+* handler, which in our case is a pointer to the driver instance.
+* @param Event specifies which interrupts were occurred.
+*
+* @return None.
+*
+* @note None.
+*
+******************************************************************************/
+static void DoneHandler(void *CallBackRef)
+{
+ Done = 1;
+
+}