spi与i2c

一 主要数据结构

struct spi_device {
struct device		dev;
struct spi_master	*master;
u32			max_speed_hz;
u8			chip_select;
u8			mode;
#define	SPI_CPHA	0x01			/* clock phase */
#define	SPI_CPOL	0x02			/* clock polarity */
#define	SPI_MODE_0	(0|0)			/* (original MicroWire) */
#define	SPI_MODE_1	(0|SPI_CPHA)
#define	SPI_MODE_2	(SPI_CPOL|0)
#define	SPI_MODE_3	(SPI_CPOL|SPI_CPHA)
#define	SPI_CS_HIGH	0x04			/* chipselect active high? */
#define	SPI_LSB_FIRST	0x08			/* per-word bits-on-wire */
#define	SPI_3WIRE	0x10			/* SI/SO signals shared */
#define	SPI_LOOP	0x20			/* loopback mode */
#define	SPI_NO_CS	0x40			/* 1 dev/bus, no chipselect */
#define	SPI_READY	0x80			/* slave pulls low to pause */
u8			bits_per_word;
int			irq;
void			*controller_state;
void			*controller_data;
char			modalias[SPI_NAME_SIZE];
int			cs_gpio;	/* chip select gpio */

/*
* likely need more hooks for more protocol options affecting how
* the controller talks to each chip, like:
*  - memory packing (12 bit samples into low bits, others zeroed)
*  - priority
*  - drop chipselect after each word
*  - chipselect delays
*  - ...
*/
};

spi从设备，相当于i2c_client。它需要依附一个spi_master。

struct spi_master {
struct device	dev;

struct list_head list;

/* other than negative (== assign one dynamically), bus_num is fully
* board-specific.  usually that simplifies to being SOC-specific.
* example:  one SOC has three SPI controllers, numbered 0..2,
* and one board's schematics might show it using SPI-2.  software
* would normally use bus_num=2 for that controller.
*/
s16			bus_num;

/* chipselects will be integral to many controllers; some others
* might use board-specific GPIOs.
*/
u16			num_chipselect;

/* some SPI controllers pose alignment requirements on DMAable
* buffers; let protocol drivers know about these requirements.
*/
u16			dma_alignment;

/* spi_device.mode flags understood by this controller driver */
u16			mode_bits;

/* other constraints relevant to this driver */
u16			flags;
#define SPI_MASTER_HALF_DUPLEX	BIT(0)		/* can't do full duplex */
#define SPI_MASTER_NO_RX	BIT(1)		/* can't do buffer read */
#define SPI_MASTER_NO_TX	BIT(2)		/* can't do buffer write */

/* lock and mutex for SPI bus locking */
spinlock_t		bus_lock_spinlock;
struct mutex		bus_lock_mutex;

/* flag indicating that the SPI bus is locked for exclusive use */
bool			bus_lock_flag;

/* Setup mode and clock, etc (spi driver may call many times).
*
* IMPORTANT:  this may be called when transfers to another
* device are active.  DO NOT UPDATE SHARED REGISTERS in ways
* which could break those transfers.
*/
int			(*setup)(struct spi_device *spi);

/* bidirectional bulk transfers
*
* + The transfer() method may not sleep; its main role is
*   just to add the message to the queue.
* + For now there's no remove-from-queue operation, or
*   any other request management
* + To a given spi_device, message queueing is pure fifo
*
* + The master's main job is to process its message queue,
*   selecting a chip then transferring data
* + If there are multiple spi_device children, the i/o queue
*   arbitration algorithm is unspecified (round robin, fifo,
*   priority, reservations, preemption, etc)
*
* + Chipselect stays active during the entire message
*   (unless modified by spi_transfer.cs_change != 0).
* + The message transfers use clock and SPI mode parameters
*   previously established by setup() for this device
*/
int			(*transfer)(struct spi_device *spi,
struct spi_message *mesg);

/* called on release() to free memory provided by spi_master */
void			(*cleanup)(struct spi_device *spi);

/*
* These hooks are for drivers that want to use the generic
* master transfer queueing mechanism. If these are used, the
* transfer() function above must NOT be specified by the driver.
* Over time we expect SPI drivers to be phased over to this API.
*/
bool				queued;
struct kthread_worker		kworker;
struct task_struct		*kworker_task;
struct kthread_work		pump_messages;
spinlock_t			queue_lock;
struct list_head		queue;
struct spi_message		*cur_msg;
bool				busy;
bool				running;
bool				rt;

int (*prepare_transfer_hardware)(struct spi_master *master);
int (*transfer_one_message)(struct spi_master *master,
struct spi_message *mesg);
int (*unprepare_transfer_hardware)(struct spi_master *master);
/* gpio chip select */
int			*cs_gpios;
};

