正点原子嵌入式linux驱动开发——Linux SPI驱动

到目前为止的学习笔记,已经介绍了Linux下的platform总线框架、I2C总线框架,本篇笔记将介绍Linux下的SPI总线框架。与I2C总线一样,SPI是物理总线,也是一种很常用的串行通信协议 。本章就来学习如何在Linux下编写SPI总线接口的设备驱动。本章实验的最终目的就是驱动STM32MP1开发板上的ICM-20608这个SPI接口的六轴传感器,可以在应用程序中读取ICM-20608的原始传感器数据。

SPI&ICM-20608简介

SPI简介

SPI的基础知识在之前学习裸机开发的时候学过了,这里就不再赘述。

STM32MP1 SPI简介

STM32MP1自带的SPI全称为:Serial peripheral interface。SPI特性如下:

  1. 全双工同步串口接口。
  2. 半双工模式。
  3. 可配置的主/从模式。
  4. 支持I2S协议。
  5. 在达到FIFO阈值、超时、操作完成以及发生访问错误时产生中断。
  6. 允许16位,24位或者32位数据长度。
  7. 支持软件片选和硬件片选。

STM32MP1的SPI可以工作在主模或从模式,本章使用主模式,此芯片有6个SPI
,其中SPI1-3是支持I2S协议
。在主模式下,可以选择硬件片选和软件片选,如果使用了硬件片选,那么每一个SPI只支持一个外设,软件片选就可以支持无数个外设,本章实验不使用硬件片选信号,因为硬件片选信号只能使用指定的片选IO,软件片选的话可以使用任意的IO

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。开发板上的ICM-20608通过SPI接口和STM32MP157连接在一起。ICM-20608特性如下:

  1. 陀螺仪支持X,Y和 Z三轴输出,内部集成16位ADC,测量范围可设置±250,±500,±1000和±2000°/s。
  2. 加速度计支持X,Y和Z轴输出,内部集成16位ADC,测量范围可设置±2g,±4g,±8g和±16g。
  3. 用户可编程中断。
  4. 内部包含512字节的FIFO。
  5. 内部包含一个数字温度传感器。
  6. 耐10000g的冲击。
  7. 支持快速I2C,速度可达400KHz。
  8. 支持SPI,速度可达8MHz。

ICM-20608的3轴方向如下图所示:

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

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

本章使用SPI接口,与之前的I2C驱动芯片AP3216C一样,ICM-20608也是通过读写寄存器来配置和读取传感器数据,使用SPI接口读写寄存器需要16个时钟或者更多 (如果读写操作包括多个字节的话) ,第一个字节包含要读写的寄存器地址,寄存器地址最高位是读写标志位,如果是读的话寄存器地址最高位要为1,如果是写的话寄存器地址最高位要为0,剩下的7位才是实际的寄存器地址,寄存器地址后面跟着的就是读写的数据。下图列出了本章实验用到的一些寄存器和位:


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就有6个SPI,那么就有6个SPI控制器,每个控制器都有一条特定的SPI总线的读写。SPI子系统使用struct spi_master数据结构体来描述SPI控制器。在内核源码drivers/spi目录下有很多以spi-xxxx.c命名的源文件,如下图所示:

这些文件就是具体平台对应的SPI控制器驱动程序,使用SPI核心层提供的接口向SPI子系统注册SPI控制器。

  • SPI设备驱动层:SPI从设备对应的驱动程序,比如一些SPI接口的芯片器件对应的驱动程序。

SPI主机驱动

SPI主机驱动就是SoC的SPI控制器驱动,类似I2C总线的适配器驱动。SPI子系统使用spi_master结构体来描述SPI控制器 ,其实spi_master是一个宏,这个宏定义在include/linux/spi/spi.h文件中,如下所示:

c 复制代码
#define spi_master spi_controller

所以由此可以知道,spi_master就是spi_controller结构体,该结构体定义在include/linux/spi/spi.h文件中,如下所示:

