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;
}