spi_master代表一个spi主设备，相当于i2c_adapter；与硬件上的物理总线相对应。它的通信方法没有另外定义结构；而是集成到自己内部了。

struct spi_driver {
const struct spi_device_id *id_table;
int			(*probe)(struct spi_device *spi);
int			(*remove)(struct spi_device *spi);
void			(*shutdown)(struct spi_device *spi);
int			(*suspend)(struct spi_device *spi, pm_message_t mesg);
int			(*resume)(struct spi_device *spi);
struct device_driver	driver;
};

driver都需要和device进行bound，不为device服务的drvier，是没有存在意义的。

struct spi_transfer {
/* it's ok if tx_buf == rx_buf (right?)
* for MicroWire, one buffer must be null
* buffers must work with dma_*map_single() calls, unless
*   spi_message.is_dma_mapped reports a pre-existing mapping
*/
const void	*tx_buf;
void		*rx_buf;
unsigned	len;

dma_addr_t	tx_dma;
dma_addr_t	rx_dma;

unsigned	cs_change:1;
u8		bits_per_word;
u16		delay_usecs;
u32		speed_hz;

struct list_head transfer_list;
};

struct spi_message {
struct list_head	transfers;

struct spi_device	*spi;

unsigned		is_dma_mapped:1;

/* REVISIT:  we might want a flag affecting the behavior of the
* last transfer ... allowing things like "read 16 bit length L"
* immediately followed by "read L bytes".  Basically imposing
* a specific message scheduling algorithm.
*
* Some controller drivers (message-at-a-time queue processing)
* could provide that as their default scheduling algorithm.  But
* others (with multi-message pipelines) could need a flag to
* tell them about such special cases.
*/

/* completion is reported through a callback */
void			(*complete)(void *context);
void			*context;
unsigned		actual_length;
int			status;

/* for optional use by whatever driver currently owns the
* spi_message ...  between calls to spi_async and then later
* complete(), that's the spi_master controller driver.
*/
struct list_head	queue;
void			*state;
};

spi_transfer定义了一对读写buffer，还有一个transfer_list；利用这个list把自己挂在spi_message的transfers上，也就是这两个结构合起来相当于i2c_msg。spi的传输单位就是一个spi_message。

struct spi_board_info {
/* the device name and module name are coupled, like platform_bus;
* "modalias" is normally the driver name.
*
* platform_data goes to spi_device.dev.platform_data,
* controller_data goes to spi_device.controller_data,
* irq is copied too
*/
char		modalias[SPI_NAME_SIZE];
const void	*platform_data;
void		*controller_data;
int		irq;

/* slower signaling on noisy or low voltage boards */
u32		max_speed_hz;

/* bus_num is board specific and matches the bus_num of some
* spi_master that will probably be registered later.
*
* chip_select reflects how this chip is wired to that master;
* it's less than num_chipselect.
*/
u16		bus_num;
u16		chip_select;

/* mode becomes spi_device.mode, and is essential for chips
* where the default of SPI_CS_HIGH = 0 is wrong.
*/
u8		mode;

/* ... may need additional spi_device chip config data here.
* avoid stuff protocol drivers can set; but include stuff
* needed to behave without being bound to a driver:
*  - quirks like clock rate mattering when not selected
*/
};

spi device的info，与i2c_board_info类似。

二 主要函数接口

static int spi_match_device(struct device *dev, struct device_driver *drv)

相当于i2c_device_match()，i2c_device_match()->i2c_match_id()->strcmp(client->name, id->name)匹配成功返回1，否则0，结束。

spi_match_device()->spi_match_id()->strcmp(sdev->modalias, id->name))仍然是匹配成功返回1，否则返回0。不同的是，对应i2c_device_match()，如果i2c_drvier中没有定义id_table，那直接就返回0了。而spi不是，它还会继续strcmp(spi->modalias, drv->name)根据这个确定返回值。所以我们看到i2c_driver中都会定义id_table，而spi_driver有时不定义，只保证pi->modalias和drv->name一致就好了。

struct spi_device *spi_new_device(struct spi_master *master, struct spi_board_info *chip)

调用spi_alloc_device(master)分配一个spi_device；

调用spi_add_device(proxy)把分配的spi_device添加到系统中，spi_device是一种device，添加device必然会调用 device_add(&spi->dev)。