c 复制代码
示例代码 45. 2.1 spi_controller 结构体
424 struct spi_controller {
425     struct device dev; /* device 对象 */
426
427     struct list_head list;
......
435     s16 bus_num; /* SPI 总线编号 */
......
440     u16 num_chipselect; /* 片选 */
441
442     /* some SPI controllers pose alignment requirements on DMAable
443      * buffers; let protocol drivers know about these requirements.
444      */
445     u16 dma_alignment;
446
447     /* spi_device.mode flags understood by this controller driver */
448     u32 mode_bits /* 模式位 */
......
455     /* limits on transfer speed */
456     u32 min_speed_hz; /* SPI 控制器支持的最小传输速率 */
457     u32 max_speed_hz; /* SPI 控制器支持的最大传输速率 */
458
459     /* other constraints relevant to this driver */
460     u16 flags; /* 传输类型标志 */
468
469     /* flag indicating this is an SPI slave controller */
470     bool slave; /* 标志该控制器是否为 SPI 从设备存在 */
471
472 /*
473  * on some hardware transfer / message size may be constrained
474  * the limit may depend on device transfer settings
475  */
476     size_t (*max_transfer_size)(struct spi_device *spi);
477     size_t (*max_message_size)(struct spi_device *spi);
478
479     /* I/O mutex */
480     struct mutex io_mutex
481
482     /* lock and mutex for SPI bus locking */
483     spinlock_t bus_lock_spinlock;
484     struct mutex bus_lock_mutex;
485
486     /* flag indicating that the SPI bus is locked for exclusive use */
487     bool bus_lock_flag;
......
495     int (*setup)(struct spi_device *spi)
......
527     int (*transfer)(struct spi_device *spi,
528                     struct spi_message *mesg);
567     int (*prepare_transfer_hardware)(struct spi_controller *ctlr);
568     int (*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的使用者,这一部分的驱动就不用操心了。

SPI主机驱动的核心就是申请spi_master,然后初始化spi_master,最后向Linux内核注册spi_master。

spi_master申请与释放

spi_alloc_master函数用于申请spi_master,函数原型如下:

c 复制代码
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本质上是个宏

c 复制代码
#define spi_master_put(_ctlr) spi_controller_put(_ctlr)

spi_master_put函数最终通过调用spi_controller_put函数来完成spi_master释放,原型如下:

c 复制代码
void spi_master_put(struct spi_controller *ctlr) 

函数参数和返回值含义如下:

  • ctlr:要释放的spi_master。
  • 返回值:无。

spi_master的注册与注销

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

c 复制代码
int spi_register_master(struct spi_controller *ctlr) 

函数参数和返回值含义如下:

  • ctlr:要注册的spi_master。
  • 返回值:0,成功;负值,失败。

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

c 复制代码
void spi_unregister_master(struct spi_controller *ctlr) 

函数参数和返回值含义如下:

  • ctlr:要注销的spi_master。
  • 返回值:无。

SPI设备驱动

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

可以看出,spi_driver和i2c_driver、platform_driver基本一样,当SPI设备和驱动匹配成功以后probe函数就会执行。

同样的,spi_driver初始化完成以后需要向Linux内核注册,spi_driver注册函数为spi_register_driver,函数原型如下:

c 复制代码
int spi_register_driver(struct spi_driver *sdrv) 

函数参数和返回值含义如下:

  • sdrv:要注册的spi_driver。
  • 返回值:0,注册成功;赋值,注册失败。

注销SPI设备驱动以后也需要注销掉前面注册的spi_driver,使用spi_unregister_driver函数完成spi_driver的注销,函数原型如下:

c 复制代码
void spi_unregister_driver(struct spi_driver *sdrv) 

函数参数和返回值含义如下:

  • sdrv:要注销的spi_driver。
  • 返回值:无。

spi_driver注册示例程序如下:

c 复制代码
示例代码 45.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。

SPI设备和驱动匹配过程

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

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

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成员变量是否

相等。

STM32MP1 SPI主机驱动分析

和I2C的适配器驱动一样,SPI主机驱动一般由SOC厂商编写好,打开stm32mp151.dtsi文件,找到如下内容:

重点来看一下第4行的compatible属性值,compatible属性为"st,stm32h7-spi",在Linux内核源码中搜素这两个属性值即可找到STM32MP1对应的SPI主机驱动。STM32MP1的SPI主机驱动文件为drivers/spi/spi-stm32.c,在此文件中找到如下内容:

第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函数做了些什么,函数如下所示:

c 复制代码
示例代码 45. 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;
1873
1874     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 p= latform_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     }
1898
1899     spi->phys_addr = (dma_addr_t)res->start;
1900
1901     spi->irq = platform_get_irq(pdev, 0);
1902     if (spi->irq <= 0) {
1903         ret = spi->irq;
1904         if (ret != -EPROBE_DEFER)
1905             dev_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 |
1967                         SPI_LSB_FIRST | SPI_3WIRE;
1968     master->bits_per_word_mask = spi->cfg->get_bpw_mask(spi);
1969     master->max_speed_hz = spi clk_rate /
                                spi->cfg->baud_rate_div_min;
1970     master->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函数的内容,如下所示(有省略):

第1709-1715行,如果启动了DMA那么就使用stm32_spi_transfer_one_dma来进行传输数据,没有用DMA的话就调用transfer_one_irq函数。这两个函数也就是控制寄存器来进行收发数据。

SPI设备驱动编写流程

SPI设备信息描述

IO的pinctrl子节点创建与修改

首先肯定是根据所使用的IO来创建或者修改pinctrl子节点。唯独要注意的是检查相应的IO有没有被其它的设备所使用 ,如果有多个pinctrl配置相同的IO是没有关系的,只要保证没有被设备调用就行

SPI设备节点的创建与修改

采用设备树方式的情况下,SPI从机设备信息描述就通过创建相应的设备子节点来完成,可以打开stm32mp157d-atk.dts这个设备树文件,然后在里边创建一个SPI从机设备节点,描述该设备的相关信息。

SPI从机设备数据收发处理流程

SPI设备驱动的核心是spi_driver 。当向Linux内核注册成功spi_driver以后就可以使用SPI核心层提供的API函数来对设备进行读写操作了

首先是spi_transfer结构体,此结构体用于描述SPI传输信息,结构体内容如下:

第817行,tx_buf保存着要发送的数据。

第818行,rx_buf用于保存接收到的数据。

第819行,len是要进行传输的数据长度,SPI是全双工通信,因此在一次通信中发送和接收的字节数都是一样的,所以spi_transfer中也就没有发送长度和接收长度之分。

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

使用spi_message之前需要对其进行初始化,spi_message初始化函数为spi_message_init,函数原型如下:

c 复制代码
void spi_message_init(struct spi_message *m) 

函数参数和返回值含义如下:

  • m:要初始化的spi_message。
  • 返回值:无。

spi_message初始化完成以后需要将spi_transfer添加到spi_message队列中,这里要用到spi_message_add_tail函数,此函数原型如下:

c 复制代码
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,函数原型如下:

c 复制代码
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,函数原型如下:

c 复制代码
int spi_async(struct spi_device *spi, struct spi_message *message)

函数参数和返回值含义如下:

  • spi:要进行数据传输的spi_device。
  • message:要传输的spi_message。
  • 返回值:无。

在本章实验中,采用同步传输方式来完成SPI数据的传输工作,也就是spi_sync函数。

综上所述,SPI数据传输步骤如下:

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

通过SPI进行n个字节的数据发送和接收的示例代码如下所示:

c 复制代码
示例代码 45.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;
};

硬件原理图分析

STM32MP1开发板上ICM20608原理如下图所示:

上图就是ICM-20608的硬件原理图。正点原子STM32MP1开发板的PZ0-3分别连接到ICM-20608的SCK、SDA、AD0和CS。其中6D_INT为ICM20608的中断引脚,连接到PA14引脚上,在本章实验上没有用到ICM20608的中断引脚。

实验程序编写

修改设备树

添加/查找ICM20608使用的IO的pinmux配置

首先在stm32mp15-pinctrl.dtsi文件中添加IO配置信息,ICM20608连接到了STM32MP157的SPI1接口,因此先在stm32mp15-pinctrl.dtsi里面搜索一下,看看有没有SPI1接口引脚配置(在正点原子的linux驱动开发的教程中是默认有的)。如果没有的话就自行添加,有的话就检查一下SPI1接口的引脚配置是否和自己所使用的硬件一致,不一致的话就要修改。修改后的引脚信息如下所示:

c 复制代码
示例代码 45. 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 { 
11         pinmux = <STM32_PINMUX('Z', 1, AF5)>; /* SPI1_MISO */ 
12         bias-disable; 
13     }; 
14 
15     pins3 { 
16         pinmux = <STM32_PINMUX('Z', 3, GPIO)>; /* SPI1_NSS */ 
17         drive-push-pull; 
18         bias-pull-up; 
19         output-high; 
20         slew-rate = <0>; 
21     }; 
22 }; 
23 
24 spi1_sleep_pins_a: spi1-sleep-0 { 
25     pins { 
26         pinmux = <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 };

示例代码45.6.3.1里15-21行是设置ICM20608的片选信号,直接复用为GPIO,也就是使用软件片选。

在SPI1节点下添加pinmux并追加icm20608子节点

在stm32mp157d-atk.dts文件,追加SPI1节点,追加如下所示内容:

c 复制代码
示例代码 45. 6.1.2 追加内容的 spi 1 节点
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";
10         reg = <0>; /* CS #0 */
11         spi-max-frequency = <8000000>;
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芯片的片选信号,比如:

c 复制代码
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接口所能支持的最大的时钟频率。

编写ICM20608驱动

工程创建好以后新建icm20608.c和icm20608reg.h这两个文件,icm20608.c为ICM20608的驱动代码,icm20608reg.h是ICM20608寄存器头文件。先在icm20608reg.h中定义好ICM20608的寄存器,输入如下内容(有省略):

c 复制代码
示例代码 45. 6.2.1 icm20608reg.h 文件内容
1  #ifndef ICM20608_H 
2  #define ICM20608_H 
3  /*************************************************************** 
4  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved. 
5  文件名 : icm20608reg.h 
6  作者 : 左忠凯 
7  版本 : V1.0
8  描述 : ICM20608寄存器地址描述头文件 
9  其他 : 无 
10 论坛 : www.openedv.com 
11 日志 : 初版V1.0 2019/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 = 0x40 
19 *Register 117(0X75) WHO_AM_I = 0xAF或0xAE 
20 */ 
21 /* 陀螺仪和加速度自测(出产时设置,用于与用户的自检输出值比较) */ 
22 #define ICM20_SELF_TEST_X_GYRO 0x00 
23 #define ICM20_SELF_TEST_Y_GYRO 0x01 
24 #define ICM20_SELF_TEST_Z_GYRO 0x02 
25 #define ICM20_SELF_TEST_X_ACCEL 0x0D 
26 #define ICM20_SELF_TEST_Y_ACCEL 0x0E 
27 #define ICM20_SELF_TEST_Z_ACCEL 0x0F 
...... 
88 #endif

接下来编写icm20608.c文件。

icm20608设备结构体创建

这一部分跟之前的字符设备的设备结构体没有什么区别,主要需要加上struct spi_device结构体指针*spi,然后就是加上一系列的signed int类型的变量来存储从传感器中读取的数据。

icm20608的spi_driver注册与注销

对于SPI设备驱动,首先就是要初始化并向系统注册spi_driver。

对于设备树而言,就是要添加一个of_device_id结构体类型的icm20608_of_match[]数组,里面设置.compatible用来匹配。

然后需要写一个spi_driver结构体类型的icm20608_driver,作为SPI驱动结构体,里面要设置.probe,.remove,.driver里面设置.owner(这个一般就是THIS_MODULE),.name以及.of_match_table,就可以了。

然后就是驱动入口和驱动出口函数,这里就是在icm20608_init里面return出来spi_register_driver;在icm20608_exit里面调用spi_unregister_driver函数。

最后就是五个常规的操作就可以了。

probe&remove函数

probe函数,就在其中先通过devm_kzalloc分配内存空间,然后就是字符设备的老一套,alloc_chrdev_region创建设备号,cdev_init初始化cdev,然后cdev_add添加一个cdev,最后就是class_create以及device_create创建类和设备。

之后就是SPI的内容,首先spi->mode来设置SPI的四种工作模式的一种,然后spi_setup;之后就是调用自己写的icm20608_reginit来初始化内部寄存器,之后spi_set_drvdata来保存设置好的设备结构体。

remove函数跟之前的基本是一样的,除了要先通过spi_get_drvdata来获取一下SPI设备,然后就是4套操作来cdev_del,unregister_chrdev_region,device_destroy以及class_destroy。

icm20608寄存器读写与初始化

SPI驱动最终是通过读写icm20608的寄存器来实现的,因此需要编写相应的寄存器读写函数,并且使用这些读写函数来完成对icm20608的初始化。 具体的读写就是参考操作手册。

这里的话我就直接把代码贴上来,比较长,需要注意的就是在读写多个寄存器的时候,因为SPI是全双工,没有发送和接收长度的分别,同时读写N个字节需要封装N+1个字节(第1个是区分读写的,后面N个才是真实的传输数据)。

c 复制代码
/*
 * @description	: 从icm20608读取多个寄存器数据
 * @param - dev:  icm20608设备
 * @param - reg:  要读取的寄存器首地址
 * @param - val:  读取到的数据
 * @param - len:  要读取的数据长度
 * @return 		: 操作结果
 */
static int icm20608_read_regs(struct icm20608_dev *dev, u8 reg, void *buf, int len)
{

	int ret = -1;
	unsigned char txdata[1];
	unsigned char * rxdata;
	struct spi_message m;
	struct spi_transfer *t;
	struct spi_device *spi = (struct spi_device *)dev->spi;
    
	t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);	/* 申请内存 */
	if(!t) {
		return -ENOMEM;
	}
	rxdata = kzalloc(sizeof(char) * len, GFP_KERNEL);	/* 申请内存 */
	if(!rxdata) {
		goto out1;
	}
	/* 一共发送len+1个字节的数据,第一个字节为
	寄存器首地址,一共要读取len个字节长度的数据,*/
	txdata[0] = reg | 0x80;		/* 写数据的时候首寄存器地址bit8要置1 */			
	t->tx_buf = txdata;			/* 要发送的数据 */
    t->rx_buf = rxdata;			/* 要读取的数据 */
	t->len = len+1;				/* t->len=发送的长度+读取的长度 */
	spi_message_init(&m);		/* 初始化spi_message */
	spi_message_add_tail(t, &m);/* 将spi_transfer添加到spi_message队列 */
	ret = spi_sync(spi, &m);	/* 同步发送 */
	if(ret) {
		goto out2;
	}
	
    memcpy(buf , rxdata+1, len);  /* 只需要读取的数据 */

out2:
	kfree(rxdata);					/* 释放内存 */
out1:	
	kfree(t);						/* 释放内存 */
	
	return ret;
}

