1）实验平台：正点原子STM32MP157开发板
2）购买链接:/item.htm?&id=629270721801
3）全套实验源码+手册+视频下载地址：/thread-318813-1-1.html
4）正点原子官方B站：/394620890
5）正点原子STM32MP157技术交流群：691905614
第四十四章Linux SPI总线框架
到目前为止，我们已经给大家介绍了Linux下的platform总线框架、I2C总线框架，本章将向大家介绍Linux下的SPI总线框架。与I2C总线一样，SPI是物理总线，也是一种很常用的串行通信协议；本章我们就来学习如何在Linux下编写SPI总线接口的设备驱动。本章实验的最终目的就是驱动STM32MP1开发板上的ICM-20608这个SPI接口的六轴传感器，可以在应用程序中读取ICM-20608的原始传感器数据。
44.1 SPI & ICM-20608简介
44.1.1 SPI简介
上一章我们讲解了I2C，I2C是串行通信的一种，只需要两根线就可以完成主机和从机之间的通信，但是I2C的速度最高只能到400KHz，如果对于访问速度要求比价高的话I2C就不适合了。本章我们就来学习一下另外一个和I2C一样广泛使用的串行通信：SPI，SPI全称是Serial Perripheral Interface，也就是串行外围设备接口。SPI是Motorola公司推出的一种同步串行接口技术，是一种高速、全双工的同步通信总线，SPI时钟频率相比I2C要高很多，最高可以工作在上百MHz。SPI以主从方式工作，通常是有一个主设备和一个或多个从设备，一般SPI需要4根线，但是也可以使用三根线(单向传输)，本章我们讲解标准的4线SPI，这四根线如下：
①、CS/SS，Slave Select/Chip Select，这个是片选信号线，用于选择需要进行通信的从设备。I2C主机是通过发送从机设备地址来选择需要进行通信的从机设备的，SPI主机不需要发送从机设备，直接将相应的从机设备片选信号拉低即可。
②、SCK，Serial Clock，串行时钟，和I2C的SCL一样，为SPI通信提供时钟。
③、MOSI/SDO，Master Out Slave In/Serial Data Output，简称主出从入信号线，这根数据线只能用于主机向从机发送数据，也就是主机输出，从机输入。
④、MISO/SDI，Master In Slave Out/Serial Data Input，简称主入从出信号线，这根数据线只能用户从机向主机发送数据，也就是主机输入，从机输出。
SPI通信都是由主机发起的，主机需要提供通信的时钟信号。主机通过SPI线连接多个从设备的结构如图44.1.1.1所示：
图44.1.1.1 SPI设备连接图
SPI有四种工作模式，通过串行时钟极性(CPOL)和相位(CPHA)的搭配来得到四种工作模式：
①、CPOL=0，串行时钟空闲状态为低电平。
②、CPOL=1，串行时钟空闲状态为高电平，此时可以通过配置时钟相位(CPHA)来选择具体的传输协议。
③、CPHA=0，串行时钟的第一个跳变沿(上升沿或下降沿)采集数据。
④、CPHA=1，串行时钟的第二个跳变沿(上升沿或下降沿)采集数据。
这四种工作模式如图44.1.1.2所示：
图44.1.1.2 SPI四种工作模式
和I2C一样，SPI也是有时序图的，以CPOL=0，CPHA=0这个工作模式为例，SPI进行全双工通信的时序如图44.1.1.3所示：
图44.1.1.3 SPI时序图
从图44.1.1.3可以看出，SPI的时序图很简单，不像I2C那样还要分为读时序和写时序，因为SPI是全双工的，所以读写时序可以一起完成。图44.1.1.3中，CS片选信号先拉低，选中要通信的从设备，然后通过MOSI和MISO这两根数据线进行收发数据，MOSI数据线发出了0XD2这个数据给从设备，同时从设备也通过MISO线给主设备返回了0X66这个数据。这个就是SPI时序图。
关于SPI就讲解到这里，接下来我们看一下STM32MP1自带的SPI外设。
44.1.2 STM32MP1 SPI简介
STM32MP1自带的SPI全称为：Serial peripheral interface。SPI特性如下：
①、全双工同步串口接口。
②、半双工模式。
③、可配置的主/从模式。
④、支持I2S协议。
⑤、在达到 FIFO 阈值、超时、操作完成以及发生访问错误时产生中断。
⑥、允许16位，24位或者32位数据长度。
⑦、支持软件片选和硬件片选。
STM32MP1的SPI可以工作在主模或从模式，本章我们使用主模式，此芯片有6个SPI，其中SPI1~3是支持I2S协议。在主模式下，可以选择硬件片选和软件片选，如果使用了硬件片选，那么每一个SPI只支持一个外设，软件片选就可以支持无数个外设，本章实验我们不使用硬件片选信号，因为硬件片选信号只能使用指定的片选IO，软件片选的话可以使用任意的IO。
44.1.3 ICM-20608简介
ICM-20608是InvenSense出品的一款6轴MEMS传感器，包括3轴加速度和3轴陀螺仪。ICM-20608尺寸非常小，只有3x3x0.75mm，采用16P的LGA封装。ICM-20608内部有一个512字节的FIFO。陀螺仪的量程范围可以编程设置，可选择±250，±500，±1000和±2000°/s，加速度的量程范围也可以编程设置，可选择±2g，±4g，±4g，±8g和±16g。陀螺仪和加速度计都是16位的ADC，并且支持I2C和SPI两种协议，使用I2C接口的话通信速度最高可以达到400KHz，使用SPI接口的话通信速度最高可达到8MHz。开发板上的ICM-20608通过SPI接口和STM32MP157连接在一起。ICM-20608特性如下：
①、陀螺仪支持X,Y和Z三轴输出，内部集成16位ADC，测量范围可设置：±250，±500，±1000和±2000°/s。
②、加速度计支持X,Y和Z轴输出，内部集成16位ADC，测量范围可设置：±2g，±4g，±4g，±8g和±16g。
③、用户可编程中断。
④、内部包含512字节的FIFO。
⑤、内部包含一个数字温度传感器。
⑥、耐10000g的冲击。
⑦、支持快速I2C，速度可达400KHz。
⑧、支持SPI，速度可达8MHz。
ICM-20608的3轴方向如图44.1.3.1所示：
图44.1.3.1 ICM-20608检测轴方向和极性
ICM-20608的结构框图如图44.1.3.2所示：
图44.1.3.2 ICM-20608框图
如果使用IIC接口的话，ICM-20608的AD0引脚决定I2C设备从地址的最后一位，如果AD0为0的话ICM-20608从设备地址是0X68，如果AD0为1的话ICM-20608从设备地址为0X69。本章我们使用SPI接口，跟上一章使用AP3216C一样，ICM-20608也是通过读写寄存器来配置和读取传感器数据，使用SPI接口读写寄存器需要16个时钟或者更多(如果读写操作包括多个字节的话)，第一个字节包含要读写的寄存器地址，寄存器地址最高位是读写标志位，如果是读的话寄存器地址最高位要为1，如果是写的话寄存器地址最高位要为0，剩下的7位才是实际的寄存器地址，寄存器地址后面跟着的就是读写的数据。表44.1.3.1列出了本章实验用到的一些寄存器和位，关于ICM-20608的详细寄存器和位的介绍请参考ICM-20608的寄存器手册：
ICM-20608的介绍就到这里，关于ICM-20608的详细介绍请参考ICM-20608的数据手册和寄存器手册。
44.2 Linux下SPI驱动框架
SPI总线框架和I2C总线框架很类似，都采用了主机控制器驱动和设备驱动分离的思想；主机控制器也就是SoC的SPI控制器，例如STM32MP1的SPI控制器；而设备驱动对应的则是挂在SPI总线下的从机设备驱动程序。主机控制器针对具体的SOC平台，例如STM32MP1，对于同一个SOC平台来说，SPI控制器驱动程序是不用动的，不管外接的是什么SPI从机设备，对应的控制器驱动程序都一样，所以我们的重点就落在了种类繁多的SPI从机设备驱动开发了。SPI控制器驱动程序一般是不需要驱动开发工程师自己编写，SOC厂商会提供相应的主机驱动程序。
在Linux内核当中，与I2C总线框架一样，SPI总线框架（也可以叫做SPI子系统）也可以分为三个部分：
SPI核心层：SPI核心层是Linux的SPI子系统的核心代码部分，提供了核心数据结构的定义、SPI控制器驱动和设备驱动的注册、注销、管理等API。其为硬件平台无关层，向下屏蔽了物理总线控制器的差异，定义了统一的访问策略和接口；其向上提供了统一的接口，以便SPI设备驱动通过总线控制器进行数据收发。在Linux系统中，SPI核心层的代码位于drivers/spi/spi.c。
SPI控制器驱动层：每种处理器平台都有自己的SPI控制器驱动程序，它的职责是为系统中的SPI总线实现相应的读写方法。例如STM32MP1就有六个SPI，那么就有六个SPI控制器，每个控制器都有一条特定的SPI总线的读写。SPI子系统使用struct spi_master数据结构体来描述SPI控制器。在内核源码drivers/spi目录下有很多以spi-xxxx.c命名的源文件，如图44.2.1：
图44.2.1 SPI控制器驱动源码
这些文件就是具体平台对应的SPI控制器驱动程序，使用SPI核心层提供的接口向SPI子系统注册SPI控制器。
SPI设备驱动层：SPI从设备对应的驱动程序，比如一些SPI接口的芯片器件对应的驱动程序。接下来我们详细的聊聊SPI子系统。
44.2.1 SPI主机驱动
SPI主机驱动就是SoC的SPI控制器驱动，类似I2C总线的适配器驱动。SPI子系统使用spi_master结构体来描述SPI控制器，其实spi_master是一个宏，这个宏定义在include/linux/spi/spi.h文件中，如下所示：
#define spi_master spi_controller
所以由此可以知道，spi_master就是spi_controller结构体，该结构体定义在include/linux/spi/spi.h文件中，如下所示：
示例代码44.2.1 spi_controller结构体424 struct spi_controller {425struct device dev; /* device 对象 */426427struct list_head list;......435s16 bus_num; /* SPI总线编号 */......440u16 num_chipselect; /* 片选 */441442/* some SPI controllers pose alignment requirements on DMAable443* buffers; let protocol drivers know about these requirements.444*/445u16 dma_alignment;446447/* spi_device.mode flags understood by this controller driver */448u32 mode_bits;/* 模式位 */......455/* limits on transfer speed */456u32 min_speed_hz; /* SPI控制器支持的最小传输速率 */457u32 max_speed_hz; /* SPI控制器支持的最大传输速率 */458459/* other constraints relevant to this driver */460u16 flags; /* 传输类型标志 */......468469/* flag indicating this is an SPI slave controller */470bool slave; /* 标志该控制器是否为SPI从设备存在 */471472/*473* on some hardware transfer / message size may be constrained474* the limit may depend on device transfer settings475*/476size_t (*max_transfer_size)(struct spi_device *spi);477size_t (*max_message_size)(struct spi_device *spi);478479/* I/O mutex */480struct mutex io_mutex;481482/* lock and mutex for SPI bus locking */483spinlock_tbus_lock_spinlock;484struct mutex bus_lock_mutex;485486 /* flag indicating that the SPI bus is locked for exclusive use */487bool bus_lock_flag;......495int (*setup)(struct spi_device *spi);......527int (*transfer)(struct spi_device *spi,528struct spi_message *mesg);......567int (*prepare_transfer_hardware)(struct spi_controller *ctlr);568int (*transfer_one_message)(struct spi_controller *ctlr,569 struct spi_message *mesg);......607 };
第495行，SPI控制器的setup函数，类似于初始化函数。第527行，SPI控制器的transfer函数，和i2c_algorithm中的master_xfer函数一样，控制器数据传输函数。第568行，transfer_one_message 函数，也用于 SPI 数据发送，用于发送一个 spi_message，
SPI 的数据会打包成 spi_message，然后以队列方式发送出去。
SPI 主机端最终会通过 transfer 函数与 SPI 设备进行通信，因此对于 SPI 主机控制器的驱动编写者而言 transfer 函数是需要实现的，因为不同的 SOC 其 SPI 控制器不同，寄存器都不一样。和 I2C 适配器驱动一样，SPI 主机驱动一般都是 SOC 厂商去编写的，所以我们作为 SOC 的使用者，这一部分的驱动就不用操心了，除非你是在 SOC 原厂工作，内容就是写 SPI 主机驱动。
SPI 主机驱动的核心就是申请 spi_master，然后初始化 spi_master，最后向 Linux 内核注册spi_master。
1、spi_master申请与释放
spi_alloc_master函数用于申请spi_master，函数原型如下：
struct spi_controller *spi_alloc_master(struct device *host,
unsigned int size)
函数参数和返回值含义如下：
host：设备，一般是platform_device中的dev成员变量。
size：私有数据大小，可以通过spi_master_get_devdata函数获取到这些私有数据。
返回值：申请到的spi_controller，也就是spi_master。
spi_master的释放通过spi_master_put函数来完成，当我们删除一个SPI主机驱动的时候就需要释放掉前面申请的spi_master，spi_master_put本质上是个宏：
#define spi_master_put(_ctlr) spi_controller_put(_ctlr)
spi_master_put函数最终通过调用spi_controller_put函数来完成spi_master释放，原型如下：
void spi_master_put(struct spi_controller *ctlr)
函数参数和返回值含义如下：
ctlr：要释放的spi_master。
返回值：无。
2、spi_master的注册与注销
当spi_master初始化完成以后就需要将其注册到Linux内核，spi_master注册函数为spi_register_master，函数原型如下：
int spi_register_master(struct spi_controller *ctlr)
函数参数和返回值含义如下：
ctlr：要注册的spi_master。
返回值：0，成功；负值，失败。
如果要注销spi_master的话可以使用spi_unregister_master函数，此函数原型为：
void spi_unregister_master(struct spi_controller *ctlr)
函数参数和返回值含义如下：
ctlr：要注销的spi_master。
返回值：无。
44.2.2 SPI设备驱动
spi设备驱动和i2c设备驱动也很类似，Linux内核使用spi_driver结构体来表示spi设备驱动，我们在编写SPI设备驱动的时候需要实现spi_driver。spi_driver结构体定义在include/linux/spi/spi.h文件中，结构体内容如下：
示例代码44.2.2.1 spi_driver结构体259 struct spi_driver {260const struct spi_device_id *id_table;261int (*probe)(struct spi_device *spi);262int (*remove)(struct spi_device *spi);263void(*shutdown)(struct spi_device *spi);264struct device_driver driver;265 };
可以看出，spi_driver和i2c_driver、platform_driver基本一样，当SPI设备和驱动匹配成功以后probe函数就会执行。
同样的，spi_driver初始化完成以后需要向Linux内核注册，spi_driver注册函数为spi_register_driver，函数原型如下：
int spi_register_driver(struct spi_driver *sdrv)
函数参数和返回值含义如下：
sdrv：要注册的spi_driver。
返回值：0，注册成功；赋值，注册失败。
注销SPI设备驱动以后也需要注销掉前面注册的spi_driver，使用spi_unregister_driver函数完成spi_driver的注销，函数原型如下：
void spi_unregister_driver(struct spi_driver *sdrv)
函数参数和返回值含义如下：
sdrv：要注销的spi_driver。
返回值：无。
spi_driver注册示例程序如下：
示例代码44.2.2.2 spi_driver注册示例程序1 /* probe函数 */2 static int xxx_probe(struct spi_device *spi)3 {4 /* 具体函数内容 */5 return 0;6 }7 8 /* remove函数 */9 static int xxx_remove(struct spi_device *spi)10 {11 /* 具体函数内容 */12 return 0;13 }14 /* 传统匹配方式ID列表 */15 static const struct spi_device_id xxx_id[] = {16 {"xxx", 0}, 17 {}18 };19 20 /* 设备树匹配列表 */21 static const struct of_device_id xxx_of_match[] = {22 {.compatible = "xxx" },23 {/* Sentinel */ }24 };25 26 /* SPI驱动结构体 */ 27 static struct spi_driver xxx_driver = {28 .probe = xxx_probe,29 .remove = xxx_remove,30 .driver = {31.owner = THIS_MODULE,32.name = "xxx",33.of_match_table = xxx_of_match, 34 },35 .id_table = xxx_id,36 };37 38 /* 驱动入口函数 */39 static int __init xxx_init(void)40 {41 return spi_register_driver(&xxx_driver);42 }43 44 /* 驱动出口函数 */45 static void __exit xxx_exit(void)46 {47 spi_unregister_driver(&xxx_driver);48 }49 50 module_init(xxx_init);51 module_exit(xxx_exit);
第1~36行，spi_driver结构体，需要SPI设备驱动人员编写，包括匹配表、probe函数等。和i2c_driver、platform_driver一样，就不详细讲解了。第39~42行，在驱动入口函数中调用spi_register_driver来注册spi_driver。第45~48行，在驱动出口函数中调用spi_unregister_driver来注销spi_driver。
44.2.3 SPI设备和驱动匹配过程
SPI设备和驱动的匹配过程是由SPI总线来完成的，这点和platform、I2C等驱动一样，SPI总线为spi_bus_type，定义在drivers/spi/spi.c文件中，内容如下：
示例代码44.2.3.1 spi_bus_type结构体377 struct bus_type spi_bus_type = {378.name = "spi",379.dev_groups = spi_dev_groups,380.match= spi_match_device,381.uevent= spi_uevent,382 };
可以看出，SPI设备和驱动的匹配函数为spi_match_device，函数内容如下：
示例代码44.2.3.2 spi_match_device函数342 static int spi_match_device(struct device *dev, struct device_driver *drv)343 {344const struct spi_device *spi = to_spi_device(dev);345const struct spi_driver *sdrv = to_spi_driver(drv);346347/* Check override first, and if set, only use the named driver */348if (spi->driver_override)349 return strcmp(spi->driver_override, drv->name) == 0;350351/* Attempt an OF style match */352if (of_driver_match_device(dev, drv))353 return 1;354355/* Then try ACPI */356if (acpi_driver_match_device(dev, drv))357 return 1;358359if (sdrv->id_table)360 return !!spi_match_id(sdrv->id_table, spi);361362return strcmp(spi->modalias, drv->name) == 0;363 }
spi_match_device函数和i2c_match_device函数的对于设备和驱动的匹配过程基本一样。
第352行，of_driver_match_device函数用于完成设备树设备和驱动匹配。比较SPI设备节点的compatible属性和of_device_id中的compatible属性是否相等，如果相当的话就表示SPI设备和驱动匹配。
第356行，acpi_driver_match_device函数用于ACPI形式的匹配。
第360行，spi_match_id函数用于传统的、无设备树的SPI设备和驱动匹配过程。比较SPI设备名字和spi_device_id的name字段是否相等，相等的话就说明SPI设备和驱动匹配。
第362行，比较spi_device中modalias成员变量和device_driver中的name成员变量是否相等。
44.3 STM32MP1 SPI主机驱动分析
和I2C的适配器驱动一样，SPI主机驱动一般都由SOC厂商编写好了，打开stm32mp151.dtsi文件，找到如下所示内容：
示例代码44.3.1 stm32mp151.dtsi文件中的spi1节点内容1 spi1: spi@44004000 {2 #address-cells = <1>;3 #size-cells = <0>;4 compatible = "st,stm32h7-spi";5 reg = <0x44004000 0x400>;6 interrupts = <GIC_SPI 35 IRQ_TYPE_LEVEL_HIGH>;7 clocks = <&rcc SPI1_K>;8 resets = <&rcc SPI1_R>;9 dmas = <&dmamux1 37 0x400 0x01>,10 <&dmamux1 38 0x400 0x01>;11dma-names = "rx", "tx";12power-domains = <&pd_core>;13status = "disabled";14 };
重点来看一下第4行的compatible属性值，compatible属性为“st,stm32h7-spi”，在Linux内核源码中搜素这两个属性值即可找到STM32MP1对应的SPI主机驱动。STM32MP1的SPI主机驱动文件为drivers/spi/spi-stm32.c，在此文件中找到如下内容：
示例代码44.3.2 stm32_spi_driver结构体1859 static const struct of_device_id stm32_spi_of_match[] = {1860 {.compatible = "st,stm32h7-spi", .data = (void *)&stm32h7_spi_cfg },1861{.compatible = "st,stm32f4-spi", .data = (void *)&stm32f4_spi_cfg },1862 {},1863 };......2154 static struct platform_driver stm32_spi_driver = {2155 .probe = stm32_spi_probe,2156 .remove = stm32_spi_remove,2157 .driver = {2158 .name = DRIVER_NAME,2159 .pm = &stm32_spi_pm_ops,2160 .of_match_table = stm32_spi_of_match,2161 },2162 };21632164 module_platform_driver(stm32_spi_driver);
第1860行，“st,stm32h7-spi”匹配项，因此可知STM32MP1主机驱动就是spi-stm32.c这个文件。第2154~2164行，从这里可以知道，该主机驱动程序是基于platform总线框架编写，platform_driver结构体变量为stm32_spi_driver，当platform总线下设备和设备驱动匹配成功之后就会执行stm32_spi_probe函数，同样当驱动模块卸载的时候就会执行stm32_spi_remove函数。接下来我们重点来看下stm32_spi_probe函数做了些什么，函数如下所示：
示例代码44.3.3 stm32_spi_probe函数1866 static int stm32_spi_probe(struct platform_device *pdev)1867 {1868 struct spi_master *master;1869 struct stm32_spi *spi;1870 struct resource *res;1871 struct reset_control *rst;1872 int i, ret, num_cs, cs_gpio;18731874 master = spi_alloc_master(&pdev->dev, sizeof(struct stm32_spi));1875 if (!master) {1876 dev_err(&pdev->dev, "spi master allocation failed\n");1877 return -ENOMEM;1878 }.....1892 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);1893 spi->base = devm_ioremap_resource(&pdev->dev, res);1894 if (IS_ERR(spi->base)) {1895 ret = PTR_ERR(spi->base);1896 goto err_master_put;1897 }18981899 spi->phys_addr = (dma_addr_t)res->start;19001901 spi->irq = platform_get_irq(pdev, 0);1902 if (spi->irq <= 0) {1903 ret = spi->irq;1904 if (ret != -EPROBE_DEFER)1905dev_err(&pdev->dev, "failed to get irq: %d\n", ret);1906 goto err_master_put;1907 }1908 ret = devm_request_threaded_irq(&pdev->dev, spi->irq,1909 spi->cfg->irq_handler_event,1910 spi->cfg->irq_handler_thread,1911 IRQF_ONESHOT, pdev->name, master);......1963 master->dev.of_node = pdev->dev.of_node;1964 master->auto_runtime_pm = true;1965 master->bus_num = pdev->id;1966 master->mode_bits = SPI_CPHA | SPI_CPOL | SPI_CS_HIGH | 1967SPI_LSB_FIRST | SPI_3WIRE;1968 master->bits_per_word_mask = spi->cfg->get_bpw_mask(spi);1969master->max_speed_hz = spi->clk_rate /spi->cfg->baud_rate_div_min;1970master->min_speed_hz = spi->clk_rate / spi->cfg->baud_rate_div_max;1971 master->setup = stm32_spi_setup;1972 master->prepare_message = stm32_spi_prepare_msg;1973 master->transfer_one = stm32_spi_transfer_one;1974 master->unprepare_message = stm32_spi_unprepare_msg;...... 2026 ret = spi_register_master(master);......2050 }
第1874行，通过调用spi_alloc_master函数为master指针申请内存，也就是实例化master。第1901~1911行，获取中断号和注册中断函数。第1963~1974行，对master变量进行初始化和赋值，从结果可以看到，master 结构体中并没有设置 transfer 和 transfer_one_message 这两个用于 SPI 数据传输的函数，而是使用了 transfer_one 作为 SPI 数据传输的函数，对应的函数为stm32_spi_transfer_one，也就是该函数是STM32MP1 SPI数据传输的函数。第2026行，调用spi_register_master函数向SPI子系统注册一个master。这里简单第看看stm32_spi_transfer_one函数的内容，如下所示(有省略)：
示例代码44.3.4 stm32_spi_transferZ_one函数1683 static int stm32_spi_transfer_one(struct spi_master *master,1684 struct spi_device *spi_dev,1685 struct spi_transfer *transfer)1686 {1687 struct stm32_spi *spi = spi_master_get_devdata(master);1688 u32 xfer_time, midi_delay_ns;1689 unsigned long timeout;1690 int ret;16911692 spi->tx_buf = transfer->tx_buf;1693 spi->rx_buf = transfer->rx_buf;1694 spi->tx_len = spi->tx_buf ? transfer->len : 0;1695 spi->rx_len = spi->rx_buf ? transfer->len : 0;16961697 spi->cur_usedma = (master->can_dma &&1698 master->can_dma(master, spi_dev, transfer));16991700 ret = stm32_spi_transfer_one_setup(spi, spi_dev, transfer);1701 if (ret) {1702 dev_err(spi->dev, "SPI transfer setup failed\n");1703 return ret;1704 }17051706 reinit_completion(&spi->xfer_completion);1707 spi->xfer_status = 0;17081709 if (spi->cur_usedma)1710 ret = stm32_spi_transfer_one_dma(spi, transfer);1711 else1712 ret = spi->cfg->transfer_one_irq(spi);17131714 if (ret)1715 return ret;......1739 }
第1709~1715行，如果启动了DMA那么就使用stm32_spi_transfer_one_dma来进行传输数据，没有用DMA的话就调用transfer_one_irq函数。这两个函数也就是控制寄存器来进行收发数据。关于STM32MP1 SPI主机程序的分析就到这里了。
44.4 SPI设备驱动编写流程
44.4.1 SPI设备信息描述
1、IO的pinctrl子节点创建与修改
首先肯定是根据所使用的IO来创建或者修改pinctrl子节点，这个没有什么好说的。唯独要注意的是检查相应的IO有没有被其它的设备所使用，如果有多个pinctrl配置相同的IO是没有关系的，只要保证没有被设备调用就行。
2、SPI设备节点的创建与修改
采用设备树方式的情况下，SPI从机设备信息描述就通过创建相应的设备子节点来完成，我们可以打开stm32mp157d-atk.dts这个设备树文件，然后在里边创建一个SPI从机设备节点，描述该设备的相关信息，我们后面再创建。
44.4.2 SPI从机设备数据收发处理流程
SPI设备驱动的核心是spi_driver，这个我们已经在44.2.2小节讲过了。当我们向Linux内核注册成功spi_driver以后就可以使用SPI核心层提供的API函数来对设备进行读写操作了。首先是spi_transfer结构体，此结构体用于描述SPI传输信息，结构体内容如下：
示例代码44.4.2.1 spi_transfer结构体811 struct spi_transfer {......817const void *tx_buf;818void *rx_buf;819unsigned len;820821dma_addr_t tx_dma;822dma_addr_t rx_dma;823struct sg_table tx_sg;824struct sg_table rx_sg;825826unsigned cs_change:1;827unsigned tx_nbits:3;828unsigned rx_nbits:3;829 #define SPI_NBITS_SINGLE 0x01 /* 1bit transfer */830 #define SPI_NBITS_DUAL0x02 /* 2bits transfer */831 #define SPI_NBITS_QUAD0x04 /* 4bits transfer */832u8bits_per_word;833u8word_delay_usecs;834u16delay_usecs;835u16cs_change_delay;836u8cs_change_delay_unit;837 #define SPI_DELAY_UNIT_USECS 0838 #define SPI_DELAY_UNIT_NSECS 1839 #define SPI_DELAY_UNIT_SCK 2840u32speed_hz;841u16word_delay;842843u32effective_speed_hz;844845struct list_head transfer_list;846 };
第817行，tx_buf保存着要发送的数据。
第818行，rx_buf用于保存接收到的数据。
第819行，len是要进行传输的数据长度，SPI是全双工通信，因此在一次通信中发送和接收的字节数都是一样的，所以spi_transfer中也就没有发送长度和接收长度之分。
spi_transfer需要组织成spi_message，spi_message也是一个结构体，内容如下：
示例代码44.4.2.2 spi_message结构体878 struct spi_message {879struct list_head transfers;880881struct spi_device *spi;882883unsigned is_dma_mapped:1;......897void (*complete)(void *context);898void *context;899unsigned frame_length;900unsigned actual_length;901int status;......907struct list_head queue;908void *state;909910/* list of spi_res reources when the spi message is processed */911struct list_head resources;912 };
在使用spi_message之前需要对其进行初始化，spi_message初始化函数为spi_message_init，函数原型如下：
void spi_message_init(struct spi_message *m)
函数参数和返回值含义如下：
m：要初始化的spi_message。
返回值：无。
spi_message初始化完成以后需要将spi_transfer添加到spi_message队列中，这里我们要用到spi_message_add_tail函数，此函数原型如下：
void spi_message_add_tail(struct spi_transfer *t, struct spi_message *m)
函数参数和返回值含义如下：
t：要添加到队列中的spi_transfer。
m：spi_transfer要加入的spi_message。
返回值：无。
spi_message准备好以后就可以进行数据传输了，数据传输分为同步传输和异步传输，同步传输会阻塞的等待SPI数据传输完成，同步传输函数为spi_sync，函数原型如下：
int spi_sync(struct spi_device *spi, struct spi_message *message)
函数参数和返回值含义如下：
spi：要进行数据传输的spi_device。
message：要传输的spi_message。
返回值：无。
异步传输不会阻塞的等到SPI数据传输完成，异步传输需要设置spi_message中的complete成员变量，complete是一个回调函数，当SPI异步传输完成以后此函数就会被调用。SPI异步传输函数为spi_async，函数原型如下：
int spi_async(struct spi_device *spi, struct spi_message *message)
函数参数和返回值含义如下：
spi：要进行数据传输的spi_device。
message：要传输的spi_message。
返回值：无。
在本章实验中，我们采用同步传输方式来完成SPI数据的传输工作，也就是spi_sync函数。
综上所述，SPI数据传输步骤如下：
①、申请并初始化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数据同步传输。
通过SPI进行n个字节的数据发送和接收的示例代码如下所示：
示例代码44.4.2.3 SPI数据读写操作/* SPI多字节发送 */static int spi_send(struct spi_device *spi, u8 *buf, int len){int ret;struct spi_message m;struct spi_transfer t = {.tx_buf = buf,.len = len,};spi_message_init(&m); /* 初始化spi_message */spi_message_add_tail(t, &m);/* 将spi_transfer添加到spi_message队列 */ret = spi_sync(spi, &m); /* 同步传输 */return ret;}/* SPI多字节接收 */static int spi_receive(struct spi_device *spi, u8 *buf, int len){int ret;struct spi_message m;struct spi_transfer t = {.rx_buf = buf,.len = len,};spi_message_init(&m); /* 初始化spi_message */spi_message_add_tail(t, &m);/* 将spi_transfer添加到spi_message队列 */ret = spi_sync(spi, &m); /* 同步传输 */return ret;};
44.5 硬件原理图分析
STM32MP1开发板上ICM20608原理如图44.5.1所示：
图44.5.1 ICM-20608 原理图
图44.5.1这是ICM-20608的硬件原理图。正点原子STM32MP1开发板的PZ0~3分别连接到ICM-20608的SCK、SDA、AD0和CS。其中6D_INT为ICM20608的中断引脚，连接到PA14引脚上，在本章实验上没有用到ICM20608的中断引脚。
44.6 实验程序编写
本实验对应的例程路径为：开发板光盘1、程序源码2、Linux驱动例程22_spi。
44.6.1 修改设备树
1、添加或者查找ICM20608所使用的IO的pinmux配置
首先在stm32mp15-pinctrl.dtsi文件中添加IO配置信息，ICM20608连接到了STM32MP157的SPI1接口，因此先在stm32mp15-pinctrl.dtsi里面搜索一下，看看有没有SPI1接口引脚配置(在本教程中，默认是有的)。如果没有的话就自行添加，有的话就检查一下SPI1接口的引脚配置是否和自己所使用的硬件一致，不一致的话就要修改。修改后的引脚信息如下所示：
示例代码44.6.1.1 spi1的pinmux配置1 spi1_pins_a: spi1-0 {2 pins1 {3 pinmux = <STM32_PINMUX('Z', 0, AF5)>, /* SPI1_SCK */4 <STM32_PINMUX('Z', 2, AF5)>;/* SPI1_MOSI */5 bias-disable;6 drive-push-pull;7 slew-rate = <1>;8 };9 10 pins2 {11pinmux = <STM32_PINMUX('Z', 1, AF5)>; /* SPI1_MISO */12bias-disable;13 };1415 pins3 {16pinmux = <STM32_PINMUX('Z', 3, GPIO)>; /* SPI1_NSS */17drive-push-pull;18bias-pull-up;19output-high;20slew-rate = <0>;21 };22 };23 24 spi1_sleep_pins_a: spi1-sleep-0 {25 pins {26pinmux = <STM32_PINMUX('Z', 0, ANALOG)>, /* SPI1_SCK */27 <STM32_PINMUX('Z', 1, ANALOG)>, /* SPI1_MISO */28 <STM32_PINMUX('Z', 2, ANALOG)>, /* SPI1_MOSI */29 <STM32_PINMUX('Z', 3, ANALOG)>; /* SPI1_NSS */30 };31 };
示例代码44.6.3.1里15~21行是设置ICM20608的片选信号，直接复用为GPIO，也就是使用软件片选。
2、在SPI1节点下添加pinmux并追加icm20608子节点
在stm32mp157d-atk.dts文件，追加SPI1节点，追加如下所示内容：
示例代码44.6.1.2追加内容的spi1节点1 &spi1 {2 pinctrl-names = "default", "sleep";3 pinctrl-0 = <&spi1_pins_a>;4 pinctrl-1 = <&spi1_sleep_pins_a>;5 cs-gpios = <&gpioz 3 GPIO_ACTIVE_LOW>;6 status = "okay";7 8 spidev: icm20608@0 {9 compatible = "alientek,icm20608";10reg = <0>; /* CS #0 */11spi-max-frequency = <80000000>;12};13 };
第2~4行，设置IO要使用的pinmux配置。
第5行，“cs-gpios”属性是用来设置SPI的片选引脚。SPI主机驱动就会根据此属性去控制设备的片选引脚，本实验我们使用PZ3作为片选引脚。关于cs-gpios属性的详细描述可以参考绑定文档：Documentation/devicetree/bindings/spi/spi-controller.yaml。如果一个SPI接口下连接了多个SPI芯片，那么cs-gpios属性里面就要添加所有SPI芯片的片选信号，比如：
cs-gpios = <&gpio1 0 0>, <&gpio1 1 0>, <&gpio1 2 0>, <&gpio1 3 0>;
上述描述说明此时SPI节点下有4个SPI芯片，第一个SPI芯片的片选引脚为gpio1_0，一以此类推。
第8~12行，icm20608设备子节点，从第5行的cs-gpios节点可以看出，此时SPI接口下只有一个ICM20608，而且ICM20608的片选索引为0，因此@后面为0。注意，@后面的数字就是对应SPI芯片片选信号在cs-gpios中的索引值。第9行设置节点属性兼容值为“alientek,icm20608”，第10行reg属性表示icm20608所使用的片选，和第8行@后面的数字含义相同，这里也设置为0，也就是cs-gpios属性中的第一个片选信号。第11行设置SPI最大时钟频率为8MHz，这是ICM20608的SPI接口所能支持的最大的时钟频率。
44.6.2 编写ICM20608驱动
新建名为“22_spi”的文件夹，然后在22_spi文件夹里面创建vscode工程，工作区命名为“spi”。工程创建好以后新建icm20608.c和icm20608reg.h这两个文件，icm20608.c为ICM20608的驱动代码，icm20608reg.h是ICM20608寄存器头文件。先在icm20608reg.h中定义好ICM20608的寄存器，输入如下内容(有省略，完整的内容请参考例程)：
示例代码44.6.2.1 icm20608reg.h文件内容1 #ifndef ICM20608_H2 #define ICM20608_H3 /***************************************************************4 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.5 文件名 : icm20608reg.h6 作者 : 左忠凯7 版本 : V1.08 描述 : ICM20608寄存器地址描述头文件9 其他: 无10 论坛 : 11 日志 : 初版V1.0 /9/2 左忠凯创建12 ***************************************************************/13 #define ICM20608G_ID 0XAF /* ID值 */14 #define ICM20608D_ID 0XAE /* ID值 */15 16 /* ICM20608寄存器 17 *复位后所有寄存器地址都为0，除了18 *Register 107(0X6B) Power Management 1 = 0x4019 *Register 117(0X75) WHO_AM_I = 0xAF或0xAE20 */21 /* 陀螺仪和加速度自测(出产时设置，用于与用户的自检输出值比较） */22 #define ICM20_SELF_TEST_X_GYRO 0x0023 #define ICM20_SELF_TEST_Y_GYRO0x0124 #define ICM20_SELF_TEST_Z_GYRO 0x0225 #define ICM20_SELF_TEST_X_ACCEL 0x0D26 #define ICM20_SELF_TEST_Y_ACCEL 0x0E27 #define ICM20_SELF_TEST_Z_ACCEL 0x0F......88 #endif
接下来继续编写icm20608.c文件，因为icm20608.c文件内容比较长，因此这里就将其分开来讲解。
1、icm20608设备结构体创建
首先创建一个icm20608设备结构体，如下所示：
示例代码44.6.2.2 icm20608设备结构体创建1 #include <linux/spi/spi.h>2 #include <linux/kernel.h>3 #include <linux/module.h>......1415 #define ICM20608_CNT 116 #define ICM20608_NAME "icm20608"1718 struct icm20608_dev {19struct spi_device *spi; /* spi设备 */20dev_t devid;/* 设备号*/21struct cdev cdev; /* cdev*/22struct class *class; /* 类*/23struct device *device;/* 设备 */24struct device_node *nd; /* 设备节点 */25signed int gyro_x_adc;/* 陀螺仪X轴原始值 */26signed int gyro_y_adc;/* 陀螺仪Y轴原始值 */27signed int gyro_z_adc;/* 陀螺仪Z轴原始值*/28signed int accel_x_adc;/* 加速度计X轴原始值 */29signed int accel_y_adc;/* 加速度计Y轴原始值 */30signed int accel_z_adc;/* 加速度计Z轴原始值 */31signed int temp_adc; /* 温度原始值*/32 };
icm20608的设备结构体icm20608_dev没什么好讲的，重点看一下第19行的spi，对于SPI设备驱动来讲最核心的就是spi_device。probe函数会向驱动提供当前SPI设备对应的spi_device，因此把这个结构体赋值到spi成员里，我们可以在字符串设备里操作spi成员就可以操作对应的SPI设备。2、icm20608的spi_driver注册与注销对于SPI设备驱动，首先就是要初始化并向系统注册spi_driver，icm20608的spi_driver初始化、注册与注销代码如下：
示例代码44.6.2.3 icm20608的spi_driver初始化、注册与注销1 /* 传统匹配方式ID列表 */2 static const struct spi_device_id icm20608_id[] = {3 {"alientek,icm20608", 0},4 {}5 };6 7 /* 设备树匹配列表 */8 static const struct of_device_id icm20608_of_match[] = {9 {.compatible = "alientek,icm20608" },10{/* Sentinel */ }11 };1213 /* SPI驱动结构体 */14 static struct spi_driver icm20608_driver = {15.probe = icm20608_probe,16.remove = icm20608_remove,17.driver = {18 .owner = THIS_MODULE,19 .name = "icm20608",20 .of_match_table = icm20608_of_match,21 },22.id_table = icm20608_id,23 };2425 /*26 * @description : 驱动入口函数27 * @param : 无28 * @return: 无29 */30 static int __init icm20608_init(void)31 {32return spi_register_driver(&icm20608_driver);33 }3435 /*36 * @description : 驱动出口函数37 * @param : 无38 * @return: 无39 */40 static void __exit icm20608_exit(void)41 {42spi_unregister_driver(&icm20608_driver);43 }4445 module_init(icm20608_init);46 module_exit(icm20608_exit);47 MODULE_LICENSE("GPL");48 MODULE_AUTHOR("ALIENTEK");49 MODULE_INFO(intree, "Y");
第2~5行，传统的设备和驱动匹配表。第8~11行，设备树的设备与驱动匹配表，这里只有一个匹配项：“alientek,icm20608”。第14~23行，icm20608的spi_driver结构体变量，当icm20608设备和此驱动匹配成功以后第15行的icm20608_probe函数就会执行。同样的，当注销此驱动的时候icm20608_remove函数会执行。第30~33行，icm20608_init函数为icm20608的驱动入口函数，在此函数中使用spi_register_driver向Linux系统注册上面定义的icm20608_driver。第40~43行，icm20608_exit函数为icm20608的驱动出口函数，在此函数中使用spi_unregister_driver注销掉前面注册的icm20608_driver。
3、probe&remove函数
icm20608_driver中的probe和remove函数内容如下所示：
示例代码44.6.3.4 probe和remove函数1 /*2 * @description : spi驱动的probe函数，当驱动与设备匹配以后此函数3 *就会执行4 * @param - spi : spi设备5 */ 6 static int icm20608_probe(struct spi_device *spi)7 {8 int ret;9 struct icm20608_dev *icm20608dev;10 11 /* 分配icm20608dev对象的空间 */12 icm20608dev = devm_kzalloc(&spi->dev, sizeof(*icm20608dev), GFP_KERNEL);13 if(!icm20608dev)14return -ENOMEM;1516 /* 注册字符设备驱动 */17 /* 1、创建设备号 */18 ret = alloc_chrdev_region(&icm20608dev->devid, 0, ICM20608_CNT, ICM20608_NAME);19 if(ret < 0) {20pr_err("%s Couldn't alloc_chrdev_region, ret=%d\r\n", ICM20608_NAME, ret);21 return 0;22 }23 24 /* 2、初始化cdev */25 icm20608dev->cdev.owner = THIS_MODULE;26 cdev_init(&icm20608dev->cdev, &icm20608_ops);27 28 /* 3、添加一个cdev */29 ret = cdev_add(&icm20608dev->cdev, icm20608dev->devid, ICM20608_CNT);30 if(ret < 0) {31goto del_unregister;32 }33 34 /* 4、创建类 */35 icm20608dev->class = class_create(THIS_MODULE, ICM20608_NAME);36 if (IS_ERR(icm20608dev->class)) {37goto del_cdev;38 }39 40 /* 5、创建设备 */41 icm20608dev->device = device_create(icm20608dev->class, NULL, icm20608dev->devid, NULL, ICM20608_NAME);42 if (IS_ERR(icm20608dev->device)) {43goto destroy_class;44 }45 icm20608dev->spi = spi;46 47 /*初始化spi_device */48 spi->mode = SPI_MODE_0; /*MODE0，CPOL=0，CPHA=0*/49 spi_setup(spi);50 51 /* 初始化ICM20608内部寄存器 */52 icm20608_reginit(icm20608dev); 53 /* 保存icm20608dev结构体 */54 spi_set_drvdata(spi, icm20608dev);55 56 return 0;57 destroy_class:58 device_destroy(icm20608dev->class, icm20608dev->devid);59 del_cdev:60 cdev_del(&icm20608dev->cdev);61 del_unregister:62 unregister_chrdev_region(icm20608dev->devid, ICM20608_CNT);63 return -EIO;64 }65 66 /*67 * @description: spi驱动的remove函数，移除spi驱动的时候此函数会执行68 * @param - spi : spi设备69 * @return : 0，成功;其他负值,失败70 */71 static int icm20608_remove(struct spi_device *spi)72 {73 struct icm20608_dev *icm20608dev = spi_get_drvdata(spi);74 /* 注销字符设备驱动 */75 /* 1、删除cdev */76 cdev_del(&icm20608dev->cdev);77 /* 2、注销设备号 */78 unregister_chrdev_region(icm20608dev->devid, ICM20608_CNT); 79 /* 3、注销设备 */80 device_destroy(icm20608dev->class, icm20608dev->devid);81 /* 4、注销类 */82 class_destroy(icm20608dev->class); 83 return 0;84 }
第6~64行，probe函数，当设备与驱动匹配成功以后此函数就会执行。第12行就是给自定义的结构体申请空间。第25~44行都是标准的注册字符设备驱动。注意我们这边驱动没有去读取“cs-gpios”属性，那是因为SPI的核心会自动控制的，我们不用关心它。第45行，将probe函数的spi_device参数赋值给我们自定义的spi成员变量，也就是保存spi_device结构体对象。第48行，设置SPI为模式0，也就是CPOL=0，CPHA=0。第49行，设置好spi_device以后需要使用spi_setup配置一下。第52行，调用icm20608_reginit函数初始化ICM20608，主要是初始化ICM20608指定寄存器。第54行，icm20608dev变量是在probe函数里申请的内存空间，在remove函数需要释放掉。这里使用spi_set_drvdata函数将icm20608dev地址保存起来，后面再remove函数里面可以通过spi_get_drvdata函数获取到icm20608dev地址。第71~84行，icm20608_remove函数，注销驱动的时候此函数就会执行。我们可以使用spi_get_drvdata函数来获取icm20608dev的地址。
4、icm20608寄存器读写与初始化
SPI驱动最终是通过读写icm20608的寄存器来实现的，因此需要编写相应的寄存器读写函数，并且使用这些读写函数来完成对icm20608的初始化。icm20608的寄存器读写以及初始化代码如下：
示例代码44.6.2.5 icm20608寄存器读写以及初始化1 /*2 * @description : 从icm20608读取多个寄存器数据3 * @param – dev: icm20608设备4 * @param – reg: 要读取的寄存器首地址5 * @param – val: 读取到的数据6 * @param – len: 要读取的数据长度7 * @return: 操作结果8 */9 static int icm20608_read_regs(struct icm20608_dev *dev, u8 reg, void *buf, int len)10 {11 12int ret = -1;13unsigned char txdata[1];14unsigned char * rxdata;15struct spi_message m;16struct spi_transfer *t;17struct spi_device *spi = (struct spi_device *)dev->spi;1819t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);/* 申请内存*/20if(!t) {21return -ENOMEM;22}23rxdata = kzalloc(sizeof(char) * len, GFP_KERNEL); /* 申请内存 */24if(!rxdata) {25goto out1;26}27/* 一共发送len+1个字节的数据，第一个字节为28寄存器首地址，一共要读取len个字节长度的数据，*/29txdata[0] = reg | 0x80; /* 写数据的时候首寄存器地址bit8要置1 */ 30t->tx_buf = txdata;/* 要发送的数据 */31t->rx_buf = rxdata;/* 要读取的数据 */32t->len = len+1;/* t->len=发送的长度+读取的长度 */33spi_message_init(&m); /* 初始化spi_message */34spi_message_add_tail(t, &m);/* 将spi_transfer添加到spi_message*/35ret = spi_sync(spi, &m);/* 同步发送 */36if(ret) {37goto out2;38}3940memcpy(buf , rxdata+1, len); /* 只需要读取的数据 */41 42 out2:43kfree(rxdata); /* 释放内存 */44 out1: 45kfree(t); /* 释放内存 */4647return ret;48 }49 50 /*51 * @description : 向icm20608多个寄存器写入数据52 * @param - dev: icm20608设备53 * @param - reg: 要写入的寄存器首地址54 * @param - val: 要写入的数据缓冲区55 * @param - len: 要写入的数据长度56 * @return : 操作结果57 */58 static s32 icm20608_write_regs(struct icm20608_dev *dev, u8 reg, u8 *buf, u8 len)59 {60int ret = -1;61unsigned char *txdata;62struct spi_message m;63struct spi_transfer *t;64struct spi_device *spi = (struct spi_device *)dev->spi;6566t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);/* 申请内存*/67if(!t) {68return -ENOMEM;69}7071txdata = kzalloc(sizeof(char)+len, GFP_KERNEL);72if(!txdata) {73goto out1;74}7576/* 一共发送len+1个字节的数据，第一个字节为77寄存器首地址，len为要写入的寄存器的集合，*/78*txdata = reg & ~0x80; /* 写数据的时候首寄存器地址bit8要清零 */79memcpy(txdata+1, buf, len); /* 把len个数据拷贝到txdata里*/80t->tx_buf = txdata; /* 要发送的数据 */81t->len = len+1; /* t->len=发送的长度+读取的长度*/82spi_message_init(&m); /* 初始化spi_message */83spi_message_add_tail(t, &m);/*添加到spi_message队列 */84ret = spi_sync(spi, &m); /* 同步发送 */85if(ret) {86goto out2;87}8889 out2:90kfree(txdata); /* 释放内存 */91 out1:92kfree(t); /* 释放内存 */93return ret;94 95 }96 97 /*98 * @description : 读取icm20608指定寄存器值，读取一个寄存器99 * @param – dev: icm20608设备100 * @param – reg: 要读取的寄存器101 * @return : 读取到的寄存器值102 */103 static unsigned char icm20608_read_onereg(struct icm20608_dev *dev, u8 reg)104 {105u8 data = 0;106icm20608_read_regs(dev, reg, &data, 1);107return data;108 }109110 /*111 * @description : 向icm20608指定寄存器写入指定的值，写一个寄存器112 * @param – dev: icm20608设备113 * @param – reg: 要写的寄存器114 * @param – data: 要写入的值115 * @return : 无116 */ 117118 static void icm20608_write_onereg(struct icm20608_dev *dev, u8 reg, u8 value)119 {120u8 buf = value;121icm20608_write_regs(dev, reg, &buf, 1);122 }123124 /*125 * @description : 读取ICM20608的数据，读取原始数据，包括三轴陀螺仪、126 * : 三轴加速度计和内部温度。127 * @param - dev : ICM20608设备128 * @return: 无。129 */130 void icm20608_readdata(struct icm20608_dev *dev)131 {132unsigned char data[14];133icm20608_read_regs(dev, ICM20_ACCEL_XOUT_H, data, 14);134135dev->accel_x_adc = (signed short)((data[0] << 8) | data[1]); 136dev->accel_y_adc = (signed short)((data[2] << 8) | data[3]); 137dev->accel_z_adc = (signed short)((data[4] << 8) | data[5]); 138dev->temp_adc = (signed short)((data[6] << 8) | data[7]); 139dev->gyro_x_adc = (signed short)((data[8] << 8) | data[9]); 140dev->gyro_y_adc = (signed short)((data[10] << 8) | data[11]);141dev->gyro_z_adc = (signed short)((data[12] << 8) | data[13]);142 }143144 /*145 * ICM20608内部寄存器初始化函数 146 * @param - spi : 要操作的设备147 * @return : 无148 */149 void icm20608_reginit(struct icm20608_dev *dev)150 {151u8 value = 0;152153icm20608_write_onereg(dev, ICM20_PWR_MGMT_1, 0x80);154mdelay(50);155icm20608_write_onereg(dev, ICM20_PWR_MGMT_1, 0x01);156mdelay(50);157158value = icm20608_read_onereg(dev, ICM20_WHO_AM_I);159printk("ICM20608 ID = %#X\r\n", value); 160161icm20608_write_onereg(dev, ICM20_SMPLRT_DIV, 0x00); 162icm20608_write_onereg(dev, ICM20_GYRO_CONFIG, 0x18); 163icm20608_write_onereg(dev, ICM20_ACCEL_CONFIG, 0x18);164icm20608_write_onereg(dev, ICM20_CONFIG, 0x04); 165icm20608_write_onereg(dev, ICM20_ACCEL_CONFIG2, 0x04);166icm20608_write_onereg(dev, ICM20_PWR_MGMT_2, 0x00); 167icm20608_write_onereg(dev, ICM20_LP_MODE_CFG, 0x00);168icm20608_write_onereg(dev, ICM20_FIFO_EN, 0x00);169 }
第9~48行，icm20608_read_regs函数，从icm20608中读取连续多个寄存器数据；注意：在本实验中，SPI为全双工通讯没有所谓的发送和接收长度之分。要读取或者发送N个字节就要封装N+1个字节，第1个字节是告诉设备我们要进行读还是写，后面的N个字节才是我们要读或者发送的数据。第58~95行，icm20608_write_rege函数，向icm20608连续写入多个寄存器数据。此函数和icm20608_read_regs函数区别不大。第103~108行，icm20608_read_onereg函数，读取icm20608指定一个寄存器数据。第118~122行，icm20608_write_onereg函数，向icm20608指定一个寄存器写入数据。第130~142行，icm20608_readdata函数，读取icm20608六轴传感器和温度传感器原始数据值，应用程序读取icm20608的时候这些传感器原始数据就会上报给应用程序。第149~169行，icm20608_reginit函数，初始化icm20608。
5、字符设备驱动框架
icm20608的字符设备驱动框架如下：
示例代码44.6.2.6 icm20608字符设备驱动1 /*2 * @description : 打开设备3 * @param – inode: 传递给驱动的inode4 * @param - filp : 要打开的设备文件(文件描述符)5 * @return : 0 成功;其他 失败6 */7 static int icm20608_open(struct inode *inode, struct file *filp)8 {9 return 0;10 }1112 /*13 * @description : 从设备读取数据 14 * @param – filp: 要打开的设备文件(文件描述符)15 * @param - buf : 返回给用户空间的数据缓冲区16 * @param - cnt : 要读取的数据长度17 * @param – offt: 相对于文件首地址的偏移18 * @return : 读取的字节数，如果为负值，表示读取失败19 */20 static ssize_t icm20608_read(struct file *filp, char __user *buf, size_t cnt, loff_t *off)21 {22signed int data[7];23long err = 0;24struct cdev *cdev = filp->f_path.dentry->d_inode->i_cdev;25struct icm20608_dev *dev = container_of(cdev, struct icm20608_dev,cdev);26 27icm20608_readdata(dev);28data[0] = dev->gyro_x_adc;29data[1] = dev->gyro_y_adc;30data[2] = dev->gyro_z_adc;31data[3] = dev->accel_x_adc;32data[4] = dev->accel_y_adc;33data[5] = dev->accel_z_adc;34data[6] = dev->temp_adc;35err = copy_to_user(buf, data, sizeof(data));36return 0;37 }3839 /*40 * @description : 关闭/释放设备41 * @param – filp: 要关闭的设备文件(文件描述符)42 * @return : 0 成功;其他 失败43 */44 static int icm20608_release(struct inode *inode, struct file *filp)45 {46return 0;47 }4849 /* icm20608操作函数 */50 static const struct file_operations icm20608_ops = {51.owner = THIS_MODULE,52.open = icm20608_open,53.read = icm20608_read,54.release = icm20608_release,55 };
字符设备驱动框架没什么好说的，重点是第20~37行的icm20608_read函数，当应用程序调用read函数读取icm20608设备文件的时候此函数就会执行。其中的24和25行里，通过probe注册的cdev变量，获取到我们自定义的icm20608_dev结构体的首地址。此函数调用上面编写好的icm20608_readdata函数读取icm20608的原始数据并将其上报给应用程序。大家注意，在内核中尽量不要使用浮点运算，所以不要在驱动将icm20608的原始值转换为对应的实际值，因为会涉及到浮点计算。这个驱动例程还不是很完美，在icm20608_read没有加锁。如果多个程序去读取这个驱动的时候就会出现读取数据出错，有能力的可以把这一点补充完整。
44.6.3 编写测试APP
新建icm20608App.c文件，然后在里面输入如下所示内容：
示例代码44.6.3.1 icm20608App.c文件代码12 #include "stdio.h"13 #include "unistd.h"14 #include "sys/types.h"15 #include "sys/stat.h"16 #include "sys/ioctl.h"17 #include "fcntl.h"18 #include "stdlib.h"19 #include "string.h"20 #include <poll.h>21 #include <sys/select.h>22 #include <sys/time.h>23 #include <signal.h>24 #include <fcntl.h>25 /*26 * @description : main主程序27 * @param – argc: argv数组元素个数28 * @param - argv : 具体参数29 * @return : 0 成功;其他 失败30 */31 int main(int argc, char *argv[])32 {33int fd;34char *filename;35signed int databuf[7];36unsigned char data[14];37signed int gyro_x_adc, gyro_y_adc, gyro_z_adc;38signed int accel_x_adc, accel_y_adc, accel_z_adc;39signed int temp_adc;4041float gyro_x_act, gyro_y_act, gyro_z_act;42float accel_x_act, accel_y_act, accel_z_act;43float temp_act;4445int ret = 0;4647if (argc != 2) {48printf("Error Usage!\r\n");49return -1;50}5152filename = argv[1];53fd = open(filename, O_RDWR);54if(fd < 0) {55printf("can't open file %s\r\n", filename);56return -1;57}5859while (1) {60ret = read(fd, databuf, sizeof(databuf));61if(ret == 0) {/* 数据读取成功 */62 gyro_x_adc = databuf[0];63 gyro_y_adc = databuf[1];64 gyro_z_adc = databuf[2];65 accel_x_adc = databuf[3];66 accel_y_adc = databuf[4];67 accel_z_adc = databuf[5];68 temp_adc = databuf[6];6970 /* 计算实际值 */71 gyro_x_act = (float)(gyro_x_adc) / 16.4;72 gyro_y_act = (float)(gyro_y_adc) / 16.4;73 gyro_z_act = (float)(gyro_z_adc) / 16.4;74 accel_x_act = (float)(accel_x_adc) / 2048;75 accel_y_act = (float)(accel_y_adc) / 2048;76 accel_z_act = (float)(accel_z_adc) / 2048;77 temp_act = ((float)(temp_adc) - 25 ) / 326.8 + 25;787980 printf("\r\n原始值:\r\n");81 printf("gx = %d, gy = %d, gz = %d\r\n", gyro_x_adc, gyro_y_adc, gyro_z_adc);82 printf("ax = %d, ay = %d, az = %d\r\n", accel_x_adc, accel_y_adc, accel_z_adc);83 printf("temp = %d\r\n", temp_adc);84 printf("实际值:");85printf("act gx = %.2f°/S, act gy = %.2f°/S, act gz = %.2f°/S\r\n", gyro_x_act, gyro_y_act, gyro_z_act);86 printf("act ax = %.2fg, act ay = %.2fg, act az = %.2fg\r\n",accel_x_act, accel_y_act, accel_z_act);87 printf("act temp = %.2f°C\r\n", temp_act);88}89usleep(100000); /*100ms */90}91close(fd); /* 关闭文件 */ 92return 0;93 }
第60~91行，在while循环中每隔100ms从icm20608中读取一次数据，读取到icm20608原始数据以后将其转换为实际值，比如陀螺仪就是角速度、加速度计就是g值。注意，我们在icm20608驱动中将陀螺仪和加速度计的测量范围全部设置到了最大，分别为±2000和±16g。因此，在计算实际值的时候陀螺仪使用16.4，加速度计使用2048。最终将传感器原始数据和得到的实际值显示在终端上。
44.7 运行测试
44.7.1 编译驱动程序和测试APP
1、内核使能SPI控制器
ST官方系统把SPI控制器的驱动编译成模块，我们需要把SPI控制器驱动编译进内核，这样就可以在启动linux内核的时候自动加载SPI控制器驱动，无需我们手动加载，方便我们使用。打开Linux内核图形化配置界面，按下路径找到对应的配置项：
Device Drivers
SPI support (SPI [=y])
<*> STMicroelectronics STM32 SPI controller //编译进内核
如图44.7.1.1所示：
图44.7.1.1 SPI控制器配置项
图44.7.1.1本来是选择为“M”,我们要改为“*”，也就是编译进内核。接着我们重新编译设备树和内核，运行以下命令进行编译：
make dtbs uImage LOADADDR=0XC2000040 -j32
使用新编译好的stm32mp157d-atk.dtb和uImage镜像启动系统，如果SPI控制器驱动工作正常就会有图44.7.1.2所示提示信息：
图44.7.1.2 SPI控制器初始化
如果没有输出图44.7.1.2中“spi_stm32 44004000.spi: driver initialized”这句话，那就要检查一下设备树和内配配置是否有问题，通过查看/sys/bus/spi/devices/下有没有spi相关的设备，就能够知道设备树配置是否正确，比如本例程如图44.7.1.3所示：
图44.7.1.3 SPI设备
2、编译驱动程序
编写Makefile文件，本章实验的Makefile文件和第四十章实验基本一样，只是将obj-m变量的值改为“icm20608.o”，Makefile内容如下所示：
示例代码44.7.1.1 Makefile文件1 KERNELDIR := /home/zuozhongkai/linux/my_linux/linux-5.4.31...... 4 obj-m := icm20608.o......11 clean:12 $(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
第4行，设置obj-m变量的值为“icm20608.o”。输入如下命令编译出驱动模块文件：
make -j16
编译成功以后就会生成一个名为“icm20608.ko”的驱动模块文件。
3、编译测试APP
在icm20608App.c这个测试APP中我们用到了浮点计算，而STM32MP1是支持硬件浮点的，因此我们在编译icm20608App.c的时候就可以使能硬件浮点，这样可以加速浮点计算。使能硬件浮点很简单，在编译的时候加入如下参数即可：
-march-armv7-a -mfpu-neon -mfloat=hard
输入如下命令使能硬件浮点编译icm20608App.c这个测试程序：
arm-none-linux-gnueabihf-gcc -march=armv7-a -mfpu=neon -mfloat-abi=hard icm20608App.c -o icm20608App
编译成功以后就会生成icm20608App这个应用程序，那么究竟有没有使用硬件浮点呢？使用arm-linux-gnueabihf-readelf查看一下编译出来的icm20608App就知道了，输入如下命令：
arm-none-linux-gnueabihf-readelf -A icm20608App
结果如图44.7.1.4所示：
图44.7.1.4 icm20608App文件信息从图44.7.1.4可以看出FPU架构为VFPv3，SIMD使用了NEON，说明icm20608App这个应用程序使用了硬件浮点。
44.7.2 运行测试
将上一小节编译出来icm20608.ko和icm20608App这两个文件拷贝到rootfs/lib/modules/5.3.41目录中，重启开发板，进入到目录lib/modules/5.3.41中。输入如下命令加载icm20608.ko这个驱动模块。
depmod //第一次加载驱动的时候需要运行此命令
modprobe icm20608.ko //加载驱动模块
当驱动模块加载成功以后使用icm20608App来测试，输入如下命令：
./icm20608App /dev/icm20608
测试APP会不断的从ICM20608中读取数据，然后输出到终端上，如图44.7.2.1所示：
图44.7.2.1获取到的ICM20608数据
可以看出，开发板静止状态下，Z轴方向的加速度为0.97g，这个就是重力加速度。对于陀螺仪来讲，静止状态下三轴的角速度应该在0°/S左右。ICM20608内温度传感器采集到的温度在39.51度，大家可以晃动一下开发板，这个时候陀螺仪和加速度计的值就会有变化。
未完待续，持续更新中
【正点原子MP157连载】第四十四章Linux SPI总线框架-摘自【正点原子】STM32MP1嵌入式Linux驱动开发指南V1.7
