/*****************************************************************************
*
* The purpose of this function is to illustrate how to use the XSpiPs
* device driver in polled mode. This function writes and reads data
* from a serial flash.
*
* @param SpiPtr is a pointer to the SPI driver instance to use.
*
* @param SpiDeviceId is the Instance Id of SPI in the system.
*
* @return
* - XST_SUCCESS if successful
* - XST_FAILURE if not successful
*
* @note
*
* If the device slave select is not correct and the device is not responding
* on bus it will read a status of 0xFF for the status register as the bus
* is pulled up.
*
*****************************************************************************/
int SpiPsFlashPolledExample(XSpiPs *SpiInstancePtr,
u16 SpiDeviceId)
{
int Status;
u8 *BufferPtr;
u8 UniqueValue;
u32 Count;
XSpiPs_Config *SpiConfig;
/*
* Initialize the SPI driver so that it's ready to use
*/
SpiConfig = XSpiPs_LookupConfig(SpiDeviceId);
if (NULL == SpiConfig) {
return XST_FAILURE;
}
Status = XSpiPs_CfgInitialize(SpiInstancePtr, SpiConfig,
SpiConfig->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to check hardware build
*/
Status = XSpiPs_SelfTest(SpiInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the SPI device as a master with manual start and manual
* chip select mode options
*/
XSpiPs_SetOptions(SpiInstancePtr, XSPIPS_MANUAL_START_OPTION | \
XSPIPS_MASTER_OPTION | XSPIPS_FORCE_SSELECT_OPTION);
/*
* Set the SPI device pre-scalar to divide by 8
*/
XSpiPs_SetClkPrescaler(SpiInstancePtr, XSPIPS_CLK_PRESCALE_8);
memset(WriteBuffer, 0x00, sizeof(WriteBuffer));
memset(ReadBuffer, 0x00, sizeof(ReadBuffer));
/*
* Initialize the write buffer for a pattern to write to the Flash
* and the read buffer to zero so it can be verified after the read, the
* test value that is added to the unique value allows the value to be
* changed in a debug environment to guarantee
*/
for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MAX_DATA;
Count++, UniqueValue++) {
WriteBuffer[DATA_OFFSET + Count] = (u8)(UniqueValue);
}
/*
* Set the flash chip select
*/
XSpiPs_SetSlaveSelect(SpiInstancePtr, FLASH_SPI_SELECT);
/*
* Read the flash Id
*/
Status = FlashReadID();
if (Status != XST_SUCCESS) {
xil_printf("SPI Flash Polled Example Read ID Failed\r\n");
return XST_FAILURE;
}
/*
* Erase the flash
*/
FlashErase(SpiInstancePtr);
TestAddress = 0x0;
/*
* Write the data in the write buffer to TestAddress in serial flash
*/
FlashWrite(SpiInstancePtr, TestAddress, MAX_DATA, WRITE_CMD);
/*
* Read the contents of the flash from TestAddress of size MAX_DATA
* using Normal Read command
*/
FlashRead(SpiInstancePtr, TestAddress, MAX_DATA, READ_CMD);
/*
* Setup a pointer to the start of the data that was read into the read
* buffer and verify the data read is the data that was written
*/
BufferPtr = &ReadBuffer[DATA_OFFSET];
for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MAX_DATA;
Count++, UniqueValue++) {
if (BufferPtr[Count] != (u8)(UniqueValue)) {
return XST_FAILURE;
}
}
memset(WriteBuffer, 0x00, sizeof(WriteBuffer));
memset(ReadBuffer, 0x00, sizeof(ReadBuffer));
/*
* Initialize the write buffer for a pattern to write to the Flash
* and the read buffer to zero so it can be verified after the read, the
* test value that is added to the unique value allows the value to be
* changed in a debug environment to guarantee
*/
for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MAX_DATA;
Count++, UniqueValue++) {
WriteBuffer[DATA_OFFSET + Count] = (u8)(UniqueValue);
}
/*
* Set the SPI device as a master with auto start and manual
* chip select mode options
*/
XSpiPs_SetOptions(SpiInstancePtr, XSPIPS_MASTER_OPTION | \
XSPIPS_FORCE_SSELECT_OPTION);
/*
* Erase the flash
*/
FlashErase(SpiInstancePtr);
TestAddress = 0x0;
/*
* Write the data in the write buffer to TestAddress in serial flash
*/
FlashWrite(SpiInstancePtr, TestAddress, MAX_DATA, WRITE_CMD);
/*
* Read the contents of the flash from TestAddress of size MAX_DATA
* using Normal Read command
*/
FlashRead(SpiInstancePtr, TestAddress, MAX_DATA, READ_CMD);
/*
* Setup a pointer to the start of the data that was read into the read
* buffer and verify the data read is the data that was written
*/
BufferPtr = &ReadBuffer[DATA_OFFSET];
for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MAX_DATA;
Count++, UniqueValue++) {
if (BufferPtr[Count] != (u8)(UniqueValue)) {
return XST_FAILURE;
}
}
return XST_SUCCESS;
}
/*****************************************************************************
*
* The purpose of this function is to illustrate how to use the XSpiPs
* device driver in polled mode. This test writes and reads data from a
* serial EEPROM. The serial EEPROM part must be present in the hardware
* to use this example.
*
* @param SpiInstancePtr is a pointer to the Spi Instance.
* @param SpiDeviceId is the Device Id of Spi.
*
* @return XST_SUCCESS if successful else XST_FAILURE.
*
* @note
*
* This function calls functions which contain loops that may be infinite
* if interrupts are not working such that it may not return. If the device
* slave select is not correct and the device is not responding on bus it will
* read a status of 0xFF for the status register as the bus is pulled up.
*
*****************************************************************************/
int SpiPsEepromPolledExample(XSpiPs *SpiInstancePtr, u16 SpiDeviceId)
{
int Status;
u8 *BufferPtr;
u8 UniqueValue;
int Count;
int Page;
XSpiPs_Config *SpiConfig;
/*
* Initialize the SPI driver so that it's ready to use
*/
SpiConfig = XSpiPs_LookupConfig(SpiDeviceId);
if (NULL == SpiConfig) {
return XST_FAILURE;
}
Status = XSpiPs_CfgInitialize(SpiInstancePtr, SpiConfig,
SpiConfig->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to check hardware build
*/
Status = XSpiPs_SelfTest(SpiInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Set the Spi device as a master. External loopback is required.
*/
XSpiPs_SetOptions(SpiInstancePtr, XSPIPS_MASTER_OPTION |
XSPIPS_FORCE_SSELECT_OPTION);
XSpiPs_SetClkPrescaler(SpiInstancePtr, XSPIPS_CLK_PRESCALE_64);
/*
* Initialize the write buffer for a pattern to write to the EEPROM
* and the read buffer to zero so it can be verified after the read, the
* test value that is added to the unique value allows the value to be
* changed in a debug environment to guarantee
*/
for (UniqueValue = 13, Count = 0; Count < MAX_DATA;
Count++, UniqueValue++) {
WriteBuffer[WRITE_DATA_OFFSET + Count] =
(u8)(UniqueValue + Test);
ReadBuffer[READ_DATA_OFFSET + Count] = 0xA5;
}
/*
* Assert the EEPROM chip select
*/
XSpiPs_SetSlaveSelect(SpiInstancePtr, EEPROM_SPI_SELECT);
/*
* Write the data in the write buffer to the serial EEPROM a page at a
* time, read the data back from the EEPROM and verify it
*/
UniqueValue = 13;
for (Page = 0; Page < PAGE_COUNT; Page++) {
EepromWrite(SpiInstancePtr, Page * PAGE_SIZE, PAGE_SIZE,
&WriteBuffer[Page * PAGE_SIZE]);
EepromRead(SpiInstancePtr, Page * PAGE_SIZE, PAGE_SIZE,
ReadBuffer);
BufferPtr = &ReadBuffer[READ_DATA_OFFSET];
for (Count = 0; Count < PAGE_SIZE; Count++, UniqueValue++) {
if (BufferPtr[Count] != (u8)(UniqueValue + Test)) {
return XST_FAILURE;
}
}
}
return XST_SUCCESS;
}
/*****************************************************************************
*
* The purpose of this function is to illustrate how to use the XSpiPs
* device driver in interrupt mode. This function writes and reads data
* from a serial flash.
*
* @param IntcInstancePtr is a pointer to Interrupt Controller instance.
*
* @param SpiInstancePtr is a pointer to the SPI driver instance to use.
*
* @param SpiDeviceId is the Instance Id of SPI in the system.
*
* @param SpiIntrId is the Interrupt Id for SPI in the system.
*
* @param None.
*
* @return
* - XST_SUCCESS if successful
* - XST_FAILURE if not successful
*
* @note
*
* This function calls other functions which contain loops that may be infinite
* if interrupts are not working such that it may not return. If the device
* slave select is not correct and the device is not responding on bus it will
* read a status of 0xFF for the status register as the bus is pulled up.
*
*****************************************************************************/
int SpiPsFlashIntrExample(XScuGic *IntcInstancePtr, XSpiPs *SpiInstancePtr,
u16 SpiDeviceId, u16 SpiIntrId)
{
int Status;
u8 *BufferPtr;
u8 UniqueValue;
u32 Count;
u32 MaxSize = MAX_DATA;
u32 ChipSelect = FLASH_SPI_SELECT_1;
XSpiPs_Config *SpiConfig;
if (XGetPlatform_Info() == XPLAT_ZYNQ_ULTRA_MP) {
MaxSize = 1024 * 10;
ChipSelect = FLASH_SPI_SELECT_0; /* Device is on CS 0 */
SpiIntrId = XPAR_XSPIPS_0_INTR;
}
/*
* Initialize the SPI driver so that it's ready to use
*/
SpiConfig = XSpiPs_LookupConfig(SpiDeviceId);
if (NULL == SpiConfig) {
return XST_FAILURE;
}
Status = XSpiPs_CfgInitialize(SpiInstancePtr, SpiConfig,
SpiConfig->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to check hardware build
*/
Status = XSpiPs_SelfTest(SpiInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the Spi device to the interrupt subsystem such that
* interrupts can occur. This function is application specific
*/
Status = SpiPsSetupIntrSystem(IntcInstancePtr, SpiInstancePtr,
SpiIntrId);
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
*/
XSpiPs_SetStatusHandler(SpiInstancePtr, SpiInstancePtr,
(XSpiPs_StatusHandler) SpiPsHandler);
/*
* Set the SPI device as a master with manual start and manual
* chip select mode options
*/
XSpiPs_SetOptions(SpiInstancePtr, XSPIPS_MANUAL_START_OPTION | \
XSPIPS_MASTER_OPTION | XSPIPS_FORCE_SSELECT_OPTION);
/*
* Set the SPI device pre-scalar to divide by 8
*/
XSpiPs_SetClkPrescaler(SpiInstancePtr, XSPIPS_CLK_PRESCALE_8);
memset(WriteBuffer, 0x00, sizeof(WriteBuffer));
memset(ReadBuffer, 0x00, sizeof(ReadBuffer));
/*
* Initialize the write buffer for a pattern to write to the flash
* and the read buffer to zero so it can be verified after the read, the
* test value that is added to the unique value allows the value to be
* changed in a debug environment to guarantee
*/
for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MaxSize;
Count++, UniqueValue++) {
WriteBuffer[DATA_OFFSET + Count] = (u8)(UniqueValue);
}
/*
* Assert the flash chip select
*/
XSpiPs_SetSlaveSelect(SpiInstancePtr, ChipSelect);
/*
* Read the flash ID
*/
Status = FlashReadID(SpiInstancePtr);
if (Status != XST_SUCCESS) {
xil_printf("SPI FLASH Interrupt Example Read ID Failed\r\n");
return XST_FAILURE;
}
/*
* Erase the flash
*/
FlashErase(SpiInstancePtr);
/*
* Write the data in the write buffer to TestAddress in serial flash
*/
FlashWrite(SpiInstancePtr, TestAddress, MaxSize, WRITE_CMD);
/*
* Read the contents of the flash from TestAddress of size MAX_DATA
* using Normal Read command
*/
FlashRead(SpiInstancePtr, TestAddress, MaxSize, READ_CMD);
/*
* Setup a pointer to the start of the data that was read into the read
* buffer and verify the data read is the data that was written
*/
BufferPtr = &ReadBuffer[DATA_OFFSET];
for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MaxSize;
Count++, UniqueValue++) {
if (BufferPtr[Count] != (u8)(UniqueValue)) {
return XST_FAILURE;
}
}
/*
* Set the SPI device as a master with auto start and manual
* chip select mode options
*/
XSpiPs_SetOptions(SpiInstancePtr, XSPIPS_MASTER_OPTION | \
XSPIPS_FORCE_SSELECT_OPTION);
memset(WriteBuffer, 0x00, sizeof(WriteBuffer));
memset(ReadBuffer, 0x00, sizeof(ReadBuffer));
/*
* Initialize the write buffer for a pattern to write to the flash
* and the read buffer to zero so it can be verified after the read, the
* test value that is added to the unique value allows the value to be
* changed in a debug environment to guarantee
*/
for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MaxSize;
Count++, UniqueValue++) {
WriteBuffer[DATA_OFFSET + Count] = (u8)(UniqueValue);
}
/*
* Erase the flash
*/
FlashErase(SpiInstancePtr);
/*
* Write the data in the write buffer to TestAddress in serial flash
*/
FlashWrite(SpiInstancePtr, TestAddress, MaxSize, WRITE_CMD);
/*
* Read the contents of the flash from TestAddress of size MAX_DATA
* using Normal Read command
*/
FlashRead(SpiInstancePtr, TestAddress, MaxSize, READ_CMD);
/*
* Setup a pointer to the start of the data that was read into the read
* buffer and verify the data read is the data that was written
*/
BufferPtr = &ReadBuffer[DATA_OFFSET];
for (UniqueValue = UNIQUE_VALUE, Count = 0; Count < MaxSize;
Count++, UniqueValue++) {
if (BufferPtr[Count] != (u8)(UniqueValue)) {
return XST_FAILURE;
}
}
SpiPsDisableIntrSystem(IntcInstancePtr, SpiIntrId);
return XST_SUCCESS;
}
/*****************************************************************************
*
* The purpose of this function is to illustrate how to use the XSpiPs
* device driver in interrupt mode . This test writes and reads data from a
* serial EEPROM.
* This part must be present in the hardware to use this example.
*
* @param IntcInstancePtr is a pointer to the GIC driver to use.
* @param SpiInstancePtr is a pointer to the SPI driver to use.
* @param SpiDeviceId is the DeviceId of the Spi device.
* @param SpiIntrId is the Spi Interrupt Id.
*
* @return XST_SUCCESS if successful else XST_FAILURE.
*
* @note
*
* This function calls functions which contain loops that may be infinite
* if interrupts are not working such that it may not return. If the device
* slave select is not correct and the device is not responding on bus it will
* read a status of 0xFF for the status register as the bus is pulled up.
*
*****************************************************************************/
int SpiPsEepromIntrExample(XScuGic *IntcInstancePtr, XSpiPs *SpiInstancePtr,
u16 SpiDeviceId, u16 SpiIntrId)
{
int Status;
u8 *BufferPtr;
u8 UniqueValue;
int Count;
int Page;
XSpiPs_Config *SpiConfig;
/*
* Initialize the SPI driver so that it's ready to use
*/
SpiConfig = XSpiPs_LookupConfig(SpiDeviceId);
if (NULL == SpiConfig) {
return XST_FAILURE;
}
Status = XSpiPs_CfgInitialize(SpiInstancePtr, SpiConfig,
SpiConfig->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to check hardware build
*/
Status = XSpiPs_SelfTest(SpiInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Connect the Spi device to the interrupt subsystem such that
* interrupts can occur. This function is application specific
*/
Status = SpiSetupIntrSystem(IntcInstancePtr, SpiInstancePtr, SpiIntrId);
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
*/
XSpiPs_SetStatusHandler(SpiInstancePtr, SpiInstancePtr,
(XSpiPs_StatusHandler) SpiHandler);
/*
* Set the Spi device as a master. External loopback is required.
*/
XSpiPs_SetOptions(SpiInstancePtr, XSPIPS_MASTER_OPTION |
XSPIPS_FORCE_SSELECT_OPTION);
XSpiPs_SetClkPrescaler(SpiInstancePtr, XSPIPS_CLK_PRESCALE_64);
/*
* Initialize the write buffer for a pattern to write to the EEPROM
* and the read buffer to zero so it can be verified after the read, the
* test value that is added to the unique value allows the value to be
* changed in a debug environment to guarantee
*/
for (UniqueValue = 13, Count = 0; Count < MAX_DATA;
Count++, UniqueValue++) {
WriteBuffer[WRITE_DATA_OFFSET + Count] =
(u8)(UniqueValue + Test);
ReadBuffer[READ_DATA_OFFSET + Count] = 0xA5;
}
/*
* Assert the EEPROM chip select
*/
XSpiPs_SetSlaveSelect(SpiInstancePtr, EEPROM_SPI_SELECT);
/*
* Write the data in the write buffer to the serial EEPROM a page at a
* time
*/
for (Page = 0; Page < PAGE_COUNT; Page++) {
EepromWrite(SpiInstancePtr, Page * PAGE_SIZE, PAGE_SIZE,
&WriteBuffer[Page * PAGE_SIZE]);
}
/*
* Read the contents of the entire EEPROM from address 0, since this
* function reads the entire EEPROM it will take some amount of time to
* complete
*/
EepromRead(SpiInstancePtr, 0, MAX_DATA, ReadBuffer);
/*
* Setup a pointer to the start of the data that was read into the read
* buffer and verify the data read is the data that was written
*/
BufferPtr = &ReadBuffer[READ_DATA_OFFSET];
for (UniqueValue = 13, Count = 0; Count < MAX_DATA;
Count++, UniqueValue++) {
if (BufferPtr[Count] != (u8)(UniqueValue + Test)) {
return XST_FAILURE;
}
}
SpiDisableIntrSystem(IntcInstancePtr, SpiIntrId);
return XST_SUCCESS;
}
