1. SPI&ICM-20608简介

1.1 SPI简介

同 I2C 一样， SPI 是很常用的通信接口，也可以通过 SPI 来连接众多的传感器。相比 I2C 接口， SPI 接口的通信速度很快， I2C 最多 400KHz，但是 SPI 可以到达几十 MHz。 I.MX6U 也有4 个 SPI 接口，可以通过这 4 个 SPI 接口来连接一些 SPI 外设。 I.MX6U-ALPHA 使用 SPI3 接口连接了一个六轴传感器 ICM-20608，本章我们就来学习如何使用 I.MX6U 的 SPI 接口来驱动ICM-20608，读取 ICM-20608 的六轴数据。

上一章我们讲解了 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 线连接多个从设备的结构如图 27.1.1.1 所示：

SPI 有四种工作模式，通过串行时钟极性(CPOL)和相位(CPHA)的搭配来得到四种工作模式：
①、 CPOL=0，串行时钟空闲状态为低电平。
②、 CPOL=1，串行时钟空闲状态为高电平，此时可以通过配置时钟相位(CPHA)来选择具体的传输协议。
③、 CPHA=0，串行时钟的第一个跳变沿(上升沿或下降沿)采集数据。
④、 CPHA=1，串行时钟的第二个跳变沿(上升沿或下降沿)采集数据。

这四种工作模式如图 27.1.1.2 所示：

跟 I2C 一样， SPI 也是有时序图的，以 CPOL=0， CPHA=0 这个工作模式为例， SPI 进行全双工通信的时序如图 27.1.1.3 所示：

从图 27.1.1.3 可以看出， SPI 的时序图很简单，不像 I2C 那样还要分为读时序和写时序，因为 SPI 是全双工的，所以读写时序可以一起完成。图 27.1.1.3 中， CS 片选信号先拉低，选中要通信的从设备，然后通过 MOSI 和 MISO 这两根数据线进行收发数据， MOSI 数据线发出了0XD2 这个数据给从设备，同时从设备也通过 MISO 线给主设备返回了 0X66 这个数据。这个就是 SPI 时序图。

关于 SPI 就讲解到这里，接下来我们看一下 I.MX6U 自带的 SPI 外设： ECSPI。

1.2 I.MX6U ECSPI 简介

I.MX6U 自带的 SPI 外设叫做 ECSPI，全称是 Enhanced Configurable Serial Peripheral Interface，别看前面加了个“EC”就以为和标准 SPI 有啥不同的， 其实就是 SPI。 ECSPI 有 64*32 个接收FIFO(RXFIFO)和 64*32 个发送 FIFO(TXFIFO)， ECSPI 特性如下：

①、全双工同步串行接口。
②、可配置的主/从模式。
③、四个片选信号，支持多从机。
④、发送和接收都有一个 32x64 的 FIFO。
⑤、片选信号 SS/CS，时钟信号 SCLK 极性可配置。
⑥、支持 DMA。

I.MX6U 的 ECSPI 可以工作在主模式或从模式，本章我们使用主模式， I.MX6U 有 4 个ECSPI，每个 ECSPI 支持四个片选信号，也就说，如果你要使用 ECSPI 的硬件片选信号的话，一个 ECSPI 可以支持 4 个外设。如果不使用硬件的片选信号就可以支持无数个外设，本章实验我们不使用硬件片选信号，因为硬件片选信号只能使用指定的片选 IO，软件片选的话可以使用任意的 IO。

我们接下来看一下 ECSPI 的几个重要的寄存器，首先看一下 ECSPIx_CONREG(x=1~4)寄存器，这是 ECSPI 的控制寄存器，此寄存器结构如图 27.1.2.1 所示：

寄存器 ECSPIx_CONREG 各位含义如下：
BURST_LENGTH(bit31:24)： 突发长度，设置 SPI 的突发传输数据长度，在一次 SPI 发送中最大可以发送 2^12bit 数据。可以设置 0X000~0XFFF，分别对应 1~2^12bit。我们一般设置突发长度为一个字节，也就是 8bit， BURST_LENGTH=7。

