int main()
{
XGpioPs_Config *GPIOConfigPtr; //gpio config
//int io;
init_platform();
//GPIO Initilization
GPIOConfigPtr = XGpioPs_LookupConfig(XPAR_XGPIOPS_0_DEVICE_ID);
XGpioPs_CfgInitialize(&Gpio, GPIOConfigPtr,GPIOConfigPtr->BaseAddr);
//set direction and enable output
XGpioPs_SetDirectionPin(&Gpio, intpin, 1);
XGpioPs_SetOutputEnablePin(&Gpio, intpin, 1);
XGpioPs_WritePin(&Gpio, intpin, 0);
//set direction input pin
XGpioPs_SetDirectionPin(&Gpio, pbsw, 0);
SetupInterruptSystem(&Intc,&FPGA,FPGA_INT,&Gpio, GPIO_INTERRUPT_ID);
printf("system running\n\r");
while(1){
}
return 0;
}
int main()
{
XScuTimer_Config *TMRConfigPtr; //timer config
//Disable cache on OCM
Xil_SetTlbAttributes(0xFFFF0000,0x14de2); // S=b1 TEX=b100 AP=b11, Domain=b1111, C=b0, B=b0
print("CPU1: starting\n\r");
//GPIO Initilization
XGpio_Initialize(&Gpio, GPIO_DEVICE_ID);
XGpio_SetDataDirection(&Gpio, CHANNEL, 0x00);
XGpio_DiscreteWrite(&Gpio,CHANNEL, 0xff);
//timer initialisation
TMRConfigPtr = XScuTimer_LookupConfig(TIMER_DEVICE_ID);
XScuTimer_CfgInitialize(&Timer, TMRConfigPtr,TMRConfigPtr->BaseAddr);
XScuTimer_SelfTest(&Timer);
//load the timer
XScuTimer_LoadTimer(&Timer, TIMER_LOAD_VALUE);
SetupInterruptSystem(&Intc, &Timer,TIMER_IRPT_INTR);
XScuTimer_Start(&Timer);
print("CPU1: configured\n\r");
while(1){
}
return 0;
}
/**
* This function shows the usage of interrupt fucntionality of the GPIO device.
* It is responsible for initializing the GPIO device, setting up interrupts and
* providing a foreground loop such that interrupts can occur in the background.
*
* @param Intc is a pointer to the XScuGic driver Instance.
* @param Gpio is a pointer to the XGpioPs driver Instance.
* @param DeviceId is the XPAR_<Gpio_Instance>_PS_DEVICE_ID value
* from xparameters.h.
* @param GpioIntrId is XPAR_<GIC>_<GPIO_Instance>_VEC_ID value
* from xparameters.h
*
* @return - XST_SUCCESS if the example has completed successfully.
* - XST_FAILURE if the example has failed.
*
* @note None
*
*****************************************************************************/
int GpioIntrExample(XScuGic *Intc, XGpioPs *Gpio, u16 DeviceId, u16 GpioIntrId)
{
XGpioPs_Config *ConfigPtr;
int Status;
/*
* Initialize the Gpio driver.
*/
ConfigPtr = XGpioPs_LookupConfig(DeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XGpioPs_CfgInitialize(Gpio, ConfigPtr, ConfigPtr->BaseAddr);
/*
* Run a self-test on the GPIO device.
*/
Status = XGpioPs_SelfTest(Gpio);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup direction register of bank0, so
* that all the pins are configured as inputs.
*/
XGpioPs_SetDirection(Gpio, INPUT_BANK, ~GPIO_ALL_BUTTONS);
/*
* Set the direction for all signals to be
* outputs and Enable the Output enable for the LED Pins.
*/
XGpioPs_SetDirection(Gpio, OUTPUT_BANK, GPIO_ALL_BUTTONS);
XGpioPs_SetOutputEnable(Gpio, OUTPUT_BANK, GPIO_ALL_BUTTONS);
/*
* Setup the interrupts such that interrupt processing can occur. If
* an error occurs then exit.
*/
Status = SetupInterruptSystem(Intc, Gpio, GPIO_INTERRUPT_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
printf("\n\rPush each of the 5 buttons once to exit\n\r");
AllButtonsPressed = FALSE;
/*
* Loop forever while the button changes are handled by the interrupt
* level processing.
*/
while(AllButtonsPressed == FALSE);
printf("\n\r The GPIO Interrupt example has passed Successfully.\n\r");
return XST_SUCCESS;
}
/**
*
* This function sets up the interrupt example.
*
* @param None.
*
* @return
* - XST_SUCCESS to indicate Success
* - XST_FAILURE to indicate Failure.
*
* @note None
*
****************************************************************************/
static int TmrInterruptExample(void)
{
int Status;
/*
* Make sure the interrupts are disabled, in case this is being run
* again after a failure.
*/
/*
* Connect the Intc to the interrupt subsystem such that interrupts can
* occur. This function is application specific.
*/
Status = SetupInterruptSystem(INTC_DEVICE_ID, &InterruptController);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set up the Ticker timer
*/
Status = SetupTicker();
if (Status != XST_SUCCESS) {
return Status;
}
/*
* Set up the PWM timer
*/
Status = SetupPWM();
if (Status != XST_SUCCESS) {
return Status;
}
/*
* Enable interrupts
*/
Status = WaitForDutyCycleFull();
if (Status != XST_SUCCESS) {
return Status;
}
/*
* Stop the counters
*/
XTtcPs_Stop(&(TtcPsInst[TTC_TICK_DEVICE_ID]));
XTtcPs_Stop(&(TtcPsInst[TTC_PWM_DEVICE_ID]));
return XST_SUCCESS;
}
/**
* This function configures the IIC hardware.
*
* @param I2cLibPtr contains a pointer to the instance of the IIC library
*
* @return XST_SUCCESS if successful else XST_FAILURE.
*
******************************************************************************/
int I2cSetupHardware(XIIC_LIB *I2cLibPtr)
{
int Status;
XIICCFG *ConfigPtr;
XIIC *I2cInstancePtr;
I2cInstancePtr = &I2cLibPtr->I2cInstance;
/*
* Initialize the IIC driver so that it is ready to use.
*/
ConfigPtr = I2cLookupConfig(IIC_DEVICE_ID);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = I2cCfgInitialize(I2cInstancePtr, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* GPIO Code to pull MUX out of reset.
*/
Xil_Out32(0xe000a204, 0x2000);
Xil_Out32(0xe000a208, 0x2000);
Xil_Out32(0xe000a040, 0x2000);
/*
* Setup the Interrupt System.
*/
Status = SetupInterruptSystem(I2cLibPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
I2cSetStatusHandler(I2cInstancePtr, I2cLibPtr, (IIC_HANDLER) StatusHandler);
/*
* Set the IIC serial clock rate.
*/
XIicPs_SetSClk(I2cInstancePtr, IIC_SCLK_RATE);
I2cLibPtr->TotalErrorCount = 0;
I2cLibPtr->TransmitComplete = FALSE;
I2cLibPtr->ReceiveComplete = FALSE;
return XST_SUCCESS;
}
/**
* This function is the main function of the GPIO example. It is responsible
* for initializing the GPIO device, setting up interrupts and providing a
* foreground loop such that interrupt can occur in the background.
*
* @param None.
*
* @return
* - XST_SUCCESS to indicate success.
* - XST_FAILURE to indicate Failure.
*
* @note None.
*
*
*****************************************************************************/
int main(void)
{
int Status;
/* Initialize the GPIO driver. If an error occurs then exit */
Status = XGpio_Initialize(&Gpio, GPIO_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test on the GPIO. This is a minimal test and only
* verifies that there is not any bus error when reading the data
* register
*/
XGpio_SelfTest(&Gpio);
/*
* Setup direction register so the switch is an input and the LED is
* an output of the GPIO
*/
XGpio_SetDataDirection(&Gpio, BUTTON_CHANNEL, GPIO_ALL_BUTTONS);
XGpio_SetDataDirection(&Gpio, LED_CHANNEL, ~GPIO_ALL_LEDS);
/* Sequence the LEDs to show this example is starting to run */
SequenceLeds();
/*
* Setup the interrupts such that interrupt processing can occur. If
* an error occurs then exit
*/
Status = SetupInterruptSystem();
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Loop forever while the button changes are handled by the interrupt
* level processing
*/
while (1) {
}
return XST_SUCCESS;
}
/**
*
* This function is an example of how to use the interrupt controller driver
* (XScuGic) and the hardware device. This function is designed to
* work without any hardware devices to cause interrupts. It may not return
* if the interrupt controller is not properly connected to the processor in
* either software or hardware.
*
* This function relies on the fact that the interrupt controller hardware
* has come out of the reset state such that it will allow interrupts to be
* simulated by the software.
*
* @param CpuBaseAddress is Base Address of the Interrupt Controller
* Device
*
* @return XST_SUCCESS to indicate success, otherwise XST_FAILURE
*
* @note None.
*
******************************************************************************/
static int ScuGicLowLevelExample(u32 CpuBaseAddress, u32 DistBaseAddress)
{
GicDistInit(DistBaseAddress);
GicCPUInit(CpuBaseAddress);
/*
* This step is processor specific, connect the handler for the
* interrupt controller to the interrupt source for the processor
*/
SetupInterruptSystem();
/*
* Enable the software interrupts only.
*/
XScuGic_WriteReg(DistBaseAddress, XSCUGIC_ENABLE_SET_OFFSET, 0x0000FFFF);
/*
* Cause (simulate) an interrupt so the handler will be called.
* This is done by changing the interrupt source to be software driven,
* then set a bit which simulates an interrupt.
*/
XScuGic_WriteReg(DistBaseAddress, XSCUGIC_SFI_TRIG_OFFSET, GIC_DEVICE_INT_MASK);
/*
* Wait for the interrupt to be processed, if the interrupt does not
* occur this loop will wait forever
*/
while (1)
{
/*
* If the interrupt occurred which is indicated by the global
* variable which is set in the device driver handler, then
* stop waiting
*/
if (InterruptProcessed != 0) {
break;
}
}
return XST_SUCCESS;
}
/**
*
* Main function to execute the Intel Serial Flash SPR example.
*
* @param None
*
* @return XST_SUCCESS if successful else XST_FAILURE.
*
* @note None
*
******************************************************************************/
int main()
{
int Status;
u32 Index;
u32 Address;
u8 StatusReg;
XIsf_WriteParam WriteParam;
XIsf_ReadParam ReadParam;
/*
* Initialize the SPI driver so that it's ready to use,
* specify the device ID that is generated in xparameters.h.
*/
Status = XSpi_Initialize(&Spi, SPI_DEVICE_ID);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the SPI driver to the interrupt subsystem such that
* interrupts can occur. This function is application specific.
*/
Status = SetupInterruptSystem(&Spi);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handler for the SPI that will be called from the interrupt
* context when an SPI status occurs, specify a pointer to the SPI
* driver instance as the callback reference so the handler is able to
* access the instance data.
*/
XIsf_SetStatusHandler(&Isf, &Spi, (XSpi_StatusHandler)SpiHandler);
/*
* Start the SPI driver so that interrupts and the device are enabled.
*/
XSpi_Start(&Spi);
/*
* Initialize the Serial Flash Library.
*/
Status = XIsf_Initialize(&Isf, &Spi, ISF_SPI_SELECT, IsfWriteBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set The transfer Mode to Interrupt
*/
XIsf_SetTransferMode(&Isf,XISF_INTERRUPT_MODE);
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read the sector protection register.
*/
TransferInProgress = TRUE;
Status = XIsf_SectorProtect(&Isf, XISF_SPR_READ, ReadBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Clear all the block protection bits in the sector protection register
* value read above.
*/
WriteBuffer[BYTE1] = ReadBuffer[BYTE2] &
(~(XISF_SR_BLOCK_PROTECT_MASK));
/*
* Write this value to the sector protection register to disable the
* sector protection.
*/
TransferInProgress = TRUE;
Status = XIsf_SectorProtect(&Isf, XISF_SPR_WRITE, WriteBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Specify the address in the Serial Flash for the Erase/Write/Read
* operations.
*/
Address = ISF_TEST_ADDRESS;
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform the Sector Erase operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Erase(&Isf, XISF_SECTOR_ERASE, Address);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* - Set the address within the Serial Flash where the data is to be
* written.
* - Set the number of bytes to be written to the Serial Flash.
* - Write Buffer which contains the data to be written to the Serial
* Flash.
*/
WriteParam.Address = Address;
WriteParam.NumBytes = ISF_PAGE_SIZE;
WriteParam.WritePtr = WriteBuffer;
/*
* Prepare the write buffer. Fill in the data need to be written into
* Serial Flash.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
WriteParam.WritePtr[Index] = Index + ISF_TEST_BYTE;
}
/*
* Perform the Write operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Write(&Isf, XISF_WRITE, (void*) &WriteParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read the sector protection register.
*/
TransferInProgress = TRUE;
Status = XIsf_SectorProtect(&Isf, XISF_SPR_READ, ReadBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Set all the block protection bits in the sector protection register
* value read above and write it back to the sector protection register.
*/
WriteBuffer[BYTE1] = ReadBuffer[BYTE2] |
(XISF_SR_BLOCK_PROTECT_MASK);
/*
* Enable the sector protection.
*/
TransferInProgress = TRUE;
Status = XIsf_SectorProtect(&Isf, XISF_SPR_WRITE, WriteBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform the Sector Erase operation. This should not work as writes to
* the Serial Flash are disabled.
*/
TransferInProgress = TRUE;
Status = XIsf_Erase(&Isf, XISF_SECTOR_ERASE, Address);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read the Status Register.
*/
TransferInProgress = TRUE;
Status = XIsf_GetStatus(&Isf, ReadBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is in progress.
*/
while(TransferInProgress);
/*
* Check if there are any errors in the transaction.
*/
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Check if the erase fail flag is set in the status register. This flag
* should be set as a sector erase operation was attempted when sector
* protection was enabled.
*/
StatusReg = ReadBuffer[BYTE2];
if((StatusReg & XISF_SR_ERASE_FAIL_MASK) == 0) {
return XST_FAILURE;
}
/*
* Clear the status register fail flags in the Serial Flash status
* register.
*/
TransferInProgress = TRUE;
Status = XIsf_Ioctl(&Isf, XISF_IOCTL_CLEAR_SR_FAIL_FLAGS);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read the Status Register.
*/
TransferInProgress = TRUE;
Status = XIsf_GetStatus(&Isf, ReadBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is in progress.
*/
while(TransferInProgress);
/*
* Check if there are any errors in the transaction.
*/
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Check if the erase fail flag is clear in the status register. This
* flag should be clear as a 'Clear SR Fail Flags' command has been
* executed.
*/
StatusReg = ReadBuffer[BYTE2];
if((StatusReg & XISF_SR_ERASE_FAIL_MASK) != 0) {
return XST_FAILURE;
}
/*
* Read the sector protection register.
*/
TransferInProgress = TRUE;
Status = XIsf_SectorProtect(&Isf, XISF_SPR_READ, ReadBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Clear all the block protection bits in the sector protection register
* value read above and write it back to the sector protection register
* to disable sector protection for all sectors.
*/
WriteBuffer[BYTE1] = ReadBuffer[BYTE2] &
~(XISF_SR_BLOCK_PROTECT_MASK);
/*
* Disable the sector protection.
*/
TransferInProgress = TRUE;
Status = XIsf_SectorProtect(&Isf, XISF_SPR_WRITE, WriteBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* The following code Reads data from a Page in the Intel Serial Flash.
*/
/*
* Set the
* - Address in the Serial Flash where the data is to be read from.
* - Number of bytes to be read from the Serial Flash.
* - Read Buffer to which the data is to be read.
*/
ReadParam.Address = Address;
ReadParam.NumBytes = ISF_PAGE_SIZE;
ReadParam.ReadPtr = ReadBuffer;
/*
* Perform the read operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Read(&Isf, XISF_READ, (void*) &ReadParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check if there are any errors
* in the transaction.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Compare the data read against the data Written.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
if(ReadBuffer[Index + XISF_CMD_SEND_EXTRA_BYTES] !=
(u8)(Index + ISF_TEST_BYTE)) {
return XST_FAILURE;
}
}
return XST_SUCCESS;
}
/**
* This main function starts the USB Intrerrupt example.
*
*
* @param None.
*
* @return
* - XST_SUCCESS if successful.
* - XST_FAILURE if test fails.
* @note None.
*
*****************************************************************************/
int main()
{
int Status;
int Index = 0;
int Cnt = 0;
/*
* Initialize the USB driver.
*/
UsbConfigPtr = XUsb_LookupConfig(USB_DEVICE_ID);
if (UsbConfigPtr == NULL) {
return XST_FAILURE;
}
#ifdef __PPC__
Xil_ICacheEnableRegion (0x80000001);
Xil_DCacheEnableRegion (0x80000001);
#endif
#ifdef __MICROBLAZE__
Xil_ICacheInvalidate();
Xil_ICacheEnable();
Xil_DCacheInvalidate();
Xil_DCacheEnable();
#endif
Status = XUsb_CfgInitialize(&UsbInstance,
UsbConfigPtr,
UsbConfigPtr->BaseAddress);
if (XST_SUCCESS != Status) {
return XST_FAILURE;
}
/*
* Initialize the USB instance as required for the
* application.
*/
InitUsbInterface(&UsbInstance);
/*
* Set our function address to 0 which is the unenumerated state.
*/
Status = XUsb_SetDeviceAddress(&UsbInstance, 0);
if (XST_SUCCESS != Status) {
return XST_FAILURE;
}
/*
* Setup the interrupt handlers.
*/
XUsb_IntrSetHandler(&UsbInstance, (void *) UsbIfIntrHandler,
&UsbInstance);
XUsb_EpSetHandler(&UsbInstance, 0,
(XUsb_EpHandlerFunc *) Ep0IntrHandler, &UsbInstance);
XUsb_EpSetHandler(&UsbInstance, 1,
(XUsb_EpHandlerFunc *) Ep1IntrHandler, &UsbInstance);
/*
* Setup the interrupt system.
*/
Status = SetupInterruptSystem(&UsbInstance);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the interrupts.
*/
XUsb_IntrEnable(&UsbInstance, XUSB_STATUS_GLOBAL_INTR_MASK |
XUSB_STATUS_RESET_MASK |
XUSB_STATUS_SUSPEND_MASK |
XUSB_STATUS_DISCONNECT_MASK |
XUSB_STATUS_FIFO_BUFF_RDY_MASK |
XUSB_STATUS_FIFO_BUFF_FREE_MASK |
XUSB_STATUS_EP0_BUFF1_COMP_MASK |
XUSB_STATUS_EP1_BUFF1_COMP_MASK |
XUSB_STATUS_EP2_BUFF1_COMP_MASK |
XUSB_STATUS_EP1_BUFF2_COMP_MASK |
XUSB_STATUS_EP2_BUFF2_COMP_MASK);
XUsb_Start(&UsbInstance);
/*
* Set the device configuration to unenumerated state.
*/
UsbInstance.DeviceConfig.CurrentConfiguration = 0;
/*
* Wait untill the USB device is enumerated.
*/
while (!UsbInstance.DeviceConfig.CurrentConfiguration);
/*
* Stop the test if the Stop key is pressed or
* device lost enumeration.
*/
while (1) {
if (UsbInstance.Config.DmaEnabled) {
/* Flush the cache before DMA transfer */
Xil_DCacheFlushRange((u32)&Hello_wav[Index],(u32)1024);
}
if (XUsb_EpDataSend(&UsbInstance, 1, &Hello_wav[Index],
1024) == XST_SUCCESS){
Index += 1024;
Cnt ++;
if (Cnt >= 9000){
Cnt =0;
Index = 0;
}
}
}
return XST_SUCCESS;
}
/**
*
* The main entry point for showing the XCanPs driver in interrupt mode.
* The example configures the device for internal loop back mode, then
* sends a CAN frame and receives the same CAN frame.
*
* @param IntcInstPtr is a pointer to the instance of the INTC driver.
* @param CanInstPtr is a pointer to the instance of the CAN driver which
* is going to be connected to the interrupt controller.
* @param CanDeviceId is the device Id of the CAN device and is typically
* XPAR_<CANPS_instance>_DEVICE_ID value from xparameters.h.
* @param CanIntrId is the interrupt Id and is typically
* XPAR_<CANPS_instance>_INTR value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note If the device is not working correctly, this function may enter
* an infinite loop and will never return to the caller.
*
******************************************************************************/
int CanPsIntrExample(INTC *IntcInstPtr, XCanPs *CanInstPtr,
u16 CanDeviceId, u16 CanIntrId)
{
int Status;
XCanPs_Config *ConfigPtr;
/*
* Initialize the Can device.
*/
ConfigPtr = XCanPs_LookupConfig(CanDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
XCanPs_CfgInitialize(CanInstPtr,
ConfigPtr,
ConfigPtr->BaseAddr);
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCanPs_SelfTest(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Configure CAN device.
*/
Config(CanInstPtr);
/*
* Set interrupt handlers.
*/
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_SEND,
(void *)SendHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_RECV,
(void *)RecvHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_ERROR,
(void *)ErrorHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_EVENT,
(void *)EventHandler, (void *)CanInstPtr);
/*
* Initialize the flags.
*/
SendDone = FALSE;
RecvDone = FALSE;
LoopbackError = FALSE;
/*
* Connect to the interrupt controller.
*/
Status = SetupInterruptSystem(IntcInstPtr,
CanInstPtr,
CanIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable all interrupts in CAN device.
*/
XCanPs_IntrEnable(CanInstPtr, XCANPS_IXR_ALL);
/*
* Enter Loop Back Mode.
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_LOOPBACK);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_LOOPBACK);
/*
* Loop back a frame. The RecvHandler is expected to handle
* the frame reception.
*/
SendFrame(CanInstPtr); /* Send a frame */
/*
* Wait here until both sending and reception have been completed.
*/
while ((SendDone != TRUE) || (RecvDone != TRUE));
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_LOOPBACK_ERROR;
}
return XST_SUCCESS;
}
/**
*
* This function demonstrates the usage of AXI FIFO
* It does the following:
* - Set up the output terminal if UART16550 is in the hardware build
* - Initialize the Axi FIFO Device.
* - Set up the interrupt handler for fifo
* - Transmit the data
* - Compare the data
* - Return the result
*
* @param InstancePtr is a pointer to the instance of the
* XLlFifo instance.
* @param DeviceId is Device ID of the Axi Fifo Deive instance,
* typically XPAR_<AXI_FIFO_instance>_DEVICE_ID value from
* xparameters.h.
*
* @return -XST_SUCCESS to indicate success
* -XST_FAILURE to indicate failure
*
******************************************************************************/
int XLlFifoInterruptExample(XLlFifo *InstancePtr, u16 DeviceId)
{
XLlFifo_Config *Config;
int Status;
int i;
int err;
Status = XST_SUCCESS;
/* Initial setup for Uart16550 */
#ifdef XPAR_UARTNS550_0_BASEADDR
Uart550_Setup();
#endif
/* Initialize the Device Configuration Interface driver */
Config = XLlFfio_LookupConfig(DeviceId);
if (!Config) {
xil_printf("No config found for %d\r\n", DeviceId);
return XST_FAILURE;
}
/*
* This is where the virtual address would be used, this example
* uses physical address.
*/
Status = XLlFifo_CfgInitialize(InstancePtr, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
xil_printf("Initialization failed\n\r");
return Status;
}
/* Check for the Reset value */
Status = XLlFifo_Status(InstancePtr);
XLlFifo_IntClear(InstancePtr,0xffffffff);
Status = XLlFifo_Status(InstancePtr);
if(Status != 0x0) {
xil_printf("\n ERROR : Reset value of ISR0 : 0x%x\t"
"Expected : 0x0\n\r",
XLlFifo_Status(InstancePtr));
return XST_FAILURE;
}
/*
* Connect the Axi Streaming FIFO to the interrupt subsystem such
* that interrupts can occur. This function is application specific.
*/
Status = SetupInterruptSystem(&Intc, InstancePtr, FIFO_INTR_ID);
if (Status != XST_SUCCESS) {
xil_printf("Failed intr setup\r\n");
return XST_FAILURE;
}
XLlFifo_IntEnable(InstancePtr, XLLF_INT_ALL_MASK);
Done = 0;
/* Transmit the Data Stream */
Status = TxSend(InstancePtr, SourceBuffer);
if (Status != XST_SUCCESS){
xil_printf("Transmission of Data failed\n\r");
return XST_FAILURE;
}
while(!Done);
/* Check for errors */
if(Error) {
xil_printf("Errors in the FIFO\n\r");
return XST_FAILURE;
}
err = 0;
/* Compare the data sent with the data received */
xil_printf("Comparing data...\n\r");
for( i=0 ; i<MAX_DATA_BUFFER_SIZE ; i++ ){
if ( *(SourceBuffer + i) != *(DestinationBuffer + i) ){
err = 1;
break;
}
}
if (err != 0){
return XST_FAILURE;
}
DisableIntrSystem(&Intc, FIFO_INTR_ID);
return Status;
}
/**
*
* This function does a minimal test on the UartPS device and driver as a
* design example. The purpose of this function is to illustrate
* how to use the XUartPs driver.
*
* This function sends data and expects to receive the same data through the
* device using the local loopback mode.
*
* This function uses interrupt mode of the device.
*
* @param IntcInstPtr is a pointer to the instance of the Scu Gic driver.
* @param UartInstPtr is a pointer to the instance of the UART driver
* which is going to be connected to the interrupt controller.
* @param DeviceId is the device Id of the UART device and is typically
* XPAR_<UARTPS_instance>_DEVICE_ID value from xparameters.h.
* @param UartIntrId is the interrupt Id and is typically
* XPAR_<UARTPS_instance>_INTR value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note
*
* This function contains an infinite loop such that if interrupts are not
* working it may never return.
*
**************************************************************************/
int UartPsIntrExample(XScuGic *IntcInstPtr, XUartPs *UartInstPtr,
u16 DeviceId, u16 UartIntrId)
{
int Status;
XUartPs_Config *Config;
int Index;
u32 IntrMask;
int BadByteCount = 0;
/*
* Initialize the UART driver so that it's ready to use
* Look up the configuration in the config table, then initialize it.
*/
Config = XUartPs_LookupConfig(DeviceId);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XUartPs_CfgInitialize(UartInstPtr, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Check hardware build
*/
Status = XUartPs_SelfTest(UartInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the UART to the interrupt subsystem such that interrupts
* can occur. This function is application specific.
*/
Status = SetupInterruptSystem(IntcInstPtr, UartInstPtr, UartIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handlers for the UART that will be called from the
* interrupt context when data has been sent and received, specify
* a pointer to the UART driver instance as the callback reference
* so the handlers are able to access the instance data
*/
XUartPs_SetHandler(UartInstPtr, (XUartPs_Handler)Handler, UartInstPtr);
/*
* Enable the interrupt of the UART so interrupts will occur, setup
* a local loopback so data that is sent will be received.
*/
IntrMask =
XUARTPS_IXR_TOUT | XUARTPS_IXR_PARITY | XUARTPS_IXR_FRAMING |
XUARTPS_IXR_OVER | XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_RXFULL |
XUARTPS_IXR_RXOVR;
XUartPs_SetInterruptMask(UartInstPtr, IntrMask);
XUartPs_SetOperMode(UartInstPtr, XUARTPS_OPER_MODE_LOCAL_LOOP);
/*
* Set the receiver timeout. If it is not set, and the last few bytes
* of data do not trigger the over-water or full interrupt, the bytes
* will not be received. By default it is disabled.
*
* The setting of 8 will timeout after 8 x 4 = 32 character times.
* Increase the time out value if baud rate is high, decrease it if
* baud rate is low.
*/
XUartPs_SetRecvTimeout(UartInstPtr, 8);
/*
* Initialize the send buffer bytes with a pattern and the
* the receive buffer bytes to zero to allow the receive data to be
* verified
*/
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
SendBuffer[Index] = (Index % 26) + 'A';
RecvBuffer[Index] = 0;
}
/*
* Start receiving data before sending it since there is a loopback,
* ignoring the number of bytes received as the return value since we
* know it will be zero
*/
XUartPs_Recv(UartInstPtr, RecvBuffer, TEST_BUFFER_SIZE);
/*
* Send the buffer using the UART and ignore the number of bytes sent
* as the return value since we are using it in interrupt mode.
*/
XUartPs_Send(UartInstPtr, SendBuffer, TEST_BUFFER_SIZE);
/*
* Wait for the entire buffer to be received, letting the interrupt
* processing work in the background, this function may get locked
* up in this loop if the interrupts are not working correctly.
*/
while (1) {
if ((TotalSentCount == TEST_BUFFER_SIZE) &&
(TotalReceivedCount == TEST_BUFFER_SIZE)) {
break;
}
}
/*
* Verify the entire receive buffer was successfully received
*/
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
if (RecvBuffer[Index] != SendBuffer[Index]) {
BadByteCount++;
}
}
/*
* Set the UART in Normal Mode
*/
XUartPs_SetOperMode(UartInstPtr, XUARTPS_OPER_MODE_NORMAL);
/*
* If any bytes were not correct, return an error
*/
if (BadByteCount != 0) {
return XST_FAILURE;
}
return XST_SUCCESS;
}
int setupUartControl(){
int Status;
u32 IntrMask;
Config = XUartPs_LookupConfig(UART_DEVICE_ID);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XUartPs_CfgInitialize(&Uart_Ps, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XUartPs_SetBaudRate(&Uart_Ps, 115200);
/*
* Check hardware build.
*/
Status = XUartPs_SelfTest(&Uart_Ps);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the UART to the interrupt subsystem such that interrupts
* can occur. This function is application specific.
*/
Status = SetupInterruptSystem(&InterruptController, &Uart_Ps, UART_INT_IRQ_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handlers for the UART that will be called from the
* interrupt context when data has been sent and received, specify
* a pointer to the UART driver instance as the callback reference
* so the handlers are able to access the instance data
*/
XUartPs_SetHandler(&Uart_Ps, (XUartPs_Handler)Handler, &Uart_Ps);
/*
* Enable the interrupt of the UART so interrupts will occur
*/
IntrMask =
XUARTPS_IXR_TOUT | XUARTPS_IXR_PARITY | XUARTPS_IXR_FRAMING |
XUARTPS_IXR_OVER | XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_RXFULL |
XUARTPS_IXR_RXOVR;
XUartPs_SetInterruptMask(&Uart_Ps, IntrMask);
/*
* Set the receiver timeout. If it is not set, and the last few bytes
* of data do not trigger the over-water or full interrupt, the bytes
* will not be received. By default it is disabled.
*
* The setting of 8 will timeout after 8 x 4 = 32 character times.
* Increase the time out value if baud rate is high, decrease it if
* baud rate is low.
*/
XUartPs_SetRecvTimeout(&Uart_Ps, 255);
return 0;
}
/**
*
* The main entry point for showing the XCan driver in interrupt mode.
* The example configures the device for internal loopback mode, then
* sends a CAN frame and receives the same CAN frame.
*
* @param DeviceId contains the CAN device ID.
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note If the device is not working correctly, this function may enter
* an infinite loop and will never return to the caller.
*
******************************************************************************/
static int XCanIntrExample(u16 DeviceId)
{
int Status;
/*
* Initialize the XCan driver.
*/
Status = XCan_Initialize(&Can, DeviceId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCan_SelfTest(&Can);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Configure the CAN device.
*/
Config(&Can);
/*
* Set interrupt handlers.
*/
XCan_SetHandler(&Can, XCAN_HANDLER_SEND,
(void *)SendHandler, (void *)&Can);
XCan_SetHandler(&Can, XCAN_HANDLER_RECV,
(void *)RecvHandler, (void *)&Can);
XCan_SetHandler(&Can, XCAN_HANDLER_ERROR,
(void *)ErrorHandler, (void *)&Can);
XCan_SetHandler(&Can, XCAN_HANDLER_EVENT,
(void *)EventHandler, (void *)&Can);
/*
* Initialize flags.
*/
SendDone = FALSE;
RecvDone = FALSE;
LoopbackError = FALSE;
/*
* Connect to the interrupt controller.
*/
Status = SetupInterruptSystem(&Can);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable all interrupts in CAN device.
*/
XCan_InterruptEnable(&Can, XCAN_IXR_ALL);
/*
* Enter Loop Back Mode.
*/
XCan_EnterMode(&Can, XCAN_MODE_LOOPBACK);
while(XCan_GetMode(&Can) != XCAN_MODE_LOOPBACK);
/*
* Loop back a frame. The RecvHandler is expected to handle
* the frame reception.
*/
SendFrame(&Can); /* Send a frame */
/*
* Wait here until both sending and reception have been completed.
*/
while ((SendDone != TRUE) || (RecvDone != TRUE));
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_LOOPBACK_ERROR;
}
return XST_SUCCESS;
}
/**
* This function implements the USB mouse application.
* This function sets up the ML403 evaluation board as a USB mouse.
* The mouse cursor movement can be seen on the PC as and when any of the push
* buttons SW3, SW4, SW5 and SW7 on the ML403 Evaluation board is pressed.
* Pressing the push button SW6 stops the test.
*
* @param UsbId is the USB device id.
* @param GpioId is the GPIO device id.
*
* @return
* - XST_SUCCESS if successful.
* - XST_FAILURE if test fails.
*
* @note None.
*
*****************************************************************************/
int UsbMouseExample (u16 UsbId, u16 GpioId)
{
int Status;
/*
* Initialize the USB driver.
*/
UsbConfigPtr = XUsb_LookupConfig(UsbId);
if (NULL == UsbConfigPtr) {
return XST_FAILURE;
}
/*
* We are passing the physical base address as the third argument
* because the physical and virtual base address are the same in our
* example. For systems that support virtual memory, the third
* argument needs to be the virtual base address.
*/
Status = XUsb_CfgInitialize(&UsbInstance,
UsbConfigPtr,
UsbConfigPtr->BaseAddress);
if (XST_SUCCESS != Status) {
return XST_FAILURE;
}
/*
* Initialize the GPIO driver.
*/
GpioConfigPtr = XGpio_LookupConfig(GpioId);
if (GpioConfigPtr == NULL) {
return XST_FAILURE;
}
/*
* We are passing the physical base address as the third argument
* because the physical and virtual base address are the same in our
* example. For systems that support virtual memory, the third
* argument needs to be the virtual base address.
*/
Status = XGpio_CfgInitialize(&Gpio,
GpioConfigPtr,
GpioConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XGpio_SetDataDirection(&Gpio, BUTTON_CHANNEL, GPIO_ALL_BUTTONS);
/*
* Initialize the USB instance as required for the USB mouse
* application.
*/
InitUsbInterface(&UsbInstance);
/*
* Set USB device address to 0 which is the unenumerated state.
*/
Status = XUsb_SetDeviceAddress(&UsbInstance, 0);
if (XST_SUCCESS != Status) {
return XST_FAILURE;
}
/*
* Setup the interrupt handlers.
*/
XUsb_IntrSetHandler(&UsbInstance, (void *)UsbIfIntrHandler,
&UsbInstance);
XUsb_EpSetHandler(&UsbInstance, 0,
(XUsb_EpHandlerFunc *)Ep0IntrHandler,
&UsbInstance);
XUsb_EpSetHandler(&UsbInstance, 1,
(XUsb_EpHandlerFunc *)Ep1IntrHandler,
&UsbInstance);
/*
* Setup the interrupt system.
*/
Status = SetupInterruptSystem(&UsbInstance, &Gpio);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the interrupts.
*/
XUsb_IntrEnable(&UsbInstance, XUSB_STATUS_GLOBAL_INTR_MASK |
XUSB_STATUS_RESET_MASK |
XUSB_STATUS_SUSPEND_MASK |
XUSB_STATUS_DISCONNECT_MASK |
XUSB_STATUS_FIFO_BUFF_RDY_MASK |
XUSB_STATUS_FIFO_BUFF_FREE_MASK |
XUSB_STATUS_EP0_BUFF1_COMP_MASK |
XUSB_STATUS_EP1_BUFF1_COMP_MASK |
XUSB_STATUS_EP1_BUFF2_COMP_MASK );
XUsb_Start(&UsbInstance);
/*
* Set the device configuration to unenumerated state.
*/
UsbInstance.DeviceConfig.CurrentConfiguration = 0;
/*
* Observe that the mouse movement is seen on the PC whenever any of the
* ML403 evaluation board push button is pressed. The test ends when the
* center push button on the ML403 Evaluation board is pressed.
*/
while (!StopTest);
return XST_SUCCESS;
}
/**
*
* The main entry point for showing the usage of XCanPs driver in interrupt
* mode. The example configures the device for internal loop back mode, then
* sends multiple CAN frames and receives the same number of CAN frame's
* using the Rx Watermark Interrupt.
*
* @param IntcInstPtr is a pointer to the instance of the ScuGic driver.
* @param CanInstPtr is a pointer to the instance of the CAN driver which
* is going to be connected to the interrupt controller.
* @param CanDeviceId is the device Id of the CAN device and is typically
* XPAR_<CANPS_instance>_DEVICE_ID value from xparameters.h.
* @param CanIntrId is the interrupt Id and is typically
* XPAR_<CANPS_instance>_INTR value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise driver-specific error code.
*
* @note If the device is not working correctly, this function may enter
* an infinite loop and will never return to the caller.
*
******************************************************************************/
int CanPsWatermarkIntrExample(XScuGic *IntcInstPtr, XCanPs *CanInstPtr,
u16 CanDeviceId, u16 CanIntrId)
{
int Status;
XCanPs_Config *ConfigPtr;
u32 Index;
/*
* Initialize the Can device.
*/
ConfigPtr = XCanPs_LookupConfig(CanDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XCanPs_CfgInitialize(CanInstPtr,
ConfigPtr,
ConfigPtr->BaseAddr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run self-test on the device, which verifies basic sanity of the
* device and the driver.
*/
Status = XCanPs_SelfTest(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Configure the CAN device.
*/
Config(CanInstPtr);
/*
* Set the interrupt handlers.
*/
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_SEND,
(void *)SendHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_RECV,
(void *)RecvHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_ERROR,
(void *)ErrorHandler, (void *)CanInstPtr);
XCanPs_SetHandler(CanInstPtr, XCANPS_HANDLER_EVENT,
(void *)EventHandler, (void *)CanInstPtr);
/*
* Initialize flags.
*/
SendDone = FALSE;
RecvDone = FALSE;
LoopbackError = FALSE;
/*
* Connect to the interrupt controller.
*/
Status = SetupInterruptSystem(IntcInstPtr,
CanInstPtr,
CanIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable all interrupts in CAN device.
*/
XCanPs_IntrEnable(CanInstPtr, XCANPS_IXR_ALL);
/*
* Disable the Receive FIFO Not Empty Interrupt and the
* New Message Received Interrupt.
*/
XCanPs_IntrDisable(CanInstPtr,
XCANPS_IXR_RXNEMP_MASK |
XCANPS_IXR_RXOK_MASK);
/*
* Enter Loop Back Mode.
*/
XCanPs_EnterMode(CanInstPtr, XCANPS_MODE_LOOPBACK);
while(XCanPs_GetMode(CanInstPtr) != XCANPS_MODE_LOOPBACK);
/*
* Send a number of frames.
*/
TestDataOffset = 1;
for (Index = 0; Index < TEST_THRESHOLD; Index++) {
SendFrame(CanInstPtr); /* Send a frame */
TestDataOffset++;
}
/*
* Wait here until both sending and reception have been completed.
*/
while ((SendDone < TEST_THRESHOLD) || (RecvDone != TRUE));
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_FAILURE;
}
/*
* Read the Received Frames from the FIFO.
*/
TestDataOffset = 1;
Status = ReceiveData(CanInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Check for errors found in the callbacks.
*/
if (LoopbackError == TRUE) {
return XST_LOOPBACK_ERROR;
}
return XST_SUCCESS;
}
int main()
{
char buff[4];
init_platform();
int Status;
XUartPs_Config *Config;
int Index;
u32 IntrMask = 0;
int BadByteCount = 0;
if (XGetPlatform_Info() == XPLAT_ZYNQ_ULTRA_MP) {
#ifdef XPAR_XUARTPS_1_DEVICE_ID
DeviceId = XPAR_XUARTPS_1_DEVICE_ID;
#endif
}
/*
* Initialize the UART driver so that it's ready to use
* Look up the configuration in the config table, then initialize it.
*/
Config = XUartPs_LookupConfig(UART_DEVICE_ID);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XUartPs_CfgInitialize(&uart, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/* Check hardware build */
Status = XUartPs_SelfTest(&uart);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the UART to the interrupt subsystem such that interrupts
* can occur. This function is application specific.
*/
Status = SetupInterruptSystem(&intc, &uart, UART_INT_IRQ_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
//force receive interrupt for every byte (char)
XUartPs_SetFifoThreshold(&uart, 1);
/*
* Setup the handlers for the UART that will be called from the
* interrupt context when data has been sent and received, specify
* a pointer to the UART driver instance as the callback reference
* so the handlers are able to access the instance data
*/
XUartPs_SetHandler(&uart, (XUartPs_Handler)Handler, &uart);
/*
* Enable the interrupt of the UART so interrupts will occur
*/
IntrMask =
XUARTPS_IXR_TOUT | XUARTPS_IXR_PARITY | XUARTPS_IXR_FRAMING |
XUARTPS_IXR_OVER | XUARTPS_IXR_TXEMPTY | XUARTPS_IXR_RXFULL |
XUARTPS_IXR_RXOVR;
if (uart.Platform == XPLAT_ZYNQ_ULTRA_MP) {
IntrMask |= XUARTPS_IXR_RBRK;
}
XUartPs_SetInterruptMask(&uart, IntrMask);
//XUartPs_SetOperMode(UartInstPtr, XUARTPS_OPER_MODE_LOCAL_LOOP);
/* Set the UART in Normal Mode */
XUartPs_SetOperMode(&uart, XUARTPS_OPER_MODE_NORMAL);
/*
* Set the receiver timeout. If it is not set, and the last few bytes
* of data do not trigger the over-water or full interrupt, the bytes
* will not be received. By default it is disabled.
*
* The setting of 8 will timeout after 8 x 4 = 32 character times.
* Increase the time out value if baud rate is high, decrease it if
* baud rate is low.
*/
//XUartPs_SetRecvTimeout(&uart, 8);
/* Run the UartPs Interrupt example, specify the the Device ID */
//currently sets up some of uart.Need to pull out what is needed
Status = UartPsIntrExample(&intc, &uart,UART_DEVICE_ID, UART_INT_IRQ_ID);
/* if (Status != XST_SUCCESS) {
xil_printf("UART Interrupt Example Test Failed\r\n");
return XST_FAILURE;
} */
xil_printf("Successfully ran UART Interrupt Example Test\r\n");
xil_printf("count = %i\r\n", count);
return XST_SUCCESS;
cleanup_platform();
return 0;
}
/**
* This main function starts the USB application.
*
*
* @param None.
*
* @return
* - XST_SUCCESS if successful.
* - XST_FAILURE if test fails.
* @note None.
*
*****************************************************************************/
int main()
{
int Status;
u32 ReadRegData = 0;
/*
* Initialize the USB driver.
*/
UsbConfigPtr = XUsb_LookupConfig(USB_DEVICE_ID);
if (NULL == UsbConfigPtr) {
return XST_FAILURE;
}
#ifdef __PPC__
Xil_ICacheEnableRegion (0x80000001);
Xil_DCacheEnableRegion (0x80000001);
#endif
#ifdef __MICROBLAZE__
Xil_ICacheInvalidate();
Xil_ICacheEnable();
Xil_DCacheInvalidate();
Xil_DCacheEnable();
#endif
/*
* We are passing the physical base address as the third argument
* because the physical and virtual base address are the same in our
* example. For systems that support virtual memory, the third
* argument needs to be the virtual base address.
*/
Status = XUsb_CfgInitialize(&UsbInstance,
UsbConfigPtr, UsbConfigPtr->BaseAddress);
if (XST_SUCCESS != Status) {
return XST_FAILURE;
}
XUsb_UlpiIntrSetHandler (&UsbInstance, (void *) UsbIfPhyIntrHandler,
&UsbInstance);
/*
* Setup the interrupt system.
*/
Status = SetupInterruptSystem(&UsbInstance);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Enable the interrupts.
*/
XUsb_IntrEnable(&UsbInstance, XUSB_STATUS_GLOBAL_INTR_MASK |
XUSB_STATUS_PHY_ACCESS_MASK);
XUsb_Start(&UsbInstance);
/*
* Initiate a ULPI register write transaction.
*/
XUsb_UlpiPhyWriteRegister(&UsbInstance, ULPI_SCRATCH_REGISTER,
WRITE_REG_DATA);
/* Wait until the write transaction is done */
while (!PhyAccessDone);
/*
* Read the PHY read register. We do not wait for transaction
* complete interrupt in this case. The API internally polls for the
* completion and then returns the register value read.
*/
ReadRegData = XUsb_UlpiPhyReadRegister(&UsbInstance,
ULPI_SCRATCH_REGISTER);
/* Compare the Written data and read data*/
if (ReadRegData != WRITE_REG_DATA) {
return XST_FAILURE;
}
return XST_SUCCESS;
}
/**
*
* This function does a minimal test on the Rtc device and driver as a
* design example. The purpose of this function is to illustrate
* how to use alarm feature in the XRtcPsu driver.
*
* This function sets alarm for a specified time from the current time.
*
* @param IntcInstPtr is a pointer to the instance of the ScuGic driver.
* @param RtcInstPtr is a pointer to the instance of the RTC driver
* which is going to be connected to the interrupt controller.
* @param DeviceId is the device Id of the RTC device and is typically
* XPAR_<RTCPSU_instance>_DEVICE_ID value from xparameters.h.
* @param RtcIntrId is the interrupt Id and is typically
* XPAR_<RTCPSU_instance>_INTR value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note
*
* This function contains an infinite loop such that if interrupts are not
* working it may never return.
*
**************************************************************************/
int RtcPsuAlarmIntrExample(XScuGic *IntcInstPtr, XRtcPsu *RtcInstPtr,
u16 DeviceId, u16 RtcIntrId)
{
int Status;
XRtcPsu_Config *Config;
u32 CurrentTime, Alarm;
XRtcPsu_DT dt0;
/*
* Initialize the RTC driver so that it's ready to use
* Look up the configuration in the config table, then initialize it.
*/
Config = XRtcPsu_LookupConfig(DeviceId);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XRtcPsu_CfgInitialize(RtcInstPtr, Config, Config->BaseAddr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/* Check hardware build */
Status = XRtcPsu_SelfTest(RtcInstPtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
xil_printf("\n\rDay Convention : 0-Fri, 1-Sat, 2-Sun, 3-Mon, 4-Tue, 5-Wed, 6-Thur\n\r");
xil_printf("Current RTC time is..\n\r");
CurrentTime = XRtcPsu_GetCurrentTime(RtcInstPtr);
XRtcPsu_SecToDateTime(CurrentTime,&dt0);
xil_printf("YEAR:MM:DD HR:MM:SS \t %04d:%02d:%02d %02d:%02d:%02d\t Day = %d\n\r",
dt0.Year,dt0.Month,dt0.Day,dt0.Hour,dt0.Min,dt0.Sec,dt0.WeekDay);
/*
* Connect the RTC to the interrupt subsystem such that interrupts
* can occur. This function is application specific.
*/
Status = SetupInterruptSystem(IntcInstPtr, RtcInstPtr, RtcIntrId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handlers for the RTC that will be called from the
* interrupt context when alarm and seconds interrupts are raised,
* specify a pointer to the RTC driver instance as the callback reference
* so the handlers are able to access the instance data
*/
XRtcPsu_SetHandler(RtcInstPtr, (XRtcPsu_Handler)Handler, RtcInstPtr);
/*
* Enable the interrupt of the RTC device so interrupts will occur.
*/
XRtcPsu_SetInterruptMask(RtcInstPtr, XRTC_INT_EN_ALRM_MASK );
CurrentTime = XRtcPsu_GetCurrentTime(RtcInstPtr);
Alarm = CurrentTime + ALARM_PERIOD;
XRtcPsu_SetAlarm(RtcInstPtr,Alarm,0);
while( IsAlarmGen != 1);
/*
* Disable the interrupt of the RTC device so interrupts will not occur.
*/
XRtcPsu_ClearInterruptMask(RtcInstPtr,XRTC_INT_DIS_ALRM_MASK);
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;
}
/**
*
* This function does a test of the data transfer in simple mode of write only
* mode on the ZDMA driver.
*
* @param DeviceId is the XPAR_<ZDMA Instance>_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;
}
int main(void) {
LOG_INFO("UART CTP FE echo test\n");
init_platform();
tx_buffer = cbuffer_new();
rx_buffer = cbuffer_new();
int Status;
u16 DeviceId = UARTLITE_DEVICE_ID;
/*
* Initialize the UartLite driver so that it's ready to use.
*/
Status = XUartLite_Initialize(&UartLite, DeviceId);
if (Status != XST_SUCCESS) {
LOG_ERROR ("Error: could not initialize UART\n");
return XST_FAILURE;
}
XUartLite_ResetFifos(&UartLite);
/*
* Perform a self-test to ensure that the hardware was built correctly.
*/
Status = XUartLite_SelfTest(&UartLite);
if (Status != XST_SUCCESS) {
LOG_ERROR ("Error: self test failed\n");
return XST_FAILURE;
}
/*
* Connect the UartLite to the interrupt subsystem such that interrupts can
* occur. This function is application specific.
*/
Status = SetupInterruptSystem(&UartLite);
if (Status != XST_SUCCESS) {
LOG_ERROR ("Error: could not setup interrupts\n");
return XST_FAILURE;
}
/*
* Setup the handlers for the UartLite that will be called from the
* interrupt context when data has been sent and received, specify a
* pointer to the UartLite driver instance as the callback reference so
* that the handlers are able to access the instance data.
*/
XUartLite_SetSendHandler(&UartLite, SendHandler, &UartLite);
XUartLite_SetRecvHandler(&UartLite, RecvHandler, &UartLite);
/*
* Enable the interrupt of the UartLite so that interrupts will occur.
*/
XUartLite_EnableInterrupt(&UartLite);
// bootstrap the READ
LOG_DEBUG("Bootstrapping READ\n");
XUartLite_Recv(&UartLite, (u8*)&rx_tmp_buffer, sizeof(uint32_t));
LOG_INFO("Starting loop\n");
/*
LOG_DEBUG("Sending 'wtf!'\n");
currently_sending = 1;
char help[4] = "wtf!";
unsigned int ret = XUartLite_Send(&UartLite, (u8*)help, 4);
LOG_DEBUG("WTF send complete return: %x\n", ret);
*/
/* echo received data forever */
unsigned int heartbeat = 0;
while (1) {
if (heartbeat++ % (1 << 8)) {
//LOG_DEBUG("bump %x\n", heartbeat);
}
while (cbuffer_size(rx_buffer) && cbuffer_freespace(tx_buffer)) {
uint32_t data = cbuffer_pop_front(rx_buffer);
//LOG_DEBUG("Echoing data word %x\n", data);
cbuffer_push_back(tx_buffer, data);
}
if (!currently_sending && cbuffer_size(tx_buffer)) {
LOG_DEBUG("\nREINT SEND\n");
currently_sending = 1;
/*
if (XUartLite_IsSending(&UartLite)) {
LOG_DEBUG("UART STAT: sending\n");
} else {
LOG_DEBUG("UART STAT: idle\n");
}
*/
unsigned int to_send = cbuffer_contiguous_data_size(tx_buffer) * sizeof(uint32_t);
u8* output_ptr = (u8*)&(tx_buffer->data[tx_buffer->pos]);
//LOG_DEBUG("REINIT %x\n", to_send);
//LOG_DEBUG("SENDADDR %x\n", output_ptr);
XUartLite_Send(&UartLite, output_ptr, to_send);
}
}
}
/**
*
* This function does a minimal test on the UartLite device and driver as a
* design example. The purpose of this function is to illustrate
* how to use the XUartLite component.
*
* This function sends data and expects to receive the same data through the
* UartLite. The user must provide a physical loopback such that data which is
* transmitted will be received.
*
* This function uses interrupt driver mode of the UartLite device. The calls
* to the UartLite driver in the handlers should only use the non-blocking
* calls.
*
* @param DeviceId is the Device ID of the UartLite Device and is the
* XPAR_<uartlite_instance>_DEVICE_ID value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note
*
* This function contains an infinite loop such that if interrupts are not
* working it may never return.
*
****************************************************************************/
int UartLiteIntrExample(u16 DeviceId)
{
int Status;
int Index;
/*
* Initialize the UartLite driver so that it's ready to use.
*/
Status = XUartLite_Initialize(&UartLite, DeviceId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to ensure that the hardware was built correctly.
*/
Status = XUartLite_SelfTest(&UartLite);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the UartLite to the interrupt subsystem such that interrupts can
* occur. This function is application specific.
*/
Status = SetupInterruptSystem(&UartLite);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handlers for the UartLite that will be called from the
* interrupt context when data has been sent and received, specify a
* pointer to the UartLite driver instance as the callback reference so
* that the handlers are able to access the instance data.
*/
XUartLite_SetSendHandler(&UartLite, SendHandler, &UartLite);
XUartLite_SetRecvHandler(&UartLite, RecvHandler, &UartLite);
/*
* Enable the interrupt of the UartLite so that interrupts will occur.
*/
XUartLite_EnableInterrupt(&UartLite);
/*
* Initialize the send buffer bytes with a pattern to send and the
* the receive buffer bytes to zero to allow the receive data to be
* verified.
*/
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
SendBuffer[Index] = Index;
ReceiveBuffer[Index] = 0;
}
/*
* Start receiving data before sending it since there is a loopback.
*/
XUartLite_Recv(&UartLite, ReceiveBuffer, TEST_BUFFER_SIZE);
/*
* Send the buffer using the UartLite.
*/
XUartLite_Send(&UartLite, SendBuffer, TEST_BUFFER_SIZE);
/*
* Wait for the entire buffer to be received, letting the interrupt
* processing work in the background, this function may get locked
* up in this loop if the interrupts are not working correctly.
*/
while ((TotalReceivedCount != TEST_BUFFER_SIZE) ||
(TotalSentCount != TEST_BUFFER_SIZE)) {
}
/*
* Verify the entire receive buffer was successfully received.
*/
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
if (ReceiveBuffer[Index] != SendBuffer[Index]) {
return XST_FAILURE;
}
}
return XST_SUCCESS;
}
/**
*
* Main function to execute the Atmel Serial Flash Read/Write example.
*
* @param None.
*
* @return XST_SUCCESS if successful else XST_FAILURE.
*
* @note None.
*
******************************************************************************/
int main(void)
{
int Status;
u16 Index;
XIsf_WriteParam WriteParam;
XIsf_ReadParam ReadParam;
u32 Address;
/*
* Initialize the SPI driver so that it's ready to use,
* specify the device ID that is generated in xparameters.h.
*/
Status = XSpi_Initialize(&Spi, SPI_DEVICE_ID);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the SPI driver to the interrupt subsystem such that
* interrupts can occur. This function is application specific.
*/
Status = SetupInterruptSystem(&Spi);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handler for the SPI that will be called from the interrupt
* context when an SPI status occurs, specify a pointer to the SPI
* driver instance as the callback reference so the handler is able to
* access the instance data.
*/
XIsf_SetStatusHandler(&Isf, &Spi, (XSpi_StatusHandler)SpiHandler);
/*
* Start the SPI driver so that interrupts and the device are enabled.
*/
Status = XSpi_Start(&Spi);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Initialize the In-system and Serial Flash Library.
*/
Status = XIsf_Initialize(&Isf, &Spi, ISF_SPI_SELECT, IsfWriteBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set The transfer Mode to Interrupt
*/
XIsf_SetTransferMode(&Isf,XISF_INTERRUPT_MODE);
/*
* Specify the address in the Serial Flash for the Erase/Write/Read
* operations.
*/
Address = TEST_ADDRESS;
/*
* Perform the Page Erase operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Erase(&Isf, XISF_PAGE_ERASE, Address);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for any errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Serial Flash is ready.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the
* - Address within the Serial Flash where the data is to be written.
* - The number of bytes to be written to the Serial Flash.
* - Write Buffer which contains the data to be written to the Serial
* Flash.
*/
WriteParam.Address = Address;
WriteParam.NumBytes = ISF_PAGE_SIZE;
WriteParam.WritePtr = WriteBuffer;
/*
* Prepare the write buffer. Fill in the data need to be written into
* Serial Flash.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
WriteParam.WritePtr[Index] = Index + ISF_TEST_BYTE;
}
/*
* Perform the Write operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Write(&Isf, XISF_WRITE, (void*) &WriteParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for any errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Serial Flash is ready.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the
* - Address in the Serial Flash where the data is to be read from.
* - Number of bytes to be read from the Serial Flash.
* - Read Buffer to which the data is to be read.
*/
ReadParam.Address = Address;
ReadParam.NumBytes = ISF_PAGE_SIZE;
ReadParam.ReadPtr = ReadBuffer;
/*
* Perform the Read operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Read(&Isf, XISF_READ, (void*) &ReadParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for any errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Compare the Data Read with the Data Written to the Serial Flash.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
if(ReadParam.ReadPtr[Index + XISF_CMD_SEND_EXTRA_BYTES] !=
(u8)(Index + ISF_TEST_BYTE)) {
return XST_FAILURE;
}
}
return XST_SUCCESS;
}
/**
*
* Main function to execute the Numonyx Quad Serial Flash Read/Write example.
*
* @param None
*
* @return XST_SUCCESS if successful else XST_FAILURE.
*
* @note None
*
******************************************************************************/
int main()
{
int Status;
u32 Index;
u32 Address;
XIsf_WriteParam WriteParam;
XIsf_ReadParam ReadParam;
/*
* Initialize the SPI driver so that it's ready to use,
* specify the device ID that is generated in xparameters.h.
*/
Status = XSpi_Initialize(&Spi, SPI_DEVICE_ID);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the SPI driver to the interrupt subsystem such that
* interrupts can occur. This function is application specific.
*/
Status = SetupInterruptSystem(&Spi);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handler for the SPI that will be called from the interrupt
* context when an SPI status occurs, specify a pointer to the SPI
* driver instance as the callback reference so the handler is able to
* access the instance data.
*/
XIsf_SetStatusHandler(&Isf, &Spi, (XSpi_StatusHandler)SpiHandler);
/*
* Start the SPI driver so that interrupts and the device are enabled.
*/
XSpi_Start(&Spi);
/*
* Set the QSPI options
*/
Status = XIsf_SetSpiConfiguration(&Isf, &Spi,
XSP_MASTER_OPTION | XSP_MANUAL_SSELECT_OPTION,
XISF_SPI_PRESCALER);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Initialize the Serial Flash Library.
*/
Status = XIsf_Initialize(&Isf, &Spi, ISF_SPI_SELECT, IsfWriteBuffer);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set The transfer Mode to Interrupt
*/
XIsf_SetTransferMode(&Isf,XISF_INTERRUPT_MODE);
/*
* Specify the address in the Serial Flash for the Erase/Write/Read
* operations.
*/
Address = ISF_TEST_ADDRESS;
/*
* The following code Erases a Sector in the Numonyx Serial Flash.
*/
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform the Sector Erase operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Erase(&Isf, XISF_SECTOR_ERASE, Address);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the
* - Address within the Serial Flash where the data is to be written.
* - Number of bytes to be written to the Serial Flash.
* - Write Buffer which contains the data to be written to the Serial
* Flash.
*/
WriteParam.Address = Address;
WriteParam.NumBytes = ISF_PAGE_SIZE;
WriteParam.WritePtr = WriteBuffer;
/*
* Prepare the write buffer. Fill in the data need to be written into
* Serial Flash.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
WriteParam.WritePtr[Index] = Index + ISF_TEST_BYTE;
}
/*
* Perform the Write operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Write(&Isf, XISF_DUAL_IP_PAGE_WRITE, (void*) &WriteParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read from the flash using Dual Output Fast Read command.
* Set the
* - Address in the Serial Flash where the data is to be read from.
* - Number of bytes to be read from the Serial Flash.
* - Read Buffer to which the data is to be read.
* - Number of dummy bytes for the read command.
*/
ReadParam.Address = Address;
ReadParam.NumBytes = ISF_PAGE_SIZE;
ReadParam.ReadPtr = ReadBuffer;
ReadParam.NumDummyBytes = DUAL_READ_DUMMY_BYTES;
/*
* Clear the read Buffer.
*/
for(Index = 0; Index < ISF_PAGE_SIZE + XISF_CMD_SEND_EXTRA_BYTES +
DUAL_READ_DUMMY_BYTES; Index++) {
ReadBuffer[Index] = 0x0;
}
/*
* Perform the read operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Read(&Isf, XISF_DUAL_OP_FAST_READ, (void*) &ReadParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Compare the data read against the data Written.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
if(ReadBuffer[Index + XISF_CMD_SEND_EXTRA_BYTES +
DUAL_READ_DUMMY_BYTES] !=
(u8)(Index + ISF_TEST_BYTE)) {
return XST_FAILURE;
}
}
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Move to the next page in the flash.
*/
Address += ISF_PAGE_SIZE;
/*
* Set the
* - Address within the Serial Flash where the data is to be written.
* - Number of bytes to be written to the Serial Flash.
* - Write Buffer which contains the data to be written to the Serial
* Flash.
*/
WriteParam.Address = Address;
WriteParam.NumBytes = ISF_PAGE_SIZE;
WriteParam.WritePtr = WriteBuffer;
/*
* Prepare the write buffer. Fill in the data need to be written into
* Serial Flash.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
WriteParam.WritePtr[Index] = Index + ISF_TEST_BYTE;
}
/*
* Perform the Write operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Write(&Isf, XISF_DUAL_IP_EXT_PAGE_WRITE, (void*) &WriteParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read from the flash using Dual Input/Output Fast Read command.
* Set the
* - Address in the Serial Flash where the data is to be read from.
* - Number of bytes to be read from the Serial Flash.
* - Read Buffer to which the data is to be read.
* - Number of dummy bytes for the read command.
*/
ReadParam.Address = Address;
ReadParam.NumBytes = ISF_PAGE_SIZE;
ReadParam.ReadPtr = ReadBuffer;
ReadParam.NumDummyBytes = DUAL_IO_READ_DUMMY_BYTES;
/*
* Clear the read Buffer.
*/
for(Index = 0; Index < ISF_PAGE_SIZE + XISF_CMD_SEND_EXTRA_BYTES +
DUAL_IO_READ_DUMMY_BYTES; Index++) {
ReadBuffer[Index] = 0x0;
}
/*
* Perform the read operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Read(&Isf, XISF_DUAL_IO_FAST_READ, (void*) &ReadParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Compare the data read against the data Written.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
if(ReadBuffer[Index + XISF_CMD_SEND_EXTRA_BYTES +
DUAL_IO_READ_DUMMY_BYTES] !=
(u8)(Index + ISF_TEST_BYTE)) {
return XST_FAILURE;
}
}
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Move to the next page in the flash.
*/
Address += ISF_PAGE_SIZE;
/*
* Set the
* - Address within the Serial Flash where the data is to be written.
* - Number of bytes to be written to the Serial Flash.
* - Write Buffer which contains the data to be written to the Serial
* Flash.
*/
WriteParam.Address = Address;
WriteParam.NumBytes = ISF_PAGE_SIZE;
WriteParam.WritePtr = WriteBuffer;
/*
* Prepare the write buffer. Fill in the data need to be written into
* Serial Flash.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
WriteParam.WritePtr[Index] = Index + ISF_TEST_BYTE;
}
/*
* Perform the Write operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Write(&Isf, XISF_QUAD_IP_PAGE_WRITE, (void*) &WriteParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read from the flash using Quad Output Fast Read command.
* Set the
* - Address in the Serial Flash where the data is to be read from.
* - Number of bytes to be read from the Serial Flash.
* - Read Buffer to which the data is to be read.
* - Number of dummy bytes for the read command.
*/
ReadParam.Address = Address;
ReadParam.NumBytes = ISF_PAGE_SIZE;
ReadParam.ReadPtr = ReadBuffer;
ReadParam.NumDummyBytes = QUAD_READ_DUMMY_BYTES;
/*
* Clear the read Buffer.
*/
for(Index = 0; Index < ISF_PAGE_SIZE + XISF_CMD_SEND_EXTRA_BYTES +
QUAD_READ_DUMMY_BYTES; Index++) {
ReadBuffer[Index] = 0x0;
}
/*
* Perform the read operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Read(&Isf, XISF_QUAD_OP_FAST_READ, (void*) &ReadParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Compare the data read against the data Written.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
if(ReadBuffer[Index + XISF_CMD_SEND_EXTRA_BYTES +
QUAD_READ_DUMMY_BYTES] !=
(u8)(Index + ISF_TEST_BYTE)) {
return XST_FAILURE;
}
}
/*
* Perform the Write Enable operation.
*/
TransferInProgress = TRUE;
Status = XIsf_WriteEnable(&Isf, XISF_WRITE_ENABLE);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Move to the next page in the flash.
*/
Address += ISF_PAGE_SIZE;
/*
* Set the
* - Address within the Serial Flash where the data is to be written.
* - Number of bytes to be written to the Serial Flash.
* - Write Buffer which contains the data to be written to the Serial
* Flash.
*/
WriteParam.Address = Address;
WriteParam.NumBytes = ISF_PAGE_SIZE;
WriteParam.WritePtr = WriteBuffer;
/*
* Prepare the write buffer. Fill in the data need to be written into
* Serial Flash.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
WriteParam.WritePtr[Index] = Index + ISF_TEST_BYTE;
}
/*
* Perform the Write operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Write(&Isf, XISF_QUAD_IP_EXT_PAGE_WRITE,
(void*) &WriteParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Wait till the Flash is not Busy.
*/
Status = IsfWaitForFlashNotBusy();
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Read from the flash using Quad Input/Output Fast Read command.
* Set the
* - Address in the Serial Flash where the data is to be read from.
* - Number of bytes to be read from the Serial Flash.
* - Read Buffer to which the data is to be read.
* - Number of dummy bytes for the read command.
*/
ReadParam.Address = Address;
ReadParam.NumBytes = ISF_PAGE_SIZE;
ReadParam.ReadPtr = ReadBuffer;
ReadParam.NumDummyBytes = QUAD_IO_READ_DUMMY_BYTES;
/*
* Clear the read Buffer.
*/
for(Index = 0; Index < ISF_PAGE_SIZE + XISF_CMD_SEND_EXTRA_BYTES +
QUAD_IO_READ_DUMMY_BYTES; Index++) {
ReadBuffer[Index] = 0x0;
}
/*
* Perform the read operation.
*/
TransferInProgress = TRUE;
Status = XIsf_Read(&Isf, XISF_QUAD_IO_FAST_READ, (void*) &ReadParam);
if(Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the Transfer is complete and check for errors.
*/
while(TransferInProgress);
if(ErrorCount != 0) {
return XST_FAILURE;
}
/*
* Compare the data read against the data written.
*/
for(Index = 0; Index < ISF_PAGE_SIZE; Index++) {
if(ReadBuffer[Index + XISF_CMD_SEND_EXTRA_BYTES +
QUAD_IO_READ_DUMMY_BYTES] !=
(u8)(Index + ISF_TEST_BYTE)) {
return XST_FAILURE;
}
}
return XST_SUCCESS;
}
int main()
{
int Status;
init_platform();
xil_printf("NetFPGA-SUME ddr3B Acceptance Test\r\n");
/*
* Setup Iic Instance
*/
Status = IicInit(&IicInstance);
if (Status != XST_SUCCESS) {
xil_printf("I2C Initialization FAILED\n\r");
return XST_FAILURE;
}
/*
* Setup the Interrupt System.
*/
Status = SetupInterruptSystem(&IicInstance);
if (Status != XST_SUCCESS) {
xil_printf("SetupInterruptSystem FAILED\n\r");
return XST_FAILURE;
}
/*
* Enable Iic Bus
*/
Status = IicInitPost(&IicInstance);
if (Status != XST_SUCCESS) {
xil_printf("I2C Initialization FAILED\n\r");
return XST_FAILURE;
}
Status = ddr3Test_Init();
if (Status != XST_SUCCESS) {
xil_printf("I2C Initialization FAILED\n\r");
return XST_FAILURE;
}
while(1) {
xil_printf("============ NetFPGA-SUME ============\n\r");
xil_printf("a: Auto Test \r\n");
xil_printf("m: Manual Test \r\n");
xil_printf("Select: ");
char cmd = XUartLite_RecvByte(XPAR_AXI_UARTLITE_0_BASEADDR);
xil_printf("%c\r\n", cmd);
switch (cmd) {
case 'a':
runAutoTest();
break;
case 'm':
runManualTest();
break;
default:
break;
}
xil_printf("\r\n");
}
return 0;
}
/**
*
* This function does a minimal test on the Iic device and driver as a
* design example. The purpose of this function is to illustrate
* how to use the XIicPs driver.
*
* This function sends data and expects to receive the same data through the IIC
* using the Aardvark test hardware.
*
* This function uses interrupt driver mode of the IIC.
*
* @param DeviceId is the Device ID of the IicPs Device and is the
* XPAR_<IICPS_instance>_DEVICE_ID value from xparameters.h
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note
*
* This function contains an infinite loop such that if interrupts are not
* working it may never return.
*
*******************************************************************************/
int IicPsMasterIntrExample(u16 DeviceId)
{
int Status;
XIicPs_Config *Config;
int Index;
int tmp;
int BufferSizes[NUMBER_OF_SIZES] = {1, 2, 19, 31, 32, 33, 62, 63, 64,
65, 66, 94, 95, 96, 97, 98, 99, 250};
/*
* Initialize the IIC driver so that it's ready to use
* Look up the configuration in the config table, then initialize it.
*/
Config = XIicPs_LookupConfig(DeviceId);
if (NULL == Config) {
return XST_FAILURE;
}
Status = XIicPs_CfgInitialize(&Iic, Config, Config->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to ensure that the hardware was built correctly.
*/
Status = XIicPs_SelfTest(&Iic);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the IIC to the interrupt subsystem such that interrupts can
* occur. This function is application specific.
*/
Status = SetupInterruptSystem(&Iic);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handlers for the IIC that will be called from the
* interrupt context when data has been sent and received, specify a
* pointer to the IIC driver instance as the callback reference so
* the handlers are able to access the instance data.
*/
XIicPs_SetStatusHandler(&Iic, (void *) &Iic, Handler);
/*
* Set the IIC serial clock rate.
*/
XIicPs_SetSClk(&Iic, IIC_SCLK_RATE);
/*
* Initialize the send buffer bytes with a pattern to send and the
* the receive buffer bytes to zero to allow the receive data to be
* verified.
*/
for (Index = 0; Index < TEST_BUFFER_SIZE; Index++) {
SendBuffer[Index] = (Index % TEST_BUFFER_SIZE);
RecvBuffer[Index] = 0;
}
for(Index = 0; Index < NUMBER_OF_SIZES; Index++) {
/* Wait for bus to become idle
*/
while (XIicPs_BusIsBusy(&Iic)) {
/* NOP */
}
SendComplete = FALSE;
/*
* Send the buffer, errors are reported by TotalErrorCount.
*/
XIicPs_MasterSend(&Iic, SendBuffer, BufferSizes[Index],
IIC_SLAVE_ADDR);
/*
* Wait for the entire buffer to be sent, letting the interrupt
* processing work in the background, this function may get
* locked up in this loop if the interrupts are not working
* correctly.
*/
while (!SendComplete) {
if (0 != TotalErrorCount) {
return XST_FAILURE;
}
}
/*
* Wait bus activities to finish.
*/
while (XIicPs_BusIsBusy(&Iic)) {
/* NOP */
}
/*
* Receive data from slave, errors are reported through
* TotalErrorCount.
*/
RecvComplete = FALSE;
XIicPs_MasterRecv(&Iic, RecvBuffer, BufferSizes[Index],
IIC_SLAVE_ADDR);
while (!RecvComplete) {
if (0 != TotalErrorCount) {
return XST_FAILURE;
}
}
/* Check for received data.
*/
for(tmp = 0; tmp < BufferSizes[Index]; tmp ++) {
/*
* Aardvark as slave can only set up to 64 bytes for
* output.
*/
if (RecvBuffer[tmp] != tmp % 64) {
return XST_FAILURE;
}
}
}
return XST_SUCCESS;
}
/**
* The function reads the temperature of the IIC temperature sensor on the
* IIC bus. It initializes the IIC device driver and sets it up to communicate
* with the temperature sensor. This function does contain a loop that polls
* for completion of the IIC processing such that it may not return if
* interrupts or the hardware are not working.
*
* @param IicDeviceId is the XPAR_<IIC_instance>_DEVICE_ID value from
* xparameters.h for the IIC Device
* @param TempSensorAddress is the address of the Temperature Sensor device
* on the IIC bus
* @param TemperaturePtr is the data byte read from the temperature sensor
*
* @return XST_SUCCESS to indicate success, else XST_FAILURE to indicate
* a Failure.
*
* @note None.
*
*******************************************************************************/
int TempSensorExample(u16 IicDeviceId, u8 TempSensorAddress, u8 *TemperaturePtr)
{
int Status;
static int Initialized = FALSE;
XIic_Config *ConfigPtr; /* Pointer to configuration data */
if (!Initialized) {
Initialized = TRUE;
/*
* Initialize the IIC driver so that it is ready to use.
*/
ConfigPtr = XIic_LookupConfig(IicDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XIic_CfgInitialize(&Iic, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup handler to process the asynchronous events which occur,
* the driver is only interrupt driven such that this must be
* done prior to starting the device.
*/
XIic_SetRecvHandler(&Iic, (void *)&HandlerInfo, RecvHandler);
XIic_SetStatusHandler(&Iic, (void *)&HandlerInfo,
StatusHandler);
/*
* Connect the ISR to the interrupt and enable interrupts.
*/
Status = SetupInterruptSystem(&Iic);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Start the IIC driver such that it is ready to send and
* receive messages on the IIC interface, set the address
* to send to which is the temperature sensor address
*/
XIic_Start(&Iic);
XIic_SetAddress(&Iic, XII_ADDR_TO_SEND_TYPE, TempSensorAddress);
}
/*
* Clear updated flags such that they can be polled to indicate
* when the handler information has changed asynchronously and
* initialize the status which will be returned to a default value
*/
HandlerInfo.EventStatusUpdated = FALSE;
HandlerInfo.RecvBytesUpdated = FALSE;
Status = XST_FAILURE;
/*
* Attempt to receive a byte of data from the temperature sensor
* on the IIC interface, ignore the return value since this example is
* a single master system such that the IIC bus should not ever be busy
*/
(void)XIic_MasterRecv(&Iic, TemperaturePtr, 1);
/*
* The message is being received from the temperature sensor,
* wait for it to complete by polling the information that is
* updated asynchronously by interrupt processing
*/
while(1) {
if(HandlerInfo.RecvBytesUpdated == TRUE) {
/*
* The device information has been updated for receive
* processing,if all bytes received (1), indicate
* success
*/
if (HandlerInfo.RemainingRecvBytes == 0) {
Status = XST_SUCCESS;
}
break;
}
/*
* Any event status which occurs indicates there was an error,
* so return unsuccessful, for this example there should be no
* status events since there is a single master on the bus
*/
if (HandlerInfo.EventStatusUpdated == TRUE) {
break;
}
}
return Status;
}
/**
*
* This function does a minimal test on the Spi device and driver as a design
* example. The purpose of this function is to illustrate the device slave
* functionality in interrupt mode. This function receives data from a master and
* prints the received data.
*
* @param SpiInstancePtr is a pointer to the instance of Spi component.
* @param SpiDeviceId is the Device ID of the Spi Device and is the
* XPAR_<SPI_instance>_DEVICE_ID value from xparameters.h.
*
* @return XST_SUCCESS if successful, otherwise XST_FAILURE.
*
* @note This function contains an infinite loop such that if the Spi
* device doesn't receive any data or if the interrupts are not
* working, it may never return.
*
******************************************************************************/
static int SpiSlaveIntrExample(XSpi *SpiInstancePtr, u16 SpiDeviceId)
{
XSpi_Config *ConfigPtr;
int Status;
u32 Count;
xil_printf("\r\nEntering the Spi Slave Interrupt Example.\r\n");
xil_printf("Waiting for data from SPI master\r\n");
/*
* Initialize the SPI driver so that it's ready to use, specify the
* device ID that is generated in xparameters.h.
*/
ConfigPtr = XSpi_LookupConfig(SpiDeviceId);
if (ConfigPtr == NULL) {
return XST_FAILURE;
}
Status = XSpi_CfgInitialize(SpiInstancePtr, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the SPI driver to the interrupt subsystem such that
* interrupts can occur. This function is application specific.
*/
Status = SetupInterruptSystem(SpiInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Setup the handler for the SPI that will be called from the interrupt
* context when an SPI status occurs, specify a pointer to the SPI
* driver instance as the callback reference so the handler is able to
* access the instance data.
*/
XSpi_SetStatusHandler(SpiInstancePtr,SpiInstancePtr,(XSpi_StatusHandler)
SpiHandler);
/*
* The SPI device is a slave by default and the clock phase and polarity
* have to be set according to its master. In this example, CPOL is set
* to active low and CPHA is set to 1.
*/
Status = XSpi_SetOptions(SpiInstancePtr, XSP_CLK_PHASE_1_OPTION |
XSP_CLK_ACTIVE_LOW_OPTION);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Start the SPI driver so that the device is enabled.
*/
XSpi_Start(SpiInstancePtr);
/*
* Enable the DTR half-empty interrupt while transfering more than
* FIFO_DEPTH number of bytes in slave mode, so that the Tx FIFO
* is never empty during a transfer. If the Tx FIFO is empty during
* a transfer, it results in master receiving invalid data.
*/
XSpi_IntrEnable(SpiInstancePtr, XSP_INTR_TX_HALF_EMPTY_MASK);
/*
* Initialize the write buffer with pattern to write, initialize the
* read buffer to zero so it can be verified after the read.
*/
Test = 0x50;
for (Count = 0; Count < BUFFER_SIZE; Count++) {
WriteBuffer[Count] = (u8)(Count + Test);
ReadBuffer[Count] = 0;
}
/*
* Transmit data as a slave, when the master starts sending data.
*/
TransferInProgress = TRUE;
Status = XSpi_Transfer(SpiInstancePtr, WriteBuffer, ReadBuffer,
BUFFER_SIZE);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Wait till the transfer is complete.
*/
while (TransferInProgress == TRUE);
/*
* Print all the data received from the master.
*/
xil_printf("\r\nReceived data is:\r\n");
for (Count = 0; Count < BUFFER_SIZE; Count++) {
xil_printf("0x%x \r\n", ReadBuffer[Count]);
}
xil_printf("\r\nExiting the Spi Slave Interrupt Example.\r\n");
return XST_SUCCESS;
}
/*Copyright (c) 2015, Adam Taylor
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project*/
int main()
{
XScuTimer_Config *TMRConfigPtr; //timer config
XBram_Config *ConfigPtr;
unsigned int inchar;
unsigned int newlr;
int rx_pix;
int r, g, b;
unsigned int state = 0;
init_platform();
ConfigPtr = XBram_LookupConfig(BRAM_DEVICE_ID);
XBram_CfgInitialize(&Bram, ConfigPtr,ConfigPtr->CtrlBaseAddress);
TMRConfigPtr = XScuTimer_LookupConfig(TIMER_DEVICE_ID);
XScuTimer_CfgInitialize(&Timer, TMRConfigPtr,TMRConfigPtr->BaseAddr);
SetupInterruptSystem(&Intc,&Timer,TIMER_IRPT_INTR);
while(1){
// printf(":>");
if (state == 0){
numb_pixels = max_pixel;
inchar = getchar();
newlr = getchar();
printf("option %x",inchar);
switch (inchar){
case 0x02:
printf("<STX>");
state = 1;
break;
case 0x03:
printf("<ETX>\n");
break;
}
}
if (state == 1){
inchar = getchar();
newlr = getchar();
rx_pix = inchar;
state = 2;
printf("pixel number = %d",rx_pix);
}
if (state == 2){
inchar = getchar();
newlr = getchar();
g = inchar;
state = 3;
printf("green = %x",g);
}
if (state == 3){
inchar = getchar();
newlr = getchar();
r = inchar;
state = 4;
printf("red = %x",r);
}
if (state == 4){
inchar = getchar();
newlr = getchar();
b = inchar;
state = 5;
printf("blue = %x",b);
}
if (state == 5){
inchar = getchar();
newlr = getchar();
switch (inchar){
case 0x02:
printf("<STX>");
state = 6;
break;
case 0x03:
printf("<ETX>\n");
state = 6;
break;
}
}
if (state == 6){
pixel[rx_pix] = (u32)b | ((u32)r << 8) | ((u32)g <<16);
load_ram();
state = 0;
}
}
return 0;
}
