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 devicedev;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. */s16bus_num;/* chipselects will be integral to many controllers; some others * might use board-specific GPIOs. */u16num_chipselect;/* some SPI controllers pose alignment requirements on DMAable * buffers; let protocol drivers know about these requirements. */u16dma_alignment;/* spi_device.mode flags understood by this controller driver */u16mode_bits;/* other constraints relevant to this driver */u16flags;#define SPI_MASTER_HALF_DUPLEXBIT(0)/* can't do full duplex */#define SPI_MASTER_NO_RXBIT(1)/* can't do buffer read */#define SPI_MASTER_NO_TXBIT(2)/* can't do buffer write *//* lock and mutex for SPI bus locking */spinlock_tbus_lock_spinlock;struct mutexbus_lock_mutex;/* flag indicating that the SPI bus is locked for exclusive use */boolbus_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;unsignedlen;dma_addr_ttx_dma;dma_addr_trx_dma;unsignedcs_change:1;u8bits_per_word;u16delay_usecs;u32speed_hz;struct list_head transfer_list;};

spi_transfer相当于主从设备发送消息时的一个数据包，

重要的字段分别是tx_buf(发送缓存)、rx_buf(接受缓存)、len(长度)

spi_message结构体

struct spi_message {struct list_headtransfers;struct spi_device*spi;unsignedis_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;unsignedactual_length;intstatus;/* 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_headqueue;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 devicedev;struct spi_master*master;u32max_speed_hz;u8chip_select;u8mode;#defineSPI_CPHA0x01/* clock phase */#defineSPI_CPOL0x02/* clock polarity */#defineSPI_MODE_0(0|0)/* (original MicroWire) */#defineSPI_MODE_1(0|SPI_CPHA)#defineSPI_MODE_2(SPI_CPOL|0)#defineSPI_MODE_3(SPI_CPOL|SPI_CPHA)#defineSPI_CS_HIGH0x04/* chipselect active high? */#defineSPI_LSB_FIRST0x08/* per-word bits-on-wire */#defineSPI_3WIRE0x10/* SI/SO signals shared */#defineSPI_LOOP0x20/* loopback mode */#defineSPI_NO_CS0x40/* 1 dev/bus, no chipselect */#defineSPI_READY0x80/* slave pulls low to pause */u8bits_per_word;intirq;void*controller_state;void*controller_data;charmodalias[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 */charmodalias[SPI_NAME_SIZE];const void*platform_data;void*controller_data;intirq;/* slower signaling on noisy or low voltage boards */u32max_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. */u16bus_num;u16chip_select;/* mode becomes spi_device.mode, and is essential for chips * where the default of SPI_CS_HIGH = 0 is wrong. */u8mode;/* ... 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_driverdriver;};

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的主从设备间相互通信了，以及实例的介绍了。