/*
 * @description	: 向icm20608多个寄存器写入数据
 * @param - dev:  icm20608设备
 * @param - reg:  要写入的寄存器首地址
 * @param - val:  要写入的数据缓冲区
 * @param - len:  要写入的数据长度
 * @return 	  :   操作结果
 */
static s32 icm20608_write_regs(struct icm20608_dev *dev, u8 reg, u8 *buf, u8 len)
{
	int ret = -1;
	unsigned char *txdata;
	struct spi_message m;
	struct spi_transfer *t;
	struct spi_device *spi = (struct spi_device *)dev->spi;
	
	t = kzalloc(sizeof(struct spi_transfer), GFP_KERNEL);	/* 申请内存 */
	if(!t) {
		return -ENOMEM;
	}
	
	txdata = kzalloc(sizeof(char)+len, GFP_KERNEL);
	if(!txdata) {
		goto out1;
	}
	
	/* 一共发送len+1个字节的数据,第一个字节为
	寄存器首地址,len为要写入的寄存器的集合,*/
	*txdata = reg & ~0x80;	/* 写数据的时候首寄存器地址bit8要清零 */
    memcpy(txdata+1, buf, len);	/* 把len个寄存器拷贝到txdata里,等待发送 */
	t->tx_buf = txdata;			/* 要发送的数据 */
	t->len = len+1;				/* t->len=发送的长度+读取的长度 */
	spi_message_init(&m);		/* 初始化spi_message */
	spi_message_add_tail(t, &m);/* 将spi_transfer添加到spi_message队列 */
	ret = spi_sync(spi, &m);	/* 同步发送 */
    if(ret) {
        goto out2;
    }
	
out2:
	kfree(txdata);				/* 释放内存 */
out1:
	kfree(t);					/* 释放内存 */
	return ret;
}