spi_add_device()->spi_setup(spi)->( spi->master->setup(spi)这是用于设置spi的mode和clock等；spi有四种模式。

int spi_register_board_info(struct spi_board_info const *info, unsigned n)

和i2c差不多，新出现的boardinfo是对spi_board_info的一个封装；register会把自己挂在一个全局的board_list上。与i2c不同的是，此时spi就会遍历spi_master_list，根据bus_num进行master和device的匹配，匹配成功就new device。如果主设备已经register，对于spi来说只要调用register_board_info，就可以自动new spi_device了；而i2c需要手动的调用i2c_new_device。

int spi_register_master(struct spi_master *master)

spi_master是个device，所以还会用device_add()；而且会把自己挂在spi_master_list全局的list上，这样register board info的时候才能找到这个master；当然，此时也会遍历board_list，找到匹配的info，创建spi device。这个函数中还有一段：

if (master->transfer)

dev_info(dev, "master is unqueued, this is deprecated\n");

else {

status = spi_master_initialize_queue(master);

if (status) {

device_unregister(&master->dev);

goto done;

}

}

master->transfer已经实现的就略过，否则需要用内核提供的一套机制。

static int spi_master_initialize_queue(struct spi_master *master)
{
int ret;

master->queued = true;
master->transfer = spi_queued_transfer;

/* Initialize and start queue */
ret = spi_init_queue(master);
if (ret) {
dev_err(&master->dev, "problem initializing queue\n");
goto err_init_queue;
}
ret = spi_start_queue(master);
if (ret) {
dev_err(&master->dev, "problem starting queue\n");
goto err_start_queue;
}

return 0;

err_start_queue:
err_init_queue:
spi_destroy_queue(master);
return ret;
}

果然提供了一个传输函数 spi_queued_transfer，是基于排队提交的。

static int spi_init_queue(struct spi_master *master)
{
struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };

INIT_LIST_HEAD(&master->queue);
spin_lock_init(&master->queue_lock);

master->running = false;
master->busy = false;

init_kthread_worker(&master->kworker);
master->kworker_task = kthread_run(kthread_worker_fn,
&master->kworker,
dev_name(&master->dev));
if (IS_ERR(master->kworker_task)) {
dev_err(&master->dev, "failed to create message pump task\n");
return -ENOMEM;
}
init_kthread_work(&master->pump_messages, spi_pump_messages);

/*
* Master config will indicate if this controller should run the
* message pump with high (realtime) priority to reduce the transfer
* latency on the bus by minimising the delay between a transfer
* request and the scheduling of the message pump thread. Without this
* setting the message pump thread will remain at default priority.
*/
if (master->rt) {
dev_info(&master->dev,
"will run message pump with realtime priority\n");
sched_setscheduler(master->kworker_task, SCHED_FIFO, ¶m);
}

return 0;
}

init_kthread_worker(&master->kworker);初始化一个线程工作者，其结构中会包含当前线程工作项；主要初始化worker->lock、worker->work_list和worker->task。

master->kworker_task创建了一个线程；线程函数是kthread_worker_fn，该函数的参数是&master->kworker；线程name是dev_name(&master->dev)。

init_kthread_work(&master->pump_messages, spi_pump_messages);这个就是线程工作项了，其结构会依附一个线程工作者；这里初始化了&(work)->node，这个一个list，可能是要把自己挂在线程工作者的work_list上。

(work)->func = (fn);spi_pump_messages就是线程工作项的工作函数了。

master->rt是realtime标志，若设置表示高优先级的信息处理，有必要减少传输等待时间，把传输请求和信息pump线程之间的延时缩短最小；所以需要调用sched_setscheduler()改变thread的调度策略为实现级别。未设置保持默认优先级。

static int spi_start_queue(struct spi_master *master)
{
unsigned long flags;

spin_lock_irqsave(&master->queue_lock, flags);

if (master->running || master->busy) {
spin_unlock_irqrestore(&master->queue_lock, flags);
return -EBUSY;
}

master->running = true;
master->cur_msg = NULL;
spin_unlock_irqrestore(&master->queue_lock, flags);

queue_kthread_work(&master->kworker, &master->pump_messages);

return 0;
}

queue_kthread_work(&master->kworker, &master->pump_messages);

insert_kthread_work(worker, work, &worker->work_list);

static void insert_kthread_work(struct kthread_worker *worker,
struct kthread_work *work,
struct list_head *pos)
{
lockdep_assert_held(&worker->lock);

list_add_tail(&work->node, pos);
work->worker = worker;
if (likely(worker->task))
wake_up_process(worker->task);
}