CHANNEL_SELECT(bit19:18)： SPI 通道选择，一个 ECSPI 有四个硬件片选信号，每个片选信号是一个硬件通道，虽然我们本章实验使用的软件片选，但是 SPI 通道还是要选择的。可设置为 0~3，分别对应通道 0~3。 I.MX6U-ALPHA 开发板上的 ICM-20608 的片选信号接的是ECSPI3_SS0，也就是 ECSPI3 的通道 0，所以本章实验设置为 0。

DRCTL(bit17:16)： SPI 的 SPI_RDY 信号控制位，用于设置 SPI_RDY 信号，为 0 的话不关心 SPI_RDY 信号；为 1 的话 SPI_RDY 信号为边沿触发；为 2 的话 SPI_DRY 是电平触发。

PRE_DIVIDER(bit15:12)： SPI 预分频， ECSPI 时钟频率使用两步来完成分频，此位设置的是第一步，可设置 0~15，分别对应 1~16 分频。

POST_DIVIDER(bit11:8)： SPI 分频值， ECSPI 时钟频率的第二步分频设置，分频值为2^POST_DIVIDER。

CHANNEL_MODE(bit7:4)： SPI 通道主/从模式设置， CHANNEL_MODE[3:0]分别对应 SPI通道 3~0， 为 0 的话就是设置为从模式，如果为 1 的话就是主模式。比如设置为 0X01 的话就是设置通道 0 为主模式。

SMC(bit3)：开始模式控制，此位只能在主模式下起作用，为 0 的话通过 XCH 位来开启 SPI突发访问，为 1 的话只要向 TXFIFO 写入数据就开启 SPI 突发访问。

XCH(bit2)： 此位只在主模式下起作用，当 SMC 为 0 的话此位用来控制 SPI 突发访问的开启。
HT(bit1)： HT 模式使能位， I.MX6ULL 不支持。
EN(bit0)： SPI 使能位，为 0 的话关闭 SPI，为 1 的话使能 SPI。

接下来看一下寄存器 ECSPIx_CONFIGREG，这个也是 ECSPI 的配置寄存器，此寄存器结构如图 27.1.2.2 所示：

寄存器 ECSPIx_CONFIGREG 用到的重要位如下：

HT_LENGTH(bit28:24)： HT 模式下的消息长度设置， I.MX6ULL 不支持。
SCLK_CTL(bit23:20)：设置 SCLK 信号线空闲状态电平， SCLK_CTL[3:0]分别对应通道3~0，为 0 的话 SCLK 空闲状态为低电平，为 1 的话 SCLK 空闲状态为高电平。
DATA_CTL(bit19:16)：设置 DATA 信号线空闲状态电平， DATA_CTL[3:0]分别对应通道3~0，为 0 的话 DATA 空闲状态为高电平，为 1 的话 DATA 空闲状态为低电平。
SS_POL(bit15:12)： 设置 SPI 片选信号极性设置， SS_POL[3:0]分别对应通道 3~0，为 0 的话片选信号低电平有效，为 1 的话片选信号高电平有效。
SCLK_POL(bit7:4)： SPI 时钟信号极性设置，也就是 CPOL， SCLK_POL[3:0]分别对应通道 3~0，为 0 的话 SCLK 高电平有效(空闲的时候为低电平)，为 1 的话 SCLK 低电平有效(空闲的时候为高电平)。
SCLK_PHA(bit3:0)： SPI时钟相位设置，也就是CPHA， SCLK_PHA[3:0]分别对应通道3~0，为 0 的话串行时钟的第一个跳变沿(上升沿或下降沿)采集数据，为 1 的话串行时钟的第二个跳变沿(上升沿或下降沿)采集数据。

通过 SCLK_POL 和 SCLK_PHA 可以设置 SPI 的工作模式。