/*
 * @description	: 读取icm20608指定寄存器值,读取一个寄存器
 * @param - dev:  icm20608设备
 * @param - reg:  要读取的寄存器
 * @return 	  :   读取到的寄存器值
 */
static unsigned char icm20608_read_onereg(struct icm20608_dev *dev, u8 reg)
{
	u8 data = 0;
	icm20608_read_regs(dev, reg, &data, 1);
	return data;
}

/*
 * @description	: 向icm20608指定寄存器写入指定的值,写一个寄存器
 * @param - dev:  icm20608设备
 * @param - reg:  要写的寄存器
 * @param - data: 要写入的值
 * @return   :    无
 */	

static void icm20608_write_onereg(struct icm20608_dev *dev, u8 reg, u8 value)
{
	u8 buf = value;
	icm20608_write_regs(dev, reg, &buf, 1);
}

/*
 * @description	: 读取ICM20608的数据,读取原始数据,包括三轴陀螺仪、
 * 				: 三轴加速度计和内部温度。
 * @param - dev	: ICM20608设备
 * @return 		: 无。
 */
void icm20608_readdata(struct icm20608_dev *dev)
{
	unsigned char data[14];
	icm20608_read_regs(dev, ICM20_ACCEL_XOUT_H, data, 14);

	dev->accel_x_adc = (signed short)((data[0] << 8) | data[1]); 
	dev->accel_y_adc = (signed short)((data[2] << 8) | data[3]); 
	dev->accel_z_adc = (signed short)((data[4] << 8) | data[5]); 
	dev->temp_adc    = (signed short)((data[6] << 8) | data[7]); 
	dev->gyro_x_adc  = (signed short)((data[8] << 8) | data[9]); 
	dev->gyro_y_adc  = (signed short)((data[10] << 8) | data[11]);
	dev->gyro_z_adc  = (signed short)((data[12] << 8) | data[13]);
}