果然work把自己挂在了work_list上，work也就找到了依附的worker；如果worker->task当前有任务，就wake_up_process(worker->task)。

该初始化的kwoker、work、task都初始好了；现在内核里有一个线程运行起来了。
master->kworker_task = kthread_run(kthread_worker_fn, &master->kworker, dev_name(&master->dev));

int kthread_worker_fn(void *worker_ptr)
{
struct kthread_worker *worker = worker_ptr;
struct kthread_work *work;

WARN_ON(worker->task);
worker->task = current;
repeat:
set_current_state(TASK_INTERRUPTIBLE);	/* mb paired w/ kthread_stop */

if (kthread_should_stop()) {
__set_current_state(TASK_RUNNING);
spin_lock_irq(&worker->lock);
worker->task = NULL;
spin_unlock_irq(&worker->lock);
return 0;
}

work = NULL;
spin_lock_irq(&worker->lock);
if (!list_empty(&worker->work_list)) {
work = list_first_entry(&worker->work_list,
struct kthread_work, node);
list_del_init(&work->node);
}
worker->current_work = work;
spin_unlock_irq(&worker->lock);

if (work) {
__set_current_state(TASK_RUNNING);
work->func(work);
} else if (!freezing(current))
schedule();

try_to_freeze();
goto repeat;
}

这里会遍历&worker->work_list，找到上面依附的work并删除(不删除就会重复执行了)后执行work->func(work)；如果已经没有线程工作项了，会schedule();休眠。根据前面的一系列初始化，这个work就是spi_start_queue()->queue_kthread_work(&master->kworker, &master->pump_messages)->insert_kthread_work()->list_add_tail(&work->node,
pos);挂上来的&master->pump_messages；它的线程工作者函数是spi_init_queue(&master->pump_messages, spi_pump_messages)->init_kthread_work()->((work)->func = (fn))填充的spi_pump_messages。到目前为止spi_pump_messages已经运行起来了。

static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
{
struct spi_master *master = spi->master;
unsigned long flags;

spin_lock_irqsave(&master->queue_lock, flags);

if (!master->running) {
spin_unlock_irqrestore(&master->queue_lock, flags);
return -ESHUTDOWN;
}
msg->actual_length = 0;
msg->status = -EINPROGRESS;

list_add_tail(&msg->queue, &master->queue);
if (master->running && !master->busy)
queue_kthread_work(&master->kworker, &master->pump_messages);

spin_unlock_irqrestore(&master->queue_lock, flags);
return 0;
}

插入一下master->transfer = spi_queued_transfer;

1 把自己挂到&master->queue。

2 master->running为true确保master已经启动，master->busy为false确保mster不忙，queue_kthread_work()->insert_kthread_work()->(&work->node, pos)，这样kthread_worker_fn线程函数里才能找到这个work，然后执行spi_pump_messages()，提交message；这个动作和spi_start_queue()差不多。

3 如果此时master->running为false，master未启动直接return了；如果此时已启动但是master->busy是true的，就只把msg挂到了&master->queue上，那什么时候queue_kthread_work呢？如果&master->queue一下挂了很多msg怎么办呢？按照排队的方式，就是每调用一次master->transfer，处理一个msg，是不阻塞的；同步机制需要另外实现。

static void spi_pump_messages(struct kthread_work *work)
{
struct spi_master *master =
container_of(work, struct spi_master, pump_messages);
unsigned long flags;
bool was_busy = false;
int ret;

/* Lock queue and check for queue work */
spin_lock_irqsave(&master->queue_lock, flags);
if (list_empty(&master->queue) || !master->running) {
if (master->busy && master->unprepare_transfer_hardware) {
ret = master->unprepare_transfer_hardware(master);
if (ret) {
spin_unlock_irqrestore(&master->queue_lock, flags);
dev_err(&master->dev,
"failed to unprepare transfer hardware\n");
return;
}
}
master->busy = false;
spin_unlock_irqrestore(&master->queue_lock, flags);
return;
}

/* Make sure we are not already running a message */
if (master->cur_msg) {
spin_unlock_irqrestore(&master->queue_lock, flags);
return;
}
/* Extract head of queue */
master->cur_msg =
list_entry(master->queue.next, struct spi_message, queue);

list_del_init(&master->cur_msg->queue);
if (master->busy)
was_busy = true;
else
master->busy = true;
spin_unlock_irqrestore(&master->queue_lock, flags);

if (!was_busy && master->prepare_transfer_hardware) {
ret = master->prepare_transfer_hardware(master);
if (ret) {
dev_err(&master->dev,
"failed to prepare transfer hardware\n");
return;
}
}

ret = master->transfer_one_message(master, master->cur_msg);
if (ret) {
dev_err(&master->dev,
"failed to transfer one message from queue\n");
return;
}
}

