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信号

支持四种工作模式:

S5PV210之SPI和linux 内核3.0.8之SPI解析_第1张图片

当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之类的子系统都采用了分离的设计思想,即主机驱动与外设驱动分离。

  以下这张图是宋宝华老师写的设备驱动开发详解里面的:描述了主机驱动和外设驱动的关系,主机控制器驱动不用关心外设,同样的外设驱动也不用关心主机,两者都是通过核心层进行信息的交互。

S5PV210之SPI和linux 内核3.0.8之SPI解析_第2张图片

 

对于LINUX 3.0.8中,

SPI总线的层次关系,这张图是嵌入式学院的刘洪涛老师讲的,我觉得讲的挺好的,就贴到着了

S5PV210之SPI和linux 内核3.0.8之SPI解析_第3张图片

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

 

 

你可能感兴趣的:(linux)