/*
 * ICM20608内部寄存器初始化函数 
 * @param - spi : 要操作的设备
 * @return 	: 无
 */
void icm20608_reginit(struct icm20608_dev *dev)
{
	u8 value = 0;
	
	icm20608_write_onereg(dev, ICM20_PWR_MGMT_1, 0x80);
	mdelay(50);
	icm20608_write_onereg(dev, ICM20_PWR_MGMT_1, 0x01);
	mdelay(50);

	value = icm20608_read_onereg(dev, ICM20_WHO_AM_I);
	printk("ICM20608 ID = %#X\r\n", value);	

	icm20608_write_onereg(dev, ICM20_SMPLRT_DIV, 0x00); 	/* 输出速率是内部采样率					*/
	icm20608_write_onereg(dev, ICM20_GYRO_CONFIG, 0x18); 	/* 陀螺仪±2000dps量程 				*/
	icm20608_write_onereg(dev, ICM20_ACCEL_CONFIG, 0x18); 	/* 加速度计±16G量程 					*/
	icm20608_write_onereg(dev, ICM20_CONFIG, 0x04); 		/* 陀螺仪低通滤波BW=20Hz 				*/
	icm20608_write_onereg(dev, ICM20_ACCEL_CONFIG2, 0x04); /* 加速度计低通滤波BW=21.2Hz 			*/
	icm20608_write_onereg(dev, ICM20_PWR_MGMT_2, 0x00); 	/* 打开加速度计和陀螺仪所有轴 				*/
	icm20608_write_onereg(dev, ICM20_LP_MODE_CFG, 0x00); 	/* 关闭低功耗 						*/
	icm20608_write_onereg(dev, ICM20_FIFO_EN, 0x00);		/* 关闭FIFO						*/
}

