Linux驱动开发：SPI子系统

1、SPI简介

1.1 四根线

MISO：主设备数据输入，从设备数据输出。
MOSI：主设备数据输出，从设备数据输入。
SCLK：时钟信号，由主设备产生。
CS：    从设备片选信号，由主设备控制。

1.2 四种模式

CPOL(时钟极性) :   0:时钟起始位低电平      1:时钟起始为高电平  
CPHA(时钟相位) ：0:第一个时钟周期采样   1:第二个时钟周期采样

1、CPOL=0，CPHA=0：此时空闲态时，SCLK处于低电平，数据采样是在第1个边沿，也就是 SCLK由低电平到高电平的跳变，所以数据采样是在上升沿，数据发送是在下降沿。

2、CPOL=0，CPHA=1：此时空闲态时，SCLK处于低电平，数据发送是在第1个边沿，也就是 SCLK由低电平到高电平的跳变，所以数据采样是在下降沿，数据发送是在上升沿。

3、CPOL=1，CPHA=0：此时空闲态时，SCLK处于高电平，数据采集是在第1个边沿，也就是 SCLK由高电平到低电平的跳变，所以数据采集是在下降沿，数据发送是在上升沿。

4、CPOL=1，CPHA=1：此时空闲态时，SCLK处于高电平，数据发送是在第1个边沿，也就是 SCLK由高电平到低电平的跳变，所以数据采集是在上升沿，数据发送是在下降沿。

1.3 SPI数据传输

        

        从图中可以看出，主机和从机都有一个串行移位寄存器，主机通过向它的SPI串行寄存器写入一个字节来发起一次传输。寄存器通过MOSI信号线将字节传送给从机，从机也将自己的移位寄存器中的内容通过MISO信号线返回给主机。这样，两个移位寄存器中的内容就被交换。外设的写操作和读操作是同步完成的。如果只进行写操作，主机只需忽略接收到的字节；反之，若主机要读取从机的一个字节，就必须发送一个空字节来引发从机的传输。

1.4 SPI驱动框架简介

        SPI 驱动框架和 I2C 很类似，都分为主机控制器驱动和设备驱动，主机控制器也就是 SOC 的 SPI 控制器接口。样。和 I2C适配器驱动一样，SPI主机驱动一般都是 SOC 厂商去编写的，所以我们作为 SOC的使用者，这一部分的驱动就不用操心了。

2、SPI设备驱动

2.1 SPI相关API

2.1.1 spi_driver

struct spi_driver {
	int			(*probe)(struct spi_device *spi);
	int			(*remove)(struct spi_device *spi);
	struct device_driver	driver;
};

struct device_driver {
	const char	*name;
	const struct of_device_id	*of_match_table;
}

2.1.2 注册：spi_register_driver

#define spi_register_driver(driver) 
	__spi_register_driver(THIS_MODULE, driver)

2.1.3 注销：spi_unregister_driver

static inline void spi_unregister_driver(struct spi_driver *sdrv)

2.1.4 module_spi_driver：一键注册，不需要以上注册注销的过程

#define module_spi_driver(__spi_driver) 
	module_driver(__spi_driver, spi_register_driver, 
			spi_unregister_driver)

