/***************************************************************************//**
* @brief spi_init
*******************************************************************************/
int32_t spi_init(uint32_t device_id,
uint8_t clk_pha,
uint8_t clk_pol)
{
uint32_t base_addr = 0;
uint32_t control_val = 0;
#ifdef _XPARAMETERS_PS_H_
uint8_t byte = 0;
spi_config = XSpiPs_LookupConfig(device_id);
base_addr = spi_config->BaseAddress;
XSpiPs_CfgInitialize(&spi_instance, spi_config, base_addr);
control_val = XSPIPS_CR_SSFORCE_MASK |
XSPIPS_CR_SSCTRL_MASK |
4 << XSPIPS_CR_PRESC_SHIFT |
(clk_pha ? XSPIPS_CR_CPHA_MASK : 0) |
(clk_pol ? XSPIPS_CR_CPOL_MASK : 0) |
XSPIPS_CR_MSTREN_MASK;
XSpiPs_WriteReg(base_addr, XSPIPS_CR_OFFSET, control_val);
for(byte = 0; byte < 128; byte++)
{
XSpiPs_ReadReg(base_addr, XSPIPS_RXD_OFFSET);
}
#else
XSpi_Initialize(&spi_instance, device_id);
XSpi_Stop(&spi_instance);
spi_config = XSpi_LookupConfig(device_id);
base_addr = spi_config->BaseAddress;
XSpi_CfgInitialize(&spi_instance, spi_config, base_addr);
control_val = XSP_MASTER_OPTION |
XSP_CLK_PHASE_1_OPTION |
XSP_MANUAL_SSELECT_OPTION;
XSpi_SetOptions(&spi_instance, control_val);
XSpi_Start(&spi_instance);
XSpi_IntrGlobalDisable(&spi_instance);
XSpi_SetSlaveSelect(&spi_instance, 1);
#endif
return SUCCESS;
}
int ACL_SPIInit(XSpi *SpiInstancePtr){
int Status;
XSpi_Config *ConfigPtr; /* Pointer to Configuration data */
/*
* Initialize the SPI driver so that it is ready to use.
*/
ConfigPtr = &XSpi_ACLConfig;
if (ConfigPtr == NULL) {
return XST_DEVICE_NOT_FOUND;
}
Status = XSpi_CfgInitialize(SpiInstancePtr, ConfigPtr, ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSpi_SetOptions(SpiInstancePtr, (XSP_MASTER_OPTION | XSP_CLK_ACTIVE_LOW_OPTION | XSP_CLK_PHASE_1_OPTION) | XSP_MANUAL_SSELECT_OPTION); //Manual SS off
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSpi_SetSlaveSelect(SpiInstancePtr, 1);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Start the SPI driver so that the device is enabled.
*/
XSpi_Start(SpiInstancePtr);
/*
* Disable Global interrupt to use polled mode operation
*/
XSpi_IntrGlobalDisable(SpiInstancePtr);
return XST_SUCCESS;
}
/***************************************************************************//**
* @brief spi_init
*******************************************************************************/
int32_t spi_init(uint32_t device_id,
uint8_t clk_pha,
uint8_t clk_pol)
{
uint32_t base_addr = 0;
uint32_t spi_options = 0;
#ifdef _XPARAMETERS_PS_H_
spi_config = XSpiPs_LookupConfig(device_id);
base_addr = spi_config->BaseAddress;
XSpiPs_CfgInitialize(&spi_instance, spi_config, base_addr);
spi_options = XSPIPS_MASTER_OPTION |
(clk_pol ? XSPIPS_CLK_ACTIVE_LOW_OPTION : 0) |
(clk_pha ? XSPIPS_CLK_PHASE_1_OPTION : 0) |
XSPIPS_FORCE_SSELECT_OPTION;
XSpiPs_SetOptions(&spi_instance, spi_options);
XSpiPs_SetClkPrescaler(&spi_instance, XSPIPS_CLK_PRESCALE_256);
#else
XSpi_Initialize(&spi_instance, device_id);
XSpi_Stop(&spi_instance);
spi_config = XSpi_LookupConfig(device_id);
base_addr = spi_config->BaseAddress;
XSpi_CfgInitialize(&spi_instance, spi_config, base_addr);
spi_options = XSP_MASTER_OPTION |
XSP_CLK_PHASE_1_OPTION |
XSP_MANUAL_SSELECT_OPTION;
XSpi_SetOptions(&spi_instance, spi_options);
XSpi_Start(&spi_instance);
XSpi_IntrGlobalDisable(&spi_instance);
XSpi_SetSlaveSelect(&spi_instance, 1);
#endif
return SUCCESS;
}
/**
*
* This function does a minimal test on the Spi device and driver as a
* design example. The purpose of this function is to illustrate how to use
* the XSpi component using the polled mode.
*
* This function sends data and expects to receive the same 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 is not
* working it may never return.
*
******************************************************************************/
int SpiPolledExample(XSpi *SpiInstancePtr, u16 SpiDeviceId)
{
int Status;
u32 Count;
XSpi_Config *ConfigPtr; /* Pointer to Configuration data */
/*
* Initialize the SPI driver so that it is ready to use.
*/
ConfigPtr = XSpi_LookupConfig(SpiDeviceId);
if (ConfigPtr == NULL) {
return XST_DEVICE_NOT_FOUND;
}
Status = XSpi_CfgInitialize(SpiInstancePtr, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to ensure that the hardware was built correctly.
*/
Status = XSpi_SelfTest(SpiInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run loopback test only in case of standard SPI mode.
*/
if (SpiInstancePtr->SpiMode != XSP_STANDARD_MODE) {
return XST_SUCCESS;
}
/*
* Set the Spi device as a master and in loopback mode.
*/
Status = XSpi_SetOptions(SpiInstancePtr, XSP_MASTER_OPTION | XSP_MANUAL_SSELECT_OPTION);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Start the SPI driver so that the device is enabled.
*/
XSpi_Start(SpiInstancePtr);
/*
* Disable Global interrupt to use polled mode operation
*/
XSpi_IntrGlobalDisable(SpiInstancePtr);
/*
* Initialize the write buffer with pattern to write, initialize 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.
*/
/*
* Transmit the data.
*/
/*Init ADCL*/
SpiInstancePtr->SlaveSelectReg = 0x00000000;
ADXL362_Init(SpiInstancePtr);
DelayMs(1);
while(1)
{
int x = 0, y=0, z=0, temp;
x= ADXL362_ReadX(SpiInstancePtr);
y= ADXL362_ReadY(SpiInstancePtr);
z= ADXL362_ReadZ(SpiInstancePtr);
temp = ADXL362_ReadTemp(SpiInstancePtr);
DelayMs(5);
xil_printf("X: %d\r\n", x);
xil_printf("Y: %d\r\n", y);
xil_printf("Z: %d\r\n", z);
xil_printf("temperature: %d\r\n", temp);
}
SpiInstancePtr->SlaveSelectReg = 0x0000001;
return XST_SUCCESS;
}
/**
*
* This function does a minimal test on the Spi device and driver as a
* design example. The purpose of this function is to illustrate how to use
* the XSpi component using the polled mode.
*
* This function sends data and expects to receive the same 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 is not
* working it may never return.
*
******************************************************************************/
int SpiPolledExample(XSpi *SpiInstancePtr, u16 SpiDeviceId)
{
int Status;
u32 Count;
u8 Test;
XSpi_Config *ConfigPtr; /* Pointer to Configuration data */
/*
* Initialize the SPI driver so that it is ready to use.
*/
ConfigPtr = XSpi_LookupConfig(SpiDeviceId);
if (ConfigPtr == NULL) {
return XST_DEVICE_NOT_FOUND;
}
Status = XSpi_CfgInitialize(SpiInstancePtr, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to ensure that the hardware was built correctly.
*/
Status = XSpi_SelfTest(SpiInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run loopback test only in case of standard SPI mode.
*/
if (SpiInstancePtr->SpiMode != XSP_STANDARD_MODE) {
return XST_SUCCESS;
}
/*
* Set the Spi device as a master and in loopback mode.
*/
Status = XSpi_SetOptions(SpiInstancePtr, XSP_MASTER_OPTION |
XSP_LOOPBACK_OPTION);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Start the SPI driver so that the device is enabled.
*/
XSpi_Start(SpiInstancePtr);
/*
* Disable Global interrupt to use polled mode operation
*/
XSpi_IntrGlobalDisable(SpiInstancePtr);
/*
* Initialize the write buffer with pattern to write, initialize 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.
*/
Test = 0x10;
for (Count = 0; Count < BUFFER_SIZE; Count++) {
WriteBuffer[Count] = (u8)(Count + Test);
ReadBuffer[Count] = 0;
}
/*
* Transmit the data.
*/
XSpi_Transfer(SpiInstancePtr, WriteBuffer, ReadBuffer, BUFFER_SIZE);
/*
* Compare the data received with the data that was transmitted.
*/
for (Count = 0; Count < BUFFER_SIZE; Count++) {
if (WriteBuffer[Count] != ReadBuffer[Count]) {
return XST_FAILURE;
}
}
return XST_SUCCESS;
}
int main() {
xil_printf("Master SPI oRSC echo test\n");
// initialize stdout.
init_platform();
tx_buffer = cbuffer_new();
rx_buffer = cbuffer_new();
spi_stream = spi_stream_init(
tx_buffer, rx_buffer,
DoSpiTransfer, // callback which triggers a SPI transfer
0);
int Status;
XSpi_Config *ConfigPtr; /* Pointer to Configuration data */
/*
* Initialize the SPI driver so that it is ready to use.
*/
ConfigPtr = XSpi_LookupConfig(SPI_DEVICE_ID);
if (ConfigPtr == NULL) {
xil_printf ("Error: could not lookup SPI configuration\n");
return XST_DEVICE_NOT_FOUND;
}
Status = XSpi_CfgInitialize(&SpiInstance, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
xil_printf("Error: could not initialize the SPI device\n");
return XST_FAILURE;
}
Status = XSpi_SelfTest(&SpiInstance);
if (Status != XST_SUCCESS) {
xil_printf("Error: The SPI self test failed.\n");
return XST_FAILURE;
}
/*
* Connect the Spi device to the interrupt subsystem such that
* interrupts can occur. This function is application specific.
*/
Status = SpiSetupIntrSystem(&IntcInstance, &SpiInstance, SPI_IRPT_INTR);
if (Status != XST_SUCCESS) {
xil_printf("Error: Could not setup interrupt system.\n");
return XST_FAILURE;
}
/*
* Set the Spi device as a master.
*/
Status = XSpi_SetOptions(&SpiInstance, XSP_MASTER_OPTION);
if (Status != XST_SUCCESS) {
xil_printf("Error: Could not set as master\n");
return XST_FAILURE;
}
// Go!
XSpi_Start(&SpiInstance);
// Note: to disable interrupt, do: XIntc_Disconnect(&IntcInstance,
// SPI_IRPT_INTR);
u32 expected_rx = 0;
u32 current_tx = 0;
while (1) {
// fill up the transmit buffer
while (cbuffer_freespace(tx_buffer)) {
cbuffer_push_back(tx_buffer, current_tx++);
}
// check to make sure the received buffer is what we expect
while (cbuffer_size(rx_buffer)) {
u32 front = cbuffer_value_at(rx_buffer, 0);
if (front != expected_rx) {
//xil_printf("Error: expected %lx, got %lx!\n", expected_rx, front);
xil_printf("Error: data value\n");
}
expected_rx++;
cbuffer_deletefront(rx_buffer, 1);
}
}
return 0;
}
/**
*
* 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 polled 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, it may never return.
*
******************************************************************************/
int SpiSlavePolledExample(XSpi *SpiInstancePtr, u16 SpiDeviceId)
{
XSpi_Config *ConfigPtr;
int Status;
u32 Count;
xil_printf("\r\nEntering the Spi Slave Polled 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;
}
/*
* 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);
/*
* Disable Global interrupt to use polled mode operation.
*/
XSpi_IntrGlobalDisable(SpiInstancePtr);
/*
* Initialize the write buffer with pattern to write, initialize the
* read buffer to zero so that it can be verified after the read.
*/
Test = 0xF0;
for (Count = 0; Count < BUFFER_SIZE; Count++) {
WriteBuffer[Count] = (u8)(Count + Test);
ReadBuffer[Count] = 0;
}
/*
* Prepare the data buffers for transmission and to send/receive data
* when the SPI device is selected by a master.
*/
XSpi_Transfer(SpiInstancePtr, WriteBuffer, ReadBuffer, BUFFER_SIZE);
/*
* Print all the data received from the master so that it can be
* compared with the data sent by 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 Polled Example.\r\n");
return XST_SUCCESS;
}
static int xspi_probe(struct device *dev)
{
dev_t devt;
XSpi_Config xspi_cfg;
struct platform_device *pdev = to_platform_device(dev);
struct xspi_platform_data *pdata;
struct xspi_instance *inst;
struct resource *irq_res, *regs_res;
unsigned long remap_size;
int retval;
if (!dev)
return -EINVAL;
pdata = (struct xspi_platform_data *) pdev->dev.platform_data;
if (!pdata) {
printk(KERN_ERR XSPI_NAME " %d: Couldn't find platform data.\n",
pdev->id);
return -ENODEV;
}
devt = MKDEV(xspi_major, xspi_minor + pdev->id);
inst = kzalloc(sizeof(struct xspi_instance), GFP_KERNEL);
if (!inst) {
printk(KERN_ERR XSPI_NAME " #%d: Could not allocate device.\n",
pdev->id);
return -ENOMEM;
}
dev_set_drvdata(dev, (void *)inst);
init_MUTEX(&inst->sem);
init_waitqueue_head(&inst->waitq);
/* Find irq number, map the control registers in */
irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
regs_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!regs_res || !irq_res) {
printk(KERN_ERR XSPI_NAME" #%d: IO resource(s) not found\n",
pdev->id);
retval = -EFAULT;
goto failed1;
}
inst->irq = irq_res->start;
remap_size = regs_res->end - regs_res->start + 1;
if (!request_mem_region(regs_res->start, remap_size, XSPI_NAME)) {
printk(KERN_ERR XSPI_NAME
" #%d: Couldn't lock memory region at 0x%08lX\n",
pdev->id, regs_res->start);
retval = -EBUSY;
goto failed1;
}
inst->remap_size = remap_size;
inst->phys_addr = regs_res->start;
inst->device_id = pdev->id;
xspi_cfg.DeviceId = pdev->id;
xspi_cfg.HasFifos = (pdata->device_flags & XSPI_HAS_FIFOS) ? 1 : 0;
xspi_cfg.SlaveOnly = (pdata->device_flags & XSPI_SLAVE_ONLY) ? 1 : 0;
xspi_cfg.NumSlaveBits = pdata->num_slave_bits;
if(check_spi_config(&xspi_cfg)) {
printk(KERN_ERR XSPI_NAME
" #%d: Unsupported hardware configuration\n", pdev->id);
retval = -ENODEV;
goto failed1;
}
xspi_cfg.BaseAddress = (u32) ioremap(regs_res->start, remap_size);
if (xspi_cfg.BaseAddress == 0) {
printk(KERN_ERR XSPI_NAME
" #%d: Couldn't ioremap memory at 0x%08lX\n",
pdev->id, regs_res->start);
retval = -EFAULT;
goto failed2;
}
/* Tell the Xilinx code to bring this SPI interface up. */
if (XSpi_CfgInitialize(&inst->Spi, &xspi_cfg) != XST_SUCCESS) {
printk(KERN_ERR XSPI_NAME " #%d: Could not initialize device.\n",
pdev->id);
retval = -ENODEV;
goto failed3;
}
/* Set interrupt callback */
XSpi_SetStatusHandler(&inst->Spi, inst, xspi_status_handler);
/* request_irq() is done in open() */
cdev_init(&inst->cdev, &xspi_fops);
inst->cdev.owner = THIS_MODULE;
retval = cdev_add(&inst->cdev, devt, 1);
if (retval) {
printk(KERN_ERR XSPI_NAME " #%d: cdev_add() failed\n",
pdev->id);
goto failed3;
}
printk(KERN_INFO XSPI_NAME
" %d: at 0x%08X mapped to 0x%08X, irq=%d\n",
pdev->id, inst->phys_addr, inst->Spi.BaseAddr, inst->irq);
return 0; /* success */
failed3:
iounmap((void *) (xspi_cfg.BaseAddress));
failed2:
release_mem_region(regs_res->start, remap_size);
failed1:
kfree(inst);
return retval;
}
void LEDPIN_Init(void)
{
int Status;
Status = XGpio_Initialize(&dc, XPAR_AXI_GPIO_0_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XGpio_Initialize(&reset, XPAR_AXI_GPIO_1_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XGpio_Initialize(&led1, XPAR_AXI_GPIO_2_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XGpio_Initialize(&led2, XPAR_AXI_GPIO_3_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XGpio_SetDataDirection(&dc, DC_CHANNEL, 0x0);
XGpio_DiscreteWrite(&dc, DC_CHANNEL, 0x0);
XGpio_SetDataDirection(&reset, reset_CHANNEL, 0x0);
XGpio_DiscreteWrite(&reset, reset_CHANNEL, 0x0);
XGpio_SetDataDirection(&led1, reset_CHANNEL, 0x0);
XGpio_DiscreteWrite(&led1, reset_CHANNEL, 0x0);
XGpio_SetDataDirection(&led2, reset_CHANNEL, 0x0);
XGpio_DiscreteWrite(&led2, reset_CHANNEL, 0x0);
XGpio_DiscreteWrite(&led2, reset_CHANNEL, 0x1);
XSpi_Config *ConfigPtr; /* Pointer to Configuration data */
/*
* Initialize the SPI driver so that it is ready to use.
*/
ConfigPtr = XSpi_LookupConfig(SPI_DEVICE_ID);
if (ConfigPtr == NULL) {
return XST_DEVICE_NOT_FOUND;
}
Status = XSpi_CfgInitialize(&Spi, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to ensure that the hardware was built correctly
*/
Status = XSpi_SelfTest(&Spi);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
Status = XSpi_SetOptions(&Spi, XSP_MASTER_OPTION | XSP_CLK_ACTIVE_LOW_OPTION );//| XSP_CR_CLK_POLARITY_MASK | XSP_CR_CLK_PHASE_MASK);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
XGpio_DiscreteWrite(&led2, reset_CHANNEL, 0x0);
}
// | XSP_CR_CPOL_MASK|XSP_CR_CPHA_MASK);
//XSpiPs_SetClkPrescaler(&Spi, XSPIPS_CLK_PRESCALE_256);
XSpi_SetSlaveSelect(&Spi, 0x1);
//XSpi_Start(&Spi);
Status = XSpi_Start(&Spi);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
XSpi_IntrGlobalDisable(&Spi);
/*Status = XSpi_SetSlaveSelect(&Spi, 0x1);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}*/
}
/**
*
* 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;
}
/**
*
* This function does a minimal test on the Spi device and driver as a
* design example. The purpose of this function is to illustrate how to use
* the XSpi component using the interrupt mode.
*
* This function sends data and expects to receive the same data.
*
*
* @param IntcInstancePtr is a pointer to the instance of the INTC
* component.
* @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.
* @param SpiIntrId is the interrupt Id and is typically
* XPAR_<INTC_instance>_<SPI_instance>_VEC_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 SpiIntrExample(XIntc *IntcInstancePtr, XSpi *SpiInstancePtr,
u16 SpiDeviceId, u16 SpiIntrId)
{
int Status;
u32 Count;
u8 Test;
XSpi_Config *ConfigPtr; /* Pointer to Configuration data */
/*
* Initialize the SPI driver so that it is ready to use.
*/
ConfigPtr = XSpi_LookupConfig(SpiDeviceId);
if (ConfigPtr == NULL) {
return XST_DEVICE_NOT_FOUND;
}
Status = XSpi_CfgInitialize(SpiInstancePtr, ConfigPtr,
ConfigPtr->BaseAddress);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Perform a self-test to ensure that the hardware was built correctly.
*/
Status = XSpi_SelfTest(SpiInstancePtr);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Run loopback test only in case of standard SPI mode.
*/
if (SpiInstancePtr->SpiMode != XSP_STANDARD_MODE) {
return XST_SUCCESS;
}
/*
* 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.
*/
XSpi_SetStatusHandler(SpiInstancePtr, SpiInstancePtr,
(XSpi_StatusHandler) SpiIntrHandler);
/*
* Set the Spi device as a master and in loopback mode.
*/
Status = XSpi_SetOptions(SpiInstancePtr, XSP_MASTER_OPTION |
XSP_LOOPBACK_OPTION);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/*
* Start the SPI driver so that interrupts and the device are enabled.
*/
XSpi_Start(SpiInstancePtr);
/*
* Initialize the write buffer with pattern to write, initialize 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.
*/
Test = 0x10;
for (Count = 0; Count < BUFFER_SIZE; Count++) {
WriteBuffer[Count] = (u8)(Count + Test);
ReadBuffer[Count] = 0;
}
/*
* Transmit the data.
*/
TransferInProgress = TRUE;
XSpi_Transfer(SpiInstancePtr, WriteBuffer, ReadBuffer, BUFFER_SIZE);
/*
* Wait for the transmission to be complete.
*/
while (TransferInProgress);
/*
* Disable the Spi interrupt.
*/
SpiDisableIntrSystem(IntcInstancePtr, SpiIntrId);
/*
* Compare the data received with the data that was transmitted.
*/
for (Count = 0; Count < BUFFER_SIZE; Count++) {
if (WriteBuffer[Count] != ReadBuffer[Count]) {
return XST_FAILURE;
}
}
return XST_SUCCESS;
}
int Mrf24j::initDrivers(void)
{
// TODO: check pin direction
/*pinMode(_pin_reset, OUTPUT);
pinMode(_pin_cs, OUTPUT);
pinMode(_pin_int, INPUT);*/
XSpi_Config *SPIConfigPtr;
XGpio_Config *GPIOConfigPtr;
int status;
/*
* Initialize the SPI driver so that it is ready to use.
*/
SPIConfigPtr = XSpi_LookupConfig(XPAR_SPI_0_DEVICE_ID);
if (SPIConfigPtr == NULL)
{
return XST_DEVICE_NOT_FOUND;
}
status = XSpi_CfgInitialize(&MSpiInstance, SPIConfigPtr, SPIConfigPtr->BaseAddress);
if (status != XST_SUCCESS)
{
return XST_FAILURE;
}
/*
* Set the Spi device as a master.
*/
status = XSpi_SetOptions( &MSpiInstance, XSP_MASTER_OPTION | XSP_MANUAL_SSELECT_OPTION ); //TO DO, add msb first config
if (status != XST_SUCCESS)
{
return XST_FAILURE;
}
/*
* Start the SPI driver so that the device is enabled.
*/
XSpi_Start(&MSpiInstance);
/*
* Disable Global interrupt to use polled mode operation
*/
XSpi_IntrGlobalDisable(&MSpiInstance);
//GPIO config
GPIOConfigPtr = XGpio_LookupConfig(XPAR_GPIO_1_DEVICE_ID);
status = XGpio_CfgInitialize(&gpioInstance, GPIOConfigPtr, GPIOConfigPtr->BaseAddress);
if (status != XST_SUCCESS)
{
return XST_FAILURE;
}
XGpio_SetDataDirection(&gpioInstance, 1, 0x1); //check data direction
XGpio_DiscreteWrite(&gpioInstance, 1, 0x6); //check register, check wake pin if it is ok high
//for(int i = 0; i < 20; i++)
//{
//u32 intr = XGpio_InterruptGetEnabled(&gpioInstance);
//u32 sts = XGpio_InterruptGetStatus(&gpioInstance);
//XGpio_InterruptClear(&gpioInstance, XGPIO_IR_CH1_MASK);
///sts = XGpio_InterruptGetStatus(&gpioInstance);
//u32 usts = sts;
//}
/*SPI.setBitOrder(MSBFIRST) ;
SPI.setDataMode(SPI_MODE0);
SPI.begin();*/
return XST_SUCCESS;
}
void OledHostInit()
{
XSpi_Config *SPIConfigPtr;
XGpio_Config *GPIOConfigPtr;
int status;
/*
* Initialize the SPI driver so that it is ready to use.
*/
SPIConfigPtr = XSpi_LookupConfig(XPAR_SPI_1_DEVICE_ID);
if (SPIConfigPtr == NULL)
{
printf("OledHostInit: ERROR: SPI device not found");
}
status = XSpi_CfgInitialize(&SpiInstance, SPIConfigPtr, SPIConfigPtr->BaseAddress);
if (status != XST_SUCCESS)
{
printf("OledHostInit: ERROR: cannot init SPI");
}
/*
* Set the Spi device as a master.
*/
status = XSpi_SetOptions( &SpiInstance, XSP_MASTER_OPTION | XSP_MANUAL_SSELECT_OPTION |
XSP_CLK_ACTIVE_LOW_OPTION | XSP_CLK_PHASE_1_OPTION);
if (status != XST_SUCCESS)
{
printf("OledHostInit: ERROR: set SPI options");
}
/*
* Start the SPI driver so that the device is enabled.
*/
XSpi_Start(&SpiInstance);
/*
* Disable Global interrupt to use polled mode operation
*/
XSpi_IntrGlobalDisable(&SpiInstance);
u32 slaveReg = XSpi_GetSlaveSelectReg(&SpiInstance);
XSpi_SetSlaveSelectReg(&SpiInstance, 0x00);
slaveReg = XSpi_GetSlaveSelectReg(&SpiInstance);
//GPIO config
GPIOConfigPtr = XGpio_LookupConfig(XPAR_GPIO_0_DEVICE_ID);
if (GPIOConfigPtr == NULL)
{
printf("OledHostInit: ERROR: GPIO device not found");
}
status = XGpio_CfgInitialize(&gpioInstance, GPIOConfigPtr, GPIOConfigPtr->BaseAddress);
if (status != XST_SUCCESS)
{
printf("OledHostInit: ERROR: cannot init GPIO");
}
XGpio_SetDataDirection(&gpioInstance, 1, 0xf0);
XGpio_DiscreteWrite(&gpioInstance, 1, 0x0F);
}
