S5PV210之SPI和linux 内核3.0.8之SPI解析
SPI(serial peripheral interface)串行外围接口，是主控制器与外设进行串口通信的接口。主要包括四条控制线，分别是SCLK(串行时钟)、MOSI(主出从入)、MISO(主入从出)、SS(芯片选择使能信号、低电平有效)。
先说说S5PV210的SPI的特点
1.全双工工作
2.发送/接收的移位寄存器可以是8位/16位/32位
3.主从模式
4.发送和接收的最大频率可达50MHz
5.支持摩托罗拉SPI协议和美国半导体总线协议
6.两路SPI信号
支持四种工作模式：
当CPHA(同步时钟相位)为0时，为格式A，当CPHA为1时，为格式B
当CPHA为0时，即格式A，串行同步时钟在第一个跳变(上升沿或下降沿)/(前沿)读取数据
当CPHA为1时，即格式B时，串行同步时钟在第二个跳变沿(上升沿或下降沿)/(后沿)读取数据
当CPOL(同步时钟极性)为1时，SPICLK空闲时处于高电平，CPOL为0时，SPICLK空闲时处于低电平
至于两路SPI的控制寄存器，接收数据寄存器、发送数据寄存器之类的，就不做多介绍了，因为要根据具体情况而进行设定。详情参看S5PV20_UM手册。
接下来使用source insight 查看SPI的原理
因为linux设备驱动框架采用分层和分离的思想，像linux中SPI、IIC、USB之类的子系统都采用了分离的设计思想，即主机驱动与外设驱动分离。
以下这张图是宋宝华老师写的设备驱动开发详解里面的：描述了主机驱动和外设驱动的关系，主机控制器驱动不用关心外设，同样的外设驱动也不用关心主机，两者都是通过核心层进行信息的交互。
对于LINUX 3.0.8中，
SPI总线的层次关系，这张图是嵌入式学院的刘洪涛老师讲的，我觉得讲的挺好的，就贴到着了
对于上面SPI的层次图，解释一下，我们知道SPI总线分为主从设备，而在linux中SPI的主设备(主机控制驱动)采用platform_device在BSP(板级支持包)中存储于主机硬件相关的信息，在platform_driver中存储操作，用platform_bus_type进行连接platform_device和platform_driver；而从设备(外设驱动)采用spi_device(准确的说是spi_board_info结构体)存储外设硬件相关信息，用spi_driver存储操作，用spi_bus_type进行连接spi_device与spi_driver。
先说主机控制器这部分
在内核的 include/linux/spi/spi.h 中，定义了主机控制器比较重要的几个机构体：分别是spi_master、spi_message、spi_transfer
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);
};
对于spi_master结构体，个人觉得比较重要的就是
1.dev成员变量，代表一个主机控制器设备
2.bus_num成员变量，应该说是总线编号，用于连接与此主控制相关的从设备 在drivers/spi/Spi_s3c64xx.c(这个文件就是一个spi主控制器的实现)中的s3c64xx_spi_probe函数 中，追踪源码(s3c64xx_spi_probe-->spi_register_master-->spi_match_master_to_boardinfo)会发现这么一句话
if (master->bus_num != bi->bus_num)
return;
即将主控制器的bus_num与从设备的bus_num进行匹配，不匹配则返回，如果匹配则调用spi_new_device函数，创建于此主控制器相关的从设备
3.(*transfer)(struct spi_device *spi,struct spi_message *mesg); ，transfer函数指针，这个transfer函数指针就是用来最终进行主从设备进行信息交换的函数。
spi_transfer结构体
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;
};
spi_transfer相当于主从设备发送消息时的一个数据包，
重要的字段分别是tx_buf(发送缓存)、rx_buf(接受缓存)、len(长度)
spi_message结构体
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_message相当于主从设备信息发送时的一帧数据，包含多个数据包，使用transfers字段将多个spi_transfer进行连接
同样是在include/linux/spi/spi.h中，再来看看外设驱动这边，SPI的外设设备驱动的实现和platform设备驱动的实现很像，采用的是通过总线连接外设与驱动，所以比较重要的结构体有：
spi_device、spi_board_info、spi_bus_type、spi_driver
spi_device结构体
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];
/*
* 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_device用来描述一个从设备，比较重要的字段有dev,
master(从设备隶属于哪一个主设备)、
modalias(设备的名称，在spi_bus_type的spi_match_device函数中用于和spi_driver的name字段进行匹配的，
在drivers/spi/Spi.c 中的 spi_match_device函数中源码
return strcmp(spi->modalias, drv->name) == 0; )
spi_board_info结构体
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的很多板信息都存储在spi_board_info结构体中，spi_board_info结构体存储了片选信号(chip_select)，主机总线编号(即bus_num)、spi传输的模式(mode)
等等
在linux启动过程中，在init_machine函数中，通过spi_register_board_info函数进行BSP信息的注册，当注册从设备的板信息时，会调用spi_match_master_to_boardinfo(master, &bi->board_info);函数进行主控制器与从设备的匹配
spi_bus_type结构体
struct bus_type spi_bus_type = {
.name = "spi",
.dev_attrs = spi_dev_attrs,
.match = spi_match_device,
.uevent = spi_uevent,
.pm = &spi_pm,
};
spi_bus_type用于连接spi_device和spi_driver，在spi_match_device函数中，
static int spi_match_device(struct device *dev, struct device_driver *drv)
{
const struct spi_device *spi = to_spi_device(dev);
const struct spi_driver *sdrv = to_spi_driver(drv);
/* Attempt an OF style match */
if (of_driver_match_device(dev, drv))
return 1;
if (sdrv->id_table)
return !!spi_match_id(sdrv->id_table, spi);
return strcmp(spi->modalias, drv->name) == 0;
}
先看of_driver_match_device函数，追踪源码会发现，它会先比较drv的of_match_table字段和dev的of_node字段，匹配两个字段的name，type，compatible三个字段是否相同，
接着是spi_match_id函数，它会遍历sdrv的id_table(即spi_driver支持的设备列表)结构体中的name与spi->modalias,比较是否匹配，匹配则返回id结构体
while (id->name[0]) {
if (!strcmp(sdev->modalias, id->name))
return id;
id++;
}
最后才是strcmp(spi->modalias, drv->name) == 0，比较设备名称spi->modalias与驱动名称drv->name字段匹配
spi_driver结构体
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;
};
spi_driver存储于外设驱动相关的操作
接下来以内核中一个SPI实例，进一步解析SPI原理，实现过程
需要用到以下文件
drivers/spi/spi_s3c64xx.c 主机控制器platform_driver
arch/arm/mach-s5pv210/dev-spi.c 主机控制器platform_device
drivers/spi/spi.c 核心层API
arch/sh/boards/board-sh7757lcr.c 外设spi_device(即spi_board_info)
先从drivers/spi/spi_s3c64xx.c中的
1.模块初始化函数看起
static int __init s3c64xx_spi_init(void)
{
return platform_driver_probe(&s3c64xx_spi_driver, s3c64xx_spi_probe);
}
查看platform_driver_probe，有两行代码需要注意
drv->probe = probe;
retval = code = platform_driver_register(drv);
其实上面两行代码是将probe函数赋值给驱动，并且注册驱动。如果熟悉platform机制的朋友，就会很了解。其实platform_driver_probe只是对platform_driver_register的一个封装而已。
查看platform_driver_register，
int platform_driver_register(struct platform_driver *drv)
{
drv->driver.bus = &platform_bus_type;
if (drv->probe)
drv->driver.probe = platform_drv_probe;
if (drv->remove)
drv->driver.remove = platform_drv_remove;
if (drv->shutdown)
drv->driver.shutdown = platform_drv_shutdown;
return driver_register(&drv->driver);
}
上面的代码
drv->driver.bus = &platform_bus_type; 给platform_driver里面的driver字段的bus字段赋初值，将之设为platform_bus_type
三个if语句，用于将platform_driver的操作赋值给driver
查看driver_register，有一句话，将驱动添加到总线上，,即将驱动挂载为platform_bus_type
ret = bus_add_driver(drv);
查看bus_add_driver，驱动捆绑函数
error = driver_attach(drv);
查看driver_attach，此时遍历设备链表，查找与驱动匹配的设备
return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
查看bus_for_each_dev，下面的while循环，即调用__driver_attach
while ((dev = next_device(&i)) && !error)
error = fn(dev, data);
查看__driver_attach，判断，如果设备的驱动为NULL的话，即调用driver_probe_device
if (!dev->driver)
driver_probe_device(drv, dev);
查看driver_probe_device，在relly_probe里面即是最终的匹配的驱动和设备的连接
ret = really_probe(dev, drv);
查看really_probe，下面有三段，分别是将驱动绑定在设备上、调用驱动的probe函数、将设备绑定在驱动上
dev->driver = drv;
if (dev->bus->probe) {
ret = dev->bus->probe(dev);
if (ret)
goto probe_failed;
} else if (drv->probe) {
ret = drv->probe(dev);
if (ret)
goto probe_failed;
}
driver_bound(dev);
到此为止，即完成了驱动与设备的查找与绑定。
在上面really_probe函数里面的第二段 ret = drv->probe(dev); 调用驱动的probe函数，回想一下，即在platform_driver_register函数里面的
if (drv->probe) drv->driver.probe = platform_drv_probe; //查看platform_drv_probe源码会发现，是将platform_driver的probe函数赋值给driver的probe函数
所以调用驱动的probe函数即是调用模块初始化的s3c64xx_spi_probe函数
2.查看s3c64xx_spi_probe函数
先是
dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
if (dmatx_res == NULL) {
dev_err(&pdev->dev, "Unable to get SPI-Tx dma resource\n");
return -ENXIO;
}
dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
if (dmarx_res == NULL) {
dev_err(&pdev->dev, "Unable to get SPI-Rx dma resource\n");
return -ENXIO;
}
mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (mem_res == NULL) {
dev_err(&pdev->dev, "Unable to get SPI MEM resource\n");
return -ENXIO;
}
获取到在arch/arm/mach-s3c64xx/dev-spi.c定义的资源文件
接着是
master = spi_alloc_master(&pdev->dev,sizeof(struct s3c64xx_spi_driver_data));
创建一个spi_master返回给master指针
接着是
spi_register_master(master);
注册一个master ，
查看spi_register_master源码中有一行：
list_for_each_entry(bi, &board_list, list) spi_match_master_to_boardinfo(master, &bi->board_info); //遍历spi_board_info链表，查找与master匹配的spi_board_spi
查看spi_match_master_to_boardinfo函数
if (master->bus_num != bi->bus_num) return; dev = spi_new_device(master, bi);
判断主从设备的总线编号是否匹配，匹配的话，则调用spi_new_device函数
查看spi_new_device函数，创建spi_device
proxy = spi_alloc_device(master);
查看spi_alloc_device
struct spi_device *spi_alloc_device(struct spi_master *master)
{
struct spi_device *spi;
struct device *dev = master->dev.parent;
if (!spi_master_get(master))
return NULL;
spi = kzalloc(sizeof *spi, GFP_KERNEL);
if (!spi) {
dev_err(dev, "cannot alloc spi_device\n");
spi_master_put(master);
return NULL;
}
spi->master = master;
spi->dev.parent = dev;
spi->dev.bus = &spi_bus_type;
spi->dev.release = spidev_release;
device_initialize(&spi->dev);
return spi;
} 创建一个spi_device，并返回， spi->master = master; 即将spi_device与之主master连接在一起
上面第一步，第二步分别完成了主机设备与驱动的绑定、创建spi_master、若有匹配的spi_board_info，则创建与之master匹配的spi_device
3.spi_device与spi_driver通过spi_bus_type进行绑定的过程，与第一步的很类似，就不叙述了，详情参看源码drivers\spi\Spi.c文件
4.注册spi_board_info信息时，与spi_master进行匹配
先看drivers\spi\Spi.c文件中的spi_register_board_info函数
list_for_each_entry(master, &spi_master_list, list) spi_match_master_to_boardinfo(master, &bi->board_info);
遍历master列表，查找与之匹配的spi_board_info
查看spi_match_master_to_boardinfo
static void spi_match_master_to_boardinfo(struct spi_master *master,
struct spi_board_info *bi)
{
struct spi_device *dev;
if (master->bus_num != bi->bus_num)
return;
dev = spi_new_device(master, bi);
if (!dev)
dev_err(master->dev.parent, "can't create new device for %s\n",
bi->modalias);
}
接下来的过程与第二步又很像了，也不叙述了。
至此，已对SPI主机控制器的驱动与设备如何连接，SPI从设备的驱动和设备如何连接，SPI主控制器设备如何与从设备进行连接，进行了分析，下一步应该是SPI的主从设备间相互通信了，以及实例的介绍了。