接着回来spi_pump_messages()。

1 &master->queue为空说明没有message；master->running为false说明还未开始spi_start_queue()，这个master还未启动了；无论是没有message，还是未启动master->busy = false都是成立的，直接return。

2 如果master->cur_msg不为空说明已经有message在运行了，直接return，所以在驱动中message传输完需要master->cur_msg = NULL;；否则找一个message，怎么找的呢？到master->queue上找，(master->transfer = spi_queued_transfer就是这里挂上的)。找到后从master->queue上删除，否则会重复发送这个message。

3 master->busy则was_busy就为true，否则要更改master->busy从false到true。只根据was_busy来判断master->prepare_transfer_hardware()执行与否，为什么master->transfer_one_message()不用判断？难道要根据transfer_one_message()中check到master的状态直接return。

4 ret = master->transfer_one_message(master, master->cur_msg)，这种方式的msg提交需要驱动实现 master->transfer_one_message()函数，别忘了master->cur_msg = NULL，否则下一个msg永远都别想提交了。

spi_queued_transfer机制总结：

1 内核提供了通用的master->transfer = spi_queued_transfer，其调用方式与驱动中实现该函数是一样的，只是现在驱动中需要实现的是master->transfer_one_message()。

2 spi_queued_transfer负责把massage信息挂到&master->queue这个list上，然后&master->pump_messages这个work挂在&master->kworker的work_list上。

3 spi_master_initialize_queue()->spi_init_queue() run了一个线程，kthread_worker_fn会遍历&master->kworker->work_list上的work，执行其工作函数。

4 上述的工作函数是spi_init_queue()->init_kthread_work()初始化的，就是spi_pump_messages。

5 spi_pump_messages()中会遍历&master->queue找到message，提交message。

6 只有kthread_worker_fn是一直在跑的，spi_pump_messages()依赖于调用master->transfer；只有执行过spi_queued_transfer，work才会挂到worker上，spi_pump_messages()才能运行；有了message，spi_pump_messages()才能成功提交。

int spi_sync(struct spi_device *spi, struct spi_message *message)

{

return __spi_sync(spi, message, 0);

}

int spi_async(struct spi_device *spi, struct spi_message *message)

spi的同步和异步传输，同步和异步的区别在哪里？spi异步：提交完message就马上返回；不会睡眠，可以在中断上下文等不可休眠的场合使用。但是需要complete同步机制，在wait_for_completion期间，不能操作message中的信息。spi同步：就是使用异步使用的一个实例，提交message后不会立即返回，应用complete进行休眠，一直等到处理完成。 spi_sync比较常用，需要注意的是在master->transfer(spi, message)函数中要调用message->complete(message->context)来更新完成量的状态，否则wait_for_completion永远也等不到同步信号；会一直睡下去的。

__spi_sync()->spi_async_locked()->__spi_async()->(master->transfer(spi, message))

int spi_write_then_read(struct spi_device *spi, const void *txbuf, unsigned n_tx, void *rxbuf, unsigned n_rx)

spi同步写然后读；这个spi_sync()的一个应用实例。

1 确定一个local_buf，这个buf里要存储的是txbuf+rxbuf的数据，要求(n_tx + n_rx)>=SPI_BUFSIZ(32)。如果小于也会扩展为32。

(n_tx + n_rx) > SPI_BUFSIZ，local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx), GFP_KERNEL);

否则，local_buf = buf;这个buf的malloc在spi_init()->buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);

2 初始化message，把spi_transfer x[2]挂在message上。

3 填充x[0].tx_buf和x[1].rx_buf结构，就是local_buf的前段和后段；x[0]是用于发送的，所以不需要rx_buf，同理x[1]不需要tx_buf。

4 spi_sync()提交message，memcpy(rxbuf, x[1].rx_buf, n_rx);。

5 善后处理，unlock、free。

三 spi总线注册

postcore_initcall(spi_init);

spi总线设备，注册等级2级。

spi_init()中malloc了一个buf，当n_tx + n_rx<= SPI_BUFSIZ时；

local_buf = buf;//local_buf 也是个中转站。

x[0].tx_buf = local_buf;

x[1].rx_buf = local_buf + n_tx;

status = bus_register(&spi_bus_type);注册一个子系统。

四 spi驱动程序开发

1 spi_register_master(master)；注册一个master；

2 实现master->transfer或者master->transfer_one_message其中之一。