Asynchronous SPI

Hi,

I use SPI to get data from an Analog/Digital converter. I have a userspace C++ program that does the following:

struct spi_ioc_transfer tr;
tr.tx_buf = (unsigned long) tx;
tr.rx_buf = (unsigned long) rx;
tr.len = size;
tr.delay_usecs = 0;
tr.speed_hz = this->speed;
tr.bits_per_word = 8;
tr.cs_change = 0;

if(ioctl(this->file, SPI_IOC_MESSAGE(1), &tr) < 1)
// Error checking skipped

tx and rx are defined like this:

char tx[] = { 0x06, 0x80, 0x00 };
char rx[3];

The first 1,5 Bytes of tx contain the measurement request and the converter writes the result into the last 1,5 Bytes of rx. All works well.

Unfortunately, the whole thing is way too slow. It blocks for 6,6ms on my board, which is not what i want. Is there a possibility to speed the call up or at least do it asynchronously, so that the application can do something useful in the mean time (Apart from spawning an additional thread)?

Thanks for any ideas

David

Hi, check <linux kernel source directory>/Documentation/spi/spi_summary. I worked with SPI some years ago and it worked very well, but I don't remember the details right now.

Thanks for your reply.

The documentation you suggested describes how to build an SPI driver. Am I supposed to write my own driver? I have never done that before... Do you expect a large performance advantage over the userspace API?

I'm sorry, that document is just where I had found out CPOL and CPHA values, but I guess it's the only reference I wrote down back then.

Here are some fragments of the code I wrote years ago.

Initialization:

int             spidev_fd;
uint8_t         spi_tx_buf,
                spi_mode,
                spi_bpw;
uint8_t         spi_rx_buf = 0;
uint16_t        spi_delay_us = 0; // if nonzero, how long to delay after the last bit transfer before optionally deselecting
                                  // the device before the next transfer
uint32_t        spi_speed;

static const char * spi_device = "/dev/spidev0.0";

// open SPI device
spidev_fd = open(spi_device, O_RDWR);

// set SPI mode
spi_mode |= SPI_CPHA;
ret = ioctl(spidev_fd, SPI_IOC_WR_MODE, &spi_mode);
ret = ioctl(spidev_fd, SPI_IOC_RD_MODE, &spi_mode);

// set number of bits per word
spi_bpw = 8;
ret = ioctl(spidev_fd, SPI_IOC_WR_BITS_PER_WORD, &spi_bpw);
ret = ioctl(spidev_fd, SPI_IOC_RD_BITS_PER_WORD, &spi_bpw);

// set max speed (in Hz)
spi_speed = 500 * 1000;
ret = ioctl(spidev_fd, SPI_IOC_WR_MAX_SPEED_HZ, &spi_speed);
ret = ioctl(spidev_fd, SPI_IOC_RD_MAX_SPEED_HZ, &spi_speed);

Inside a function "spi_transfer" I put:

struct spi_ioc_transfer tr = {
         .tx_buf = (unsigned long) &spi_tx_buf,
         .rx_buf = (unsigned long) &spi_rx_buf,
         .len = sizeof(spi_tx_buf),
         .delay_usecs = spi_delay_us,
         .speed_hz = spi_speed,
         .bits_per_word = spi_bpw,
};

ret = ioctl(spidev_fd, SPI_IOC_MESSAGE(1), &tr);

And then I used, for example:

spi_tx_buf = 0; // send anything to get data from the ADC
spi_transfer();
fsr = spi_rx_buf; // FSR0 (Reset Value = 0x59)

I'm not coding for embedded boards anymore, but I'm willing to recall what I did if it helps you.

Regards,
Esteban

Hi, thanks for your reply!

Unfortunately, this is already the way I'm doing it and it's too slow. But thanks anyway for your help.

I have almost exactly the same problem. But the unwanted delay varies between 6-30 ms. Were you able to come up with a solution?