linux+spi通讯同步,和菜鸟一起学linux总线驱动之初识spi驱动数据传输流程

对于SPI的一些结构体都有所了解之后呢，那么再去瞧瞧SPI的那些长见的操作的函数了。

首先看一下本人画的比较挫的数据流了，仅供参考，如有不对，不吝赐教

接下来看看各个函数吧还是：

SPI write

/**

* spi_write - SPI synchronous write

* @spi: device to which data will be written

* @buf: data buffer

* @len: data buffer size

* Context: can sleep

*

* This writes the buffer and returns zero or a negative error code.

* Callable only from contexts that can sleep.

*/

static inline int

spi_write(struct spi_device *spi, const void *buf, size_t len)

{

struct spi_transfer   t= {

.tx_buf=buf,

.len=len,

};

struct spi_message  m;

spi_message_init(&m);

spi_message_add_tail(&t, &m);

return spi_sync(spi, &m);

}

SPI发送函数，数据放在buf中，然后把要发送的数据放在工作队列中

SPI  read

/**

* spi_read - SPI synchronous read

* @spi: device from which data will be read

* @buf: data buffer

* @len: data buffer size

* Context: can sleep

*

* This reads the buffer and returns zero or a negative error code.

* Callable only from contexts that can sleep.

*/

static inline int

spi_read(struct spi_device *spi, void *buf, size_t len)

{

struct spi_transfer   t= {

.rx_buf=buf,

.len=len,

};

struct spi_message  m;

spi_message_init(&m);

spi_message_add_tail(&t, &m);

return spi_sync(spi, &m);

}

SPI接收函数，数据放在buf中，然后把要发送的数据放在工作队列中，发送出去

SPI write 8 bits read 8 bits

/* this copies txbuf and rxbuf data; for small transfers only! */

extern int spi_write_then_read(struct spi_device *spi,

const void *txbuf, unsigned n_tx,

void *rxbuf, unsigned n_rx);

/**

* spi_w8r8 - SPI synchronous 8 bit write followed by 8 bit read

* @spi: device with which data will be exchanged

* @cmd: command to be written before data is read back

* Context: can sleep

*

* This returns the (unsigned) eight bit number returned by the

* device, or else a negative error code.  Callable only from

* contexts that can sleep.

*/

static inline ssize_t spi_w8r8(struct spi_device *spi, u8 cmd)

{

ssize_t                   status;

u8                  result;

status=spi_write_then_read(spi, &cmd, 1, &result, 1);

/* return negative errno or unsigned value */

return (status <0) ? status : result;

}

SPI write 8 bit read 16 bits

/**

* spi_w8r16 - SPI synchronous 8 bit write followed by 16 bit read

* @spi: device with which data will be exchanged

* @cmd: command to be written before data is read back

* Context: can sleep

*

* This returns the (unsigned) sixteen bit number returned by the

* device, or else a negative error code.  Callable only from

* contexts that can sleep.

*

* The number is returned in wire-order, which is at least sometimes

* big-endian.

*/

static inline ssize_t spi_w8r16(struct spi_device *spi, u8 cmd)

{

ssize_t                   status;

u16                result;

status=spi_write_then_read(spi, &cmd, 1, (u8 *) &result, 2);

/* return negative errno or unsigned value */

return (status <0) ? status : result;

}

int spi_write_then_read(struct spi_device *spi,

const void *txbuf, unsigned n_tx,

void *rxbuf, unsigned n_rx)

{

static DEFINE_MUTEX(lock);

int                 status;

struct spi_message  message;

struct spi_transfer   x[2];

u8                  *local_buf;

/* Use preallocated DMA-safe buffer.  We can't avoid copying here,

* (as a pure convenience thing), but we can keep heap costs

* out of the hot path ...

*/

if ((n_tx + n_rx) >SPI_BUFSIZ)

return -EINVAL;

spi_message_init(&message);

memset(x, 0, sizeof x);

if (n_tx) {