字符设备驱动框架

这里的驱动框架就比较常规。

在icm20608_read里面,与IIC一样,需要先读取filp的cdev首地址,再通过container_of来获取设备的首地址;然后调用已经写好的icm20608_readdata读取寄存器的值,然后把数据对应存入到自定义的data[7]数组之中,最后copy_to_user来传输。

open和release函数就是直接return 0就可以了。

file_operations这个操作函数集就是.open,.read以及.release。

编写测试APP

argc是传入了2个参数。

这里主要就是获取字符设备之后,filename=argv[1],然后open打开,在while死循环里面,通过read把数据读入databuf[7]数组里面,然后把数组的对应位置的值传入自己定义的变量里面;再根据寄存器设置的量程,把这些直接读取的数据转换成对应的真实值然后打印出来,最后usleep(100000)间隔100ms重复读取;跳出死循环外面close设备。

运行测试

内核使能SPI控制器

ST官方系统把SPI控制器的驱动编译成模块,需要把SPI控制器驱动编译进内核 ,这

样就可以在启动Linux内核的时候自动加载SPI控制器驱动,无需手动加载,方便使用。打开Linux内核图形化配置界面,按下路径找到对应的配置项:

|------------------------------------------------------------------------------------------------------------|
| -> Device Drivers -> SPI support (SPI [=y]) -> <*> STMicroelectronics STM32 SPI controller //编译进内核 |