#define module_driver(__driver, __register, __unregister, ...) 
static int __init __driver##_init(void) 
{ 
	return __register(&(__driver) , ##__VA_ARGS__); 
} 
module_init(__driver##_init); 
static void __exit __driver##_exit(void) 
{ 
	__unregister(&(__driver) , ##__VA_ARGS__); 
} 
module_exit(__driver##_exit);

module_spi_driver(myspi);

#define module_spi_driver(myspi) 
	module_driver(myspi, spi_register_driver, 
			spi_unregister_driver)

#define module_driver(myspi, spi_register_driver, spi_unregister_driver) 
static int __init myspi_init(void) 
{ 
	return spi_register_driver(&myspi); 
} 

static void __exit myspi_exit(void) 
{ 
	spi_unregister_driver(&myspi); 
} 
module_init(myspi_init); 
module_exit(myspi_exit);

2.1.5 spi_write

spi_write(struct spi_device *spi, const void *buf, size_t len)
{
	struct spi_transfer	t = {
			.tx_buf		= buf,
			.len		= len,
		};

	return spi_sync_transfer(spi, &t, 1);
}

2.1.6 spi_read

spi_read(struct spi_device *spi, void *buf, size_t len)
{
	struct spi_transfer	t = {
			.rx_buf		= buf,
			.len		= len,
		};

	return spi_sync_transfer(spi, &t, 1);
}

2.1.7 spi_write_then_read 

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

2.1.8 以上三种spi传输函数解析，实际接收发送只需spi_write、spi_read

struct spi_transfer {
	const void	*tx_buf;  //用于保存发送的数据
	void		*rx_buf;  //用于保存接收到的数据
	unsigned	len;      //是要进行传输的数据长度， SPI是全双工通信，
                          //因此在一次通信中发送和接收的字节数都是一样的，
                          //所以 spi_transfer中也就没有发送长度和接收长度之分。
};

spi_sync_transfer(struct spi_device *spi, struct spi_transfer *xfers,
	unsigned int num_xfers)
{
	struct spi_message msg;

	spi_message_init_with_transfers(&msg, xfers, num_xfers);

	return spi_sync(spi, &msg);
}

struct spi_message {
	struct list_head	transfers;
	struct spi_device	*spi;
};

spi_message_init_with_transfers(struct spi_message *m,
struct spi_transfer *xfers, unsigned int num_xfers)
{    
	unsigned int i;
	spi_message_init(m);
	for (i = 0; i < num_xfers; ++i)
		spi_message_add_tail(&xfers[i], m);
}

总体流程：

①、申请并初 始化 spi_transfer，设置 spi_transfer的 tx_buf成员变量， tx_buf为要发送的数
据。然后设置 rx_buf成员变量， rx_buf保存着接收到的数据。最后设置 len成员变量，也就是要进行数据通信的长度。
②、使用 spi_message_init函数初始化 spi_message。
③、使用 spi_message_add_tail函数将前面设置好的 spi_transfer添加到 spi_message队列中。
④、使用 spi_sync函数完成 SPI数据同步传输。

 2.1.9 spi_message_init

int spi_sync(struct spi_device *spi, struct spi_message *message) 
/*
功能：初始化spi_message
参数：
    @spi    :要进行数据传输的 spi_device
    @message:要传输的 spi_message
返回值：无
*/

2.1.10 spi_message_add_tail

void spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
/*
功能：初始化完成以后需要将 spi_transfer添加到 spi_message队列中
参数：
    @t：要添加到队列中的 spi_transfer
    @m：spi_transfer要加入的 spi_message
返回值： 无
*/

2.1.11 spi_sync：同步传输

int spi_sync(struct spi_device *spi, struct spi_message *message)
/*
功能：同步传输，会阻塞的等待 SPI 数据传输完成
参数：
    @spi:要进行数据传输的 spi_device
    @message：要传输的 spi_message
返回值：成功返回0，失败返回错误码
*/

2.1.12 spi_async：异步传输

int spi_async(struct spi_device *spi, struct spi_message *message)
/*
功能：异步传输不会阻塞的等到 SPI数据传输完成，异步传输需要设置 spi_message中的 complete成员变量，
      complete是一个回调函数，当 SPI异步传输完成以后此函数就会被调用。
参数：        
    @spi:要进行数据传输的 spi_device
    @message：要传输的 spi_message
返回值：成功返回0，失败返回错误码
*/

3、驱动程序

3.1 修改设备树

&spi4{
    pinctrl-names = "default", "sleep";
    pinctrl-0 = <&spi4_pins_b>;
    pinctrl-1 = <&spi4_sleep_pins_b>;
    cs-gpios = <&gpioe 11 0>;
    status = "okay";
    
    m74hc595@0{
        compatible = "aaa,m74hc595";
        reg = <0>;
        spi-max-frequency = <10000000>; //10Mhz
    };
};

3.2 驱动程序编写

#ifndef __M74HC595_H__
#define __M74HC595_H__

#define SEG_WHICH _IOW('k',0,int)
#define SEG_DAT  _IOW('k',1,int)
#endif

#define NAME "m74hc595"
int major = 0;
struct class *cls;
struct device *dev;
struct spi_device *gspi;
u8 code[] = {
	0x3f, 0x06, 0x5b, 0x4f, 0x6d, 0x7d, 0x07, 0x7f, 
	0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71, 
};

u8 which[] = {
	0x1, 0x2, 0x4, 0x8, 
};

int m74hc595_open(struct inode *inode, struct file *file)
{
	return 0;
}
long m74hc595_ioctl(struct file *file, 
	unsigned int cmd, unsigned long args)
{	
	switch(cmd){
		case SEG_WHICH:
			spi_write(gspi,&which[args],1);
			break;
		case SEG_DAT:
			spi_write(gspi,&code[args],1);
			break;
		default: printk("ioctl error\n");break;
	}
	
	return 0;
}

int m74hc595_close(struct inode *inode, struct file *file)
{
	return 0;
}
struct file_operations fops = {
	.open = m74hc595_open,
	.unlocked_ioctl = m74hc595_ioctl,
	.release = m74hc595_close,
};

int	m74hc595_probe(struct spi_device *spi)
{
	u8 buf[2] = {0xf,0x0};
	gspi = spi;
	spi_write(gspi,buf,ARRAY_SIZE(buf));
	
	major = register_chrdev(0,NAME,&fops);
	cls = class_create(THIS_MODULE,NAME);
	dev = device_create(cls,NULL,MKDEV(major,0),NULL,NAME);

	return 0;
}

int	m74hc595_remove(struct spi_device *spi)
{
	device_destroy(cls,MKDEV(major,0));
	class_destroy(cls);
	unregister_chrdev(major,NAME);
	return 0;
}

const struct of_device_id of_match[] = {
	{.compatible = "aaa,m74hc595",},
	{},
};

struct spi_driver m74hc595 = {
	.probe = m74hc595_probe,
	.remove = m74hc595_remove,
	.driver = {
		.name = "bbb",
		.of_match_table = of_match,
	},	
};
module_spi_driver(m74hc595);

4、应用程序
 

int main(int argc, const char *argv[])
{
	int which=0;
	int data=0;
	int fd;
	fd = open("/dev/m74hc595",O_RDWR);
	if(fd < 0){
		perror("open error");
		return -1;
	}

	while(1){
		ioctl(fd,SEG_WHICH,which++);
		ioctl(fd,SEG_DAT,data++);
		if(which >= 4)which=0;
		if(data >= 16)data = 0;
		sleep(1);
	}

	close(fd);
	return 0;
}