接下来看一下寄存器 ECSPIx_PERIODREG，这个是 ECSPI 的采样周期寄存器，此寄存器结构如图 27.1.2.3 所示：

寄存器 ECSPIx_PERIODREG 用到的重要位如下：
CSD_CTL(bit21:16)： 片选信号延时控制位，用于设置片选信号和第一个 SPI 时钟信号之间的时间间隔，范围为 0~63。
CSRC(bit15)： SPI 时钟源选择，为 0 的话选择 SPI CLK 为 SPI 的时钟源，为 1 的话选择
32.768KHz 的晶振为 SPI 时钟源。我们一般选择 SPI CLK 作为 SPI 时钟源， SPI CLK 时钟来源如图 27.1.2.4 所示：

图 27.1.2.4 中各部分含义如下：
①、这是一个选择器，用于选择根时钟源，由寄存器 CSCDR2 的位 ECSPI_CLK_SEL 来控制，为 0 的话选择 pll3_60m 作为 ECSPI 根时钟源。为 1 的话选择 osc_clk 作为 ECSPI 时钟源。本章我们选择 pll3_60m 作为 ECSPI 根时钟源。
②、 ECSPI 时钟分频值，由寄存器 CSCDR2 的位 ECSPI_CLK_PODF 来控制，分频值为2^ECSPI_CLK_PODF。本章我们设置为 0，也就是 1 分频。
③、最终进入 ECSPI 的时钟，也就是 SPI CLK=60MHz。

SAMPLE_PERIO： 采样周期寄存器，可设置为 0~0X7FFF 分别对应 0~32767 个周期。
接下来看一下寄存器 ECSPIx_STATREG，这个是 ECSPI 的状态寄存器，此寄存器结构如图27.1.2.5 所示：

寄存器 ECSPIx_STATREG 用到的重要位如下：
TC(bit7)：传输完成标志位，为 0 表示正在传输，为 1 表示传输完成。
RO(bit6)： RXFIFO 溢出标志位，为 0 表示 RXFIFO 无溢出，为 1 表示 RXFIFO 溢出。
RF(bit5)： RXFIFO 空标志位，为 0 表示 RXFIFO 不为空，为 1 表示 RXFIFO 为空。
RDR(bit4)： RXFIFO 数据请求标志位，此位为 0 表示 RXFIFO 里面的数据不大于
RX_THRESHOLD，此位为 1 的话表示 RXFIFO 里面的数据大于 RX_THRESHOLD。
RR(bit3)： RXFIFO 就绪标志位，为 0 的话 RXFIFO 没有数据，为 1 的话表示 RXFIFO 中至少有一个字的数据。
TF(bit2)： TXFIFO 满标志位，为 0 的话表示 TXFIFO 不为满，为 1 的话表示 TXFIFO 为满。
TDR(bit1)： TXFIFO 数据请求标志位，为 0 表示 TXFIFO 中的数据大于 TX_THRESHOLD，为 1 表示 TXFIFO 中的数据不大于 TX_THRESHOLD。
TE(bit0)： TXFIFO 空标志位，为 0 表示 TXFIFO 中至少有一个字的数据，为 1 表示 TXFIFO为空。

最后就是两个数据寄存器， ECSPIx_TXDATA 和 ECSPIx_RXDATA，这两个寄存器都是 32位的，如果要发送数据就向寄存器 ECSPIx_TXDATA 写入数据，读取及存取 ECSPIx_RXDATA里面的数据就可以得到刚刚接收到的数据。

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， ±8g 和±16g。陀螺仪和加速度计都是 16 位的 ADC，并且支持 I2C 和 SPI 两种协议，使用 I2C 接口的话通信速度最高可以达到400KHz，使用 SPI 接口的话通信速度最高可达到 8MHz。 I.MX6U-ALPHA 开发板上的 ICM-20608 通过 SPI 接口和 I.MX6U 连接在一起。 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 轴方向如图 27.1.3.1 所示：

ICM-20608 的结构框图如图 27.1.3.2 所示：

