[正点原子]Linux驱动学习笔记--21.Linux SPI驱动实验

adtxl
2022-10-22 / 0 评论 / 342 阅读 / 正在检测是否收录...

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 所示:

image.png

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

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

imagecfa337f14a39e0e8.png

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

image61080a470ff59b08.png

从图 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 所示:

imagec2ab6cc5a7c429e9.png

寄存器 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 所示:

image9d6d746a9539cedd.png

寄存器 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 所示:

imagec74d3955ad2788f2.png

寄存器 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 所示:

image9234bf6cd858de13.png

图 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 所示:

imagee41c6a37bc8e060e.png

寄存器 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 所示:

image856299abc14f31ef.png

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

image51001e8530962c7f.png

如果使用 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 的寄存器手册:

image39bcd875032551b0.png
续:
image78f2d88c60c6cb3d.png

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

imagee13e20c4e673212a.png

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

评论 (0)

取消