如下图所示:

上图本来是选择为"M"",要改为"*",也就是编译进内核。接着重新编译设备树和内核,运行以下命令进行编译:

|-------------------------------------------|
| make dtbs uImage LOADADDR=0XC2000040 -j32 |

使用新编译好的stm32mp157d-atk.dtb和uImage镜像启动系统,如果SPI控制器驱动工作正常就会有如下图所示提示信息:

如果没有输出上图中"spi_stm32 44004000.spi: driver initialized"这句话,那就要检查一下设备树和内配配置是否有问题,通过查看/sys/bus/spi/devices/下有没有spi相关的设备,就能够知道设备树配置是否正确,比如本例程如下图所示:

编译驱动程序

老样子,Makefile里面的obj-m改成icm20608.o,然后"make"就可以了。

编译测试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 |

结果如下图所示:

从上图可以看出FPU架构为VFPv3,SIMD使用了NEON,说明icm20608App这个应用程序使用了硬件浮点。

运行测试

将上一小节编译出来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中读取数据,然后输出到终端上,如下图所示:

可以看出,开发板静止状态下,Z轴方向的加速度为0.97g,这个就是重力加速度。对于陀螺仪来讲,静止状态下三轴的角速度应该在0°/S左右。ICM20608内温度传感器采集到的温度在39.51度,可以晃动一下开发板,这个时候陀螺仪和加速度计的值就会有变化。

总结

跟之前的I2C驱动是很类似的,具体SPI主机驱动是不需要我们自己写的,我们只需要写从机驱动,也就是对应的传感器芯片的驱动就可以了。

首先需要修改设备数,根据SPI的接口,在stm32mp15-pinctrl.dtsi中,修改电气属性,添加复用功能;然后在stm32mp157d-atk.dts设备树文件中,添加对应的spi节点,并与pinctrl关联。

然后要编写SPI驱动传感器或芯片的头文件,按照数据手册定义好寄存器的地址。

对于驱动程序而言,首先是设备结构体,这里就是要添加spi_device结构体的*spi,来完成对spi的设置。然后就是通过设备树,写一个SPI的驱动结构体spi_driver,定义probe和remove函数,然后在.driver里面写好.owner,.name和.of_match_table。of_match_table就是of_device_id结构体的数组,设置好.compatible就可以了。驱动的入口和出口就是调用spi_register_driver和spi_unregister_driver。

probe函数,首先来通过devm_kzalloc分配内存之后,走字符设备的流程,然后是初始化spi_device,通过spi->mode选定SPI工作模式,然后spi_setup初始化,之后调用自行编写的初始化寄存器的函数,并通过spi_set_drvdata保存spi结构体。

remove函数,就是通过spi_get_drvdata获取到spi结构体,然后注销字符设备驱动的四件套就可以了。

这里SPI实验是使用ICM20608,所以根据他的手册和寄存器,来编写对寄存器的读写函数,这里因为全双工就不区别收发的长度,只要注意长度是len+1就可以了。

字符设备的驱动框架就是老样子,这里注意在read里面,要跟I2C一样,先读cdev首地址,再container_of获取设备首地址。

相关推荐
哎呦喂-ll29 分钟前
Linux进阶:环境变量
linux
Rverdoser31 分钟前
Linux环境开启MongoDB的安全认证
linux·安全·mongodb
PigeonGuan41 分钟前
【jupyter】linux服务器怎么使用jupyter
linux·ide·jupyter
zmd-zk1 小时前
flink学习(2)——wordcount案例
大数据·开发语言·学习·flink
Chef_Chen1 小时前
从0开始学习机器学习--Day33--机器学习阶段总结
人工智能·学习·机器学习
东华果汁哥1 小时前
【linux 免密登录】快速设置kafka01、kafka02、kafka03 三台机器免密登录
linux·运维·服务器
咖喱鱼蛋2 小时前
Ubuntu安装Electron环境
linux·ubuntu·electron
2202_754421542 小时前
一个计算频率的模块
驱动开发·fpga开发
ac.char2 小时前
在 Ubuntu 系统上安装 npm 环境以及 nvm(Node Version Manager)
linux·ubuntu·npm