如果使用 IIC 接口的话 ICM-20608 的 AD0 引脚决定 I2C 设备从地址的最后一位，如果 AD0为 0 的话 ICM-20608 从设备地址是 0X68，如果 AD0 为 1 的话 ICM-20608 从设备地址为 0X69。

本章我们使用 SPI 接口，跟上一章使用 AP3216C 一样， ICM-20608 也是通过读写寄存器来配置和读取传感器数据，使用 SPI 接口读写寄存器需要 16 个时钟或者更多(如果读写操作包括多个字节的话)，第一个字节包含要读写的寄存器地址，寄存器地址最高位是读写标志位，如果是读的话寄存器地址最高位要为 1，如果是写的话寄存器地址最高位要为 0，剩下的 7 位才是实际的寄存器地址，寄存器地址后面跟着的就是读写的数据。表 27.1.3.1 列出了本章实验用到的一些寄存器和位，关于 ICM-20608 的详细寄存器和位的介绍请参考 ICM-20608 的寄存器手册：

续：

ICM-20608 是在 I.MX6U-ALPHA 开发板底板上，原理图如图 27.2.1 所示：

2. Linux 下 SPI 驱动框架简介

SPI 驱动框架和 I2C 很类似，都分为主机控制器驱动和设备驱动，主机控制器也就是 SOC的 SPI 控制器接口。比如在裸机篇中的《第二十七章 SPI 实验》，我们编写了 bsp_spi.c 和 bsp_spi.h这两个文件，这两个文件是 I.MX6U 的 SPI 控制器驱动，我们编写好 SPI 控制器驱动以后就可以直接使用了，不管是什么 SPI 设备， SPI 控制器部分的驱动都是一样，我们的重点就落在了种类繁多的 SPI 设备驱动。

2.1 SPI 主机驱动

SPI 主机驱动就是 SOC 的 SPI 控制器驱动，类似 I2C 驱动里面的适配器驱动。 Linux 内核使用 spi_master 表示 SPI 主机驱动， spi_master 是个结构体，定义在 include/linux/spi/spi.h 文件中，内容如下(有缩减)：

// 示例代码 62.1.1.1 spi_master 结构体
315 struct spi_master {
316     struct device dev;
317
318     struct list_head list;
    ......
326     s16 bus_num;
327
328     /* chipselects will be integral to many controllers; some others
329      * might use board-specific GPIOs.
330      */
331     u16 num_chipselect;
332
333     /* some SPI controllers pose alignment requirements on DMAable
334      * buffers; let protocol drivers know about these requirements.
335      */
336     u16 dma_alignment;
337
338     /* spi_device.mode flags understood by this controller driver */
339     u16 mode_bits;
340
341     /* bitmask of supported bits_per_word for transfers */
342     u32 bits_per_word_mask;
        ......
347     /* limits on transfer speed */
348     u32 min_speed_hz;
349     u32 max_speed_hz;
350
351     /* other constraints relevant to this driver */
352     u16 flags;
    ......
359     /* lock and mutex for SPI bus locking */
360     spinlock_t bus_lock_spinlock;
361     struct mutex bus_lock_mutex;
362
363     /* flag indicating that the SPI bus is locked for exclusive use */
364     bool bus_lock_flag;
        ......
372     int (*setup)(struct spi_device *spi);
373
    ......
393     int (*transfer)(struct spi_device *spi,
394     struct spi_message *mesg);
    ......
434     int (*transfer_one_message)(struct spi_master *master,
435     struct spi_message *mesg);
    ......
462 };

第 393 行， transfer 函数，和 i2c_algorithm 中的 master_xfer 函数一样，控制器数据传输函数。
第 434 行， 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_master *spi_alloc_master(struct device *dev, unsigned size)

函数参数和返回值含义如下：
dev：设备，一般是 platform_device 中的 dev 成员变量。
size： 私有数据大小，可以通过 spi_master_get_devdata 函数获取到这些私有数据。
返回值： 申请到的 spi_master。

spi_master 的释放通过 spi_master_put 函数来完成，当我们删除一个 SPI 主机驱动的时候就需要释放掉前面申请的 spi_master， spi_master_put 函数原型如下：

void spi_master_put(struct spi_master *master)

函数参数和返回值含义如下：
master：要释放的 spi_master。
返回值： 无。

2、 spi_master 的注册与注销

当 spi_master 初始化完成以后就需要将其注册到 Linux 内核， spi_master 注册函数为spi_register_master，函数原型如下：

int spi_register_master(struct spi_master *master)

函数参数和返回值含义如下：
master：要注册的 spi_master。
返回值： 0，成功；负值，失败。

I.MX6U 的 SPI 主机驱动会采用 spi_bitbang_start 这个 API 函数来完成 spi_master 的注册，spi_bitbang_start 函数内部其实也是通过调用 spi_register_master 函数来完成 spi_master 的注册。

如果要注销 spi_master 的话可以使用 spi_unregister_master 函数，此函数原型为：

void spi_unregister_master(struct spi_master *master)

函数参数和返回值含义如下：
master：要注销的 spi_master。
返回值： 无。
如果使用 spi_bitbang_start 注册 spi_master 的话就要使用 spi_bitbang_stop 来注销掉spi_master。

2.2 SPI 设备驱动

spi 设备驱动和 i2c 设备驱动也很类似， Linux 内核使用 spi_driver 结构体来表示 spi 设备驱动，我们在编写 SPI 设备驱动的时候需要实 现 spi_driver 。 spi_driver 结构体定义在include/linux/spi/spi.h 文件中，结构体内容如下：

// 示例代码 62.1.1.2 spi_driver 结构体
180 struct spi_driver {
181     const struct spi_device_id *id_table;
182     int (*probe)(struct spi_device *spi);
183     int (*remove)(struct spi_device *spi);
184     void (*shutdown)(struct spi_device *spi);
185     struct device_driver driver;
186 };

可以看出， 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 注册示例程序如下：

// 示例代码 62.1.1.3 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。

2.3 SPI 设备和驱动匹配过程

SPI 设备和驱动的匹配过程是由 SPI 总线来完成的，这点和 platform、 I2C 等驱动一样， SPI总线为 spi_bus_type，定义在 drivers/spi/spi.c 文件中，内容如下：

示例代码 62.1.3.1 spi_bus_type 结构体
131 struct bus_type spi_bus_type = {
132     .name = "spi",
133     .dev_groups = spi_dev_groups,
134     .match = spi_match_device,
135     .uevent = spi_uevent,
136 };

可以看出， SPI 设备和驱动的匹配函数为 spi_match_device，函数内容如下：

// 示例代码 62.1.3.2 spi_match_device 函数
99 static int spi_match_device(struct device *dev, struct device_driver *drv)
100 {
101     const struct spi_device *spi = to_spi_device(dev);
102     const struct spi_driver *sdrv = to_spi_driver(drv);
103
104     /* Attempt an OF style match */
105     if (of_driver_match_device(dev, drv))
106         return 1;
107
108     /* Then try ACPI */
109     if (acpi_driver_match_device(dev, drv))
110         return 1;
111
112     if (sdrv->id_table)
113         return !!spi_match_id(sdrv->id_table, spi);
114
115     return strcmp(spi->modalias, drv->name) == 0;
116 }

spi_match_device 函数和 i2c_match_device 函数对于设备和驱动的匹配过程基本一样。
第 105 行， of_driver_match_device 函数用于完成设备树设备和驱动匹配。比较 SPI 设备节点的 compatible 属性和 of_device_id 中的 compatible 属性是否相等，如果相当的话就表示 SPI 设备和驱动匹配。
第 109 行， acpi_driver_match_device 函数用于 ACPI 形式的匹配。
第 113 行， spi_match_id 函数用于传统的、无设备树的 SPI 设备和驱动匹配过程。比较 SPI设备名字和 spi_device_id 的 name 字段是否相等，相等的话就说明 SPI 设备和驱动匹配。
第 115 行，比较 spi_device 中 modalias 成员变量和 device_driver 中的 name 成员变量是否相等。

3. I.MX6U SPI 主机驱动分析

和 I2C 的适配器驱动一样， SPI 主机驱动一般都由 SOC 厂商编写好了，打开 imx6ull.dtsi文件，找到如下所示内容：

// 示例代码 62.2.1 imx6ull.dtsi 文件中的 ecspi3 节点内容
1 ecspi3: ecspi@02010000 {
2     #address-cells = <1>;
3     #size-cells = <0>;
4     compatible = "fsl,imx6ul-ecspi", "fsl,imx51-ecspi";
5     reg = <0x02010000 0x4000>;
6     interrupts = <GIC_SPI 33 IRQ_TYPE_LEVEL_HIGH>;
7     clocks = <&clks IMX6UL_CLK_ECSPI3>,
8     <&clks IMX6UL_CLK_ECSPI3>;
9     clock-names = "ipg", "per";
10     dmas = <&sdma 7 7 1>, <&sdma 8 7 2>;
11     dma-names = "rx", "tx";
12     status = "disabled";
13 };

重点来看一下第 4 行的 compatible 属性值， compatible 属性有两个值“fsl,imx6ul-ecspi”和“fsl,imx51-ecspi”，在 Linux 内核源码中搜素这两个属性值即可找到 I.MX6U 对应的 ECSPI(SPI)主机驱动。 I.MX6U 的 ECSPI 主机驱动文件为 drivers/spi/spi-imx.c，在此文件中找到如下内容：

// 示例代码 62.2.2 spi_imx_driver 结构体
694 static struct platform_device_id spi_imx_devtype[] = {
695     {
696         .name = "imx1-cspi",
697         .driver_data = (kernel_ulong_t) &imx1_cspi_devtype_data,
698     }, {
699         .name = "imx21-cspi",
700         .driver_data = (kernel_ulong_t) &imx21_cspi_devtype_data,
......
713     }, {
714         .name = "imx6ul-ecspi",
715         .driver_data = (kernel_ulong_t) &imx6ul_ecspi_devtype_data,
716     }, {
717     /* sentinel */
718     }
719 };
720
721 static const struct of_device_id spi_imx_dt_ids[] = {
722     { .compatible = "fsl,imx1-cspi", .data =
                &imx1_cspi_devtype_data, },
    ......
728     { .compatible = "fsl,imx6ul-ecspi", .data =
                &imx6ul_ecspi_devtype_data, },
729     { /* sentinel */ }
730 };
731 MODULE_DEVICE_TABLE(of, spi_imx_dt_ids);
......
1338 static struct platform_driver spi_imx_driver = {
1339     .driver = {
1340         .name = DRIVER_NAME,
1341         .of_match_table = spi_imx_dt_ids,
1342         .pm = IMX_SPI_PM,
1343     },
1344     .id_table = spi_imx_devtype,
1345     .probe = spi_imx_probe,
1346     .remove = spi_imx_remove,
1347 };
1348 module_platform_driver(spi_imx_driver);

第 714 行， spi_imx_devtype 为 SPI 无设备树匹配表。
第 721 行， spi_imx_dt_ids 为 SPI 设备树匹配表。
第 728 行，“fsl,imx6ul-ecspi”匹配项，因此可知 I.MX6U 的 ECSPI 驱动就是 spi-imx.c 这个文件。
第 1338~1347 行， platform_driver 驱动框架，和 I2C 的适配器驱动一样， SPI 主机驱动器采用了 platfom 驱动框架。当设备和驱动匹配成功以后 spi_imx_probe 函数就会执行。
spi_imx_probe 函数会从设备树中读取相应的节点属性值，申请并初始化 spi_master，最后调用 spi_bitbang_start 函数(spi_bitbang_start 会调用 spi_register_master 函数)向 Linux 内核注册spi_master。
对于 I.MX6U 来讲， SPI 主机的最终数据收发函数为 spi_imx_transfer，此函数通过如下层层调用最终实现 SPI 数据发送：

spi_imx_transfer-> spi_imx_pio_transfer-> spi_imx_push-> spi_imx->tx

spi_imx 是个 spi_imx_data 类型的机构指针变量，其中 tx 和 rx 这两个成员变量分别为 SPI数据发送和接收函数。 I.MX6U SPI 主机驱动会维护一个 spi_imx_data 类型的变量 spi_imx，并且使用 spi_imx_setupxfer 函数来设置 spi_imx 的 tx 和 rx 函数。根据要发送的数据数据位宽的不同，分别有 8 位、 16 位和 32 位的发送函数，如下所示：

spi_imx_buf_tx_u8
spi_imx_buf_tx_u16
spi_imx_buf_tx_u32

同理，也有 8 位、 16 位和 32 位的数据接收函数，如下所示：

spi_imx_buf_rx_u8
spi_imx_buf_rx_u16
spi_imx_buf_rx_u32

我们就以 spi_imx_buf_tx_u8 这个函数为例，看看，一个自己的数据发送是怎么完成的，在spi-imx.c 文件中找到如下所示内容：

// 示例代码 62.2.3 spi_imx_buf_tx_u8 函数
152 #define MXC_SPI_BUF_TX(type) \
153 static void spi_imx_buf_tx_##type(struct spi_imx_data *spi_imx) \
154 {                                     \
155     type val = 0;                     \
156                                     \
157     if (spi_imx->tx_buf) {             \
158         val = *(type *)spi_imx->tx_buf; \
159         spi_imx->tx_buf += sizeof(type); \
160     }                                     \
161                                         \
162     spi_imx->count -= sizeof(type);        \
163                                         \
164     writel(val, spi_imx->base + MXC_CSPITXDATA); \
165 }
166
167 MXC_SPI_BUF_RX(u8)
168 MXC_SPI_BUF_TX(u8)

从示例代码 62.2.3 可以看出， spi_imx_buf_tx_u8 函数是通过 MXC_SPI_BUF_TX 宏来实现的。第 164 行就是将要发送的数据值写入到 ECSPI 的 TXDATA 寄存器里面去，这和我们 SPI 裸机实验的方法一样。将第 168 行的 MXC_SPI_BUF_TX(u8)展开就是 spi_imx_buf_tx_u8 函数。
其他的 tx 和 rx 函数都是这样实现的，这里就不做介绍了。关于 I.MX6U 的主机驱动程序就讲
解到这里，基本套路和 I2C 的适配器驱动程序类似。

4. SPI 设备驱动编写流程

4.1 SPI 设备信息描述

1、 IO 的 pinctrl 子节点创建与修改

首先肯定是根据所使用的 IO 来创建或修改 pinctrl 子节点，这个没什么好说的，唯独要注意的就是检查相应的 IO 有没有被其他的设备所使用，如果有的话需要将其删除掉！

2、 SPI 设备节点的创建与修改

采用设备树的情况下， SPI 设备信息描述就通过创建相应的设备子节点来完成，我们可以打开 imx6qdl-sabresd.dtsi 这个设备树头文件，在此文件里面找到如下所示内容：

示例代码 62.3.1.1 m25p80 设备节点
308 &ecspi1 {
309     fsl,spi-num-chipselects = <1>;
310     cs-gpios = <&gpio4 9 0>;
311     pinctrl-names = "default";
312     pinctrl-0 = <&pinctrl_ecspi1>;
313     status = "okay";
314
315     flash: m25p80@0 {
316         #address-cells = <1>;
317         #size-cells = <1>;
318         compatible = "st,m25p32";
319         spi-max-frequency = <20000000>;
320         reg = <0>;
321     };
322 };

示例代码 62.3.1.1 是 I.MX6Q 的一款板子上的一个 SPI 设备节点，在这个板子的 ECSPI 接口上接了一个 m25p80，这是一个 SPI 接口的设备。
第 309 行，设置“fsl,spi-num-chipselects”属性为 1，表示只有一个设备。
第 310 行，设置“cs-gpios”属性，也就是片选信号为 GPIO4_IO09。
第 311 行，设置“pinctrl-names”属性，也就是 SPI 设备所使用的 IO 名字。
第 312 行，设置“pinctrl-0”属性，也就是所使用的 IO 对应的 pinctrl 节点。
第 313 行，将 ecspi1 节点的“status”属性改为“okay”。
第 315~320 行， ecspi1 下的 m25p80 设备信息，每一个 SPI 设备都采用一个子节点来描述其设备信息。第 315 行的“m25p80@0”后面的“0”表示 m25p80 的接到了 ECSPI 的通道 0上。这个要根据自己的具体硬件来设置。
第 318 行， SPI 设备的 compatible 属性值，用于匹配设备驱动。
第 319 行，“spi-max-frequency”属性设置 SPI 控制器的最高频率，这个要根据所使用的SPI 设备来设置，比如在这里将 SPI 控制器最高频率设置为 20MHz。
第 320 行， reg 属性设置 m25p80 这个设备所使用的 ECSPI 通道，和“m25p80@0”后面的“0”一样。

我们一会在编写 ICM20608 的设备树节点信息的时候就参考示例代码 62.3.1.1 中的内容即可。

62.3.2 SPI 设备数据收发处理流程

SPI 设备驱动的核心是 spi_driver，这个我们已经在 62.1.2 小节讲过了。当我们向 Linux 内核注册成功 spi_driver 以后就可以使用 SPI 核心层提供的 API 函数来对设备进行读写操作了。
首先是 spi_transfer 结构体，此结构体用于描述 SPI 传输信息，结构体内容如下：

示例代码 62.3.2.1 spi_transfer 结构体
603 struct spi_transfer {
604     /* it's ok if tx_buf == rx_buf (right?)
605      * for MicroWire, one buffer must be null
606      * buffers must work with dma_*map_single() calls, unless
607      * spi_message.is_dma_mapped reports a pre-existing mapping
608      */
609     const void *tx_buf;
610     void *rx_buf;
611     unsigned len;
612
613     dma_addr_t tx_dma;
614     dma_addr_t rx_dma;
615     struct sg_table tx_sg;
616     struct sg_table rx_sg;
617
618     unsigned cs_change:1;
619     unsigned tx_nbits:3;
620     unsigned rx_nbits:3;
621     #define SPI_NBITS_SINGLE 0x01 /* 1bit transfer */
622     #define SPI_NBITS_DUAL 0x02 /* 2bits transfer */
623     #define SPI_NBITS_QUAD 0x04 /* 4bits transfer */
624     u8 bits_per_word;
625     u16 delay_usecs;
626     u32 speed_hz;
627
628      struct list_head transfer_list;
629 };

第 609 行， tx_buf 保存着要发送的数据。
第 610 行， rx_buf 用于保存接收到的数据。
第 611 行， len 是要进行传输的数据长度， SPI 是全双工通信，因此在一次通信中发送和接收的字节数都是一样的，所以 spi_transfer 中也就没有发送长度和接收长度之分。

spi_transfer 需要组织成 spi_message， spi_message 也是一个结构体，内容如下：

示例代码 62.3.2.2 spi_message 结构体
660 struct spi_message {
661     struct list_head transfers;
662
663     struct spi_device *spi;
664
665     unsigned is_dma_mapped:1;
......
678     /* completion is reported through a callback */
679     void (*complete)(void *context);
680     void *context;
681     unsigned frame_length;
682     unsigned actual_length;
683     int status;
684
685     /* for optional use by whatever driver currently owns the
686      * spi_message ... between calls to spi_async and then later
687      * complete(), that's the spi_master controller driver.
688      */
689     struct list_head queue;
690     void *state;
691 };

在使用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 个字节的数据发送和接收的示例代码如下所示：

// 示例代码 62.3.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;
}