工业场合里面也有大量的模拟量和数字量之间的转换，也就是我们常说的 ADC 和 DAC。 而且随着手机、物联网、工业物联网和可穿戴设备的爆发，传感器的需求只持续增强。比如手 机或者手环里面的加速度计、光传感器、陀螺仪、气压计、磁力计等，这些传感器本质上都是 ADC，大家注意查看这些传感器的手册，会发现他们内部都会有个 ADC，传感器对外提供 IIC 或者 SPI 接口，SOC 可以通过 IIC 或者 SPI 接口来获取到传感器内部的 ADC 数值，从而得到 想要测量的结果。Linux 内核为了管理这些日益增多的 ADC 类传感器，特地推出了 IIO 子系统， 本章我们就来学习如何使用 IIO 子系统来编写 ADC 类传感器驱动。

1：IIO 子系统简介

IIO 全称是 Industrial I/O，翻译过来就是工业 I/O，大家不要看到“工业”两个字就觉得 IIO 是只用于工业领域的。大家一般在搜索 IIO 子系统的时候，会发现大多数讲的都是 ADC，这是 因为 IIO 就是为 ADC 类传感器准备的，当然了 DAC 也是可以的。大家常用的陀螺仪、加速度 计、电压/电流测量芯片、光照传感器、压力传感器等内部都是有个 ADC，内部 ADC 将原始的 模拟数据转换为数字量，然后通过其他的通信接口，比如 IIC、SPI 等传输给 SOC。 因此，当你使用的传感器本质是 ADC 或 DAC 器件的时候，可以优先考虑使用 IIO 驱动框 架。

1.1：iio_dev

1.1.1：iio_dev 结构体

IIO 子系统使用结构体 iio_dev 来描述一个具体 IIO 设备，此设备结构体定义在 include/linux/iio/iio.h 文件中，结构体内容如下(有省略)：

474 struct iio_dev {
475 int id;
476
477 int modes;
478 int currentmode;
479 struct device dev;
480
481 struct iio_event_interface *event_interface;
482
483 struct iio_buffer *buffer;
484 struct list_head buffer_list;
485 int scan_bytes;
486 struct mutex mlock;
487
488 const unsigned long *available_scan_masks;
489 unsigned masklength;
490 const unsigned long *active_scan_mask;
491 bool scan_timestamp;
492 unsigned scan_index_timestamp;
493 struct iio_trigger *trig;
494 struct iio_poll_func *pollfunc;
495
496 struct iio_chan_spec const *channels;
497 int num_channels;
498
499 struct list_head channel_attr_list;
500 struct attribute_group chan_attr_group;
501 const char *name;
502 const struct iio_info *info;
503 struct mutex info_exist_lock;
504 const struct iio_buffer_setup_ops *setup_ops;
505 struct cdev chrdev;
......
515 };

我们来看一下 iio_dev 结构体中几个比较重要的成员变量： 第 477 行，modes 为设备支持的模式，可选择的模如表 75.1.1.1 所示：

 第 478 行，currentmode 为当前模式。

第 483 行，buffer 为缓冲区。

第 484 行，buffer_list 为当前匹配的缓冲区列表。

第 485 行，scan_bytes 为捕获到，并且提供给缓冲区的字节数。

第 488 行，available_scan_masks 为可选的扫描位掩码，使用触发缓冲区的时候可以通过设 置掩码来确定使能哪些通道，使能以后的通道会将捕获到的数据发送到 IIO 缓冲区。

第 490 行，active_scan_mask 为缓冲区已经开启的通道掩码。只有这些使能了的通道数据才 能被发送到缓冲区。

第 491 行，scan_timestamp 为扫描时间戳，如果使能以后会将捕获时间戳放到缓冲区里面。

第 493 行，trig 为 IIO 设备当前触发器，当使用缓冲模式的时候。

第 494 行，pollfunc 为一个函数，在接收到的触发器上运行。

第 496 行，channels 为 IIO 设备通道，为 iio_chan_spec 结构体类型，稍后会详细讲解 IIO 通道。

第 497 行，num_channels 为 IIO 设备的通道数。

第 501 行，name 为 IIO 设备名字。

第 502 行，info 为 iio_info 结构体类型，这个结构体里面有很多函数，需要驱动开发人员编 写，非常重要！我们从用户空间读取 IIO 设备内部数据，最终调用的就是 iio_info 里面的函数。 稍后会详细讲解 iio_info 结构体。

第 504 行，setup_ops 为 iio_buffer_setup_ops 结构体类型，内容如下

427 struct iio_buffer_setup_ops {
428 int (*preenable)(struct iio_dev *); /* 缓冲区使能之前调用 */
429 int (*postenable)(struct iio_dev *); /* 缓冲区使能之后调用 */
430 int (*predisable)(struct iio_dev *); /* 缓冲区禁用之前调用 */
431 int (*postdisable)(struct iio_dev *); /* 缓冲区禁用之后调用 */
432 bool (*validate_scan_mask)(struct iio_dev *indio_dev,
433 const unsigned long *scan_mask); /* 检查扫描掩码是否有效 */
434 };

可以看出 iio_buffer_setup_ops 里面都是一些回调函数，在使能或禁用缓冲区的时候会调用这些函数。如果未指定的话就默认使用 iio_triggered_buffer_setup_ops。 继续回到示例代码 75.1.1.1 中第 505 行，chrdev 为字符设备，由 IIO 内核创建。

1.1.2：iio_dev 申请与释放

在使用之前要先申请 iio_dev，申请函数为 iio_device_alloc，函数原型如下：

struct iio_dev *iio_device_alloc(int sizeof_priv)

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

sizeof_priv：私有数据内存空间大小，一般我们会将自己定义的设备结构体变量作为 iio_dev 的私有数据，这样可以直接通过 iio_device_alloc 函数同时完成 iio_dev 和设备结构体变量的内 存申请。申请成功以后使用 iio_priv 函数来得到自定义的设备结构体变量首地址。

返回值：如果申请成功就返回 iio_dev 首地址，如果失败就返回 NULL。 一般 iio_device_alloc 和 iio_priv 之间的配合使用如下所示：

1 struct icm20608_dev *dev;
2 struct iio_dev *indio_dev;
3 
4 /* 1、申请 iio_dev 内存 */
5 indio_dev = iio_device_alloc(sizeof(*dev));
6 if (!indio_dev)
7 return -ENOMEM;
8 
9 /* 2、获取设备结构体变量地址 */
10 dev = iio_priv(indio_dev);

第 1 行，icm20608_dev 是自定义的设备结构体。

第 2 行，indio_dev 是 iio_dev 结构体变量指针。

第 5 行，使用 iio_device_alloc 函数来申请 iio_dev，并且一起申请了 icm2060_dev 的内存。

第 10 行，使用 iio_priv 函数从 iio_dev 中提取出私有数据，也就是 icm2608_dev 这个自定 义结构体变量首地址。 如果要释放 iio_dev，需要使用 iio_device_free 函数，函数原型如下：

void iio_device_free(struct iio_dev *indio_dev)

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

indio_dev：需要释放的 iio_dev。

返回值：无。

也 可 以 使 用 devm_iio_device_alloc 来 分 配 iio_dev ， 这 样 就 不 需 要 我 们 手 动 调 用 iio_device_free 函数完成 iio_dev 的释放工作。

1.1.3：iio_dev 注册与注销

前面分配好 iio_dev 以后就要初始化各种成员变量，初始化完成以后就需要将 iio_dev 注册 到内核中，需要用到 iio_device_register 函数，函数原型如下：

int iio_device_register(struct iio_dev *indio_dev)

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

indio_dev：需要注册的 iio_dev。

返回值：0，成功；其他值，失败。

如果要注销 iio_dev 使用 iio_device_unregister 函数，函数原型如下：

void iio_device_unregister(struct iio_dev *indio_dev)

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

indio_dev：需要注销的 iio_dev。

返回值：0，成功；其他值，失败。

1.2：iio_info

iio_dev 有个成员变量：info，为 iio_info 结构体指针变量，这个是我们在编写 IIO 驱动的时 候需要着重去实现的，因为用户空间对设备的具体操作最终都会反映到 iio_info 里面。iio_info 结构体定义在 include/linux/iio/iio.h 中，结构体定义如下(有省略)：

352 struct iio_info {
353 struct module *driver_module;
354 struct attribute_group *event_attrs;
355 const struct attribute_group *attrs;
356
357 int (*read_raw)(struct iio_dev *indio_dev,
358 struct iio_chan_spec const *chan,
359 int *val,
360 int *val2,
361 long mask);
......
369
370 int (*write_raw)(struct iio_dev *indio_dev,
371 struct iio_chan_spec const *chan,
372 int val,
373 int val2,
374 long mask);
375
376 int (*write_raw_get_fmt)(struct iio_dev *indio_dev,
377 struct iio_chan_spec const *chan,
378 long mask);
......
415 };

第 355 行，attrs 是通用的设备属性。

第 357 和 370 行，分别为 read_raw 和 write_raw 函数，这两个函数就是最终读写设备内部 数据的操作函数，需要程序编写人员去实现的。比如应用读取一个陀螺仪传感器的原始数据， 那么最终完成工作的就是 read_raw 函数，我们需要在 read_raw 函数里面实现对陀螺仪芯片的 读取操作。同理，write_raw 是应用程序向陀螺仪芯片写数据，一般用于配置芯片，比如量 程、数据速率等。这两个函数的参数都是一样的，我们依次来看一下： indio_dev：需要读写的 IIO 设备。 chan：需要读取的通道。 val，val2：对于 read_raw 函数来说 val 和 val2 这两个就是应用程序从内核空间读取到数 据，一般就是传感器指定通道值，或者传感器的量程、分辨率等。对于 write_raw 来说就是应用程序向设备写入的数据。val 和 val2 共同组成具体值，val 是整数部分，val2 是小数部分。但是 val2 也是对具体的小数部分扩大 N 倍后的整数值，因为不能直接从内核向应用程序返回一个小 数值。比如现在有个值为 1.00236，那么 val 就是 1，vla2 理论上来讲是 0.00236，但是我们需要 对 0.00236 扩大 N 倍，使其变为整数，这里我们扩大 1000000 倍，那么 val2 就是 2360。因此 val=1，val2=2360。扩大的倍数我们不能随便设置，而是要使用 Linux 定义的倍数，Linux 内核 里面定义的数据扩大倍数，或者说数据组合形式如表 75.1.2.1 所示：

mask：掩码，用于指定我们读取的是什么数据，比如 ICM20608 这样的传感器，他既有原 始的测量数据，比如 X,Y,Z 轴的陀螺仪、加速度计等，也有测量范围值，或者分辨率。比如加 速度计测量范围设置为±16g，那么分辨率就是 32/65536≈0.000488，我们只有读出原始值以及 对应的分辨率(量程)，才能计算出真实的重力加速度。此时就有两种数据值：传感器原始值、分 辨率。Linux 内核使用 IIO_CHAN_INFO_RAW 和 IIO_CHAN_INFO_SCALE 这两个宏来表示原 始值以及分辨率，这两个宏就是掩码。至于每个通道可以采用哪几种掩码，这个在我们初始化 通道的时候需要驱动编写人员设置好。掩码有很多种，稍后讲解 IIO 通道的时候详细讲解！

第 376 行的 write_raw_get_fmt 用于设置用户空间向内核空间写入的数据格式， write_raw_get_fmt 函数决定了 wtite_raw 函数中 val 和 val2 的意义，也就是表 75.1.2.1 中的组合 形式。比如我们需要在应用程序中设置 ICM20608 加速度计的量程为±8g，那么分辨率就是 16/65536 ≈0.000244 ，我们 在 write_raw_get_fmt 函数 里面设置 加速度计的数 据格式 为 IIO_VAL_INT_PLUS_MICRO。那么我们在应用程序里面向指定的文件写入 0.000244 以后，最 终传递给内核驱动的就是 0.000244*1000000=244。也就是 write_raw 函数的 val 参数为 0，val2 参数为 244。

1.3：iio_chan_spec

IIO 的核心就是通道，一个传感器可能有多路数据，比如一个 ADC 芯片支持 8 路采集，那 么这个 ADC 就有 8 个通道。我们本章实验用到的 ICM20608，这是一个六轴传感器，可以输出三轴陀螺仪(X、Y、Z)、三轴加速度计(X、Y、Z)和一路温度，也就是一共有 7 路数据，因此就 有 7 个通道。注意，三轴陀螺仪或加速度计的 X、Y、Z 这三个轴，每个轴都算一个通道。 Linux 内核使用 iio_chan_spec 结构体来描述通道，定义在 include/linux/iio/iio.h 文件中，内 容如下：

223 struct iio_chan_spec {
224 enum iio_chan_type type;
225 int channel;
226 int channel2;
227 unsigned long address;
228 int scan_index;
229 struct {
230 char sign;
231 u8 realbits;
232 u8 storagebits;
233 u8 shift;
234 u8 repeat;
235 enum iio_endian endianness;
236 } scan_type;
237 long info_mask_separate;
238 long info_mask_shared_by_type;
239 long info_mask_shared_by_dir;
240 long info_mask_shared_by_all;
241 const struct iio_event_spec *event_spec;
242 unsigned int num_event_specs;
243 const struct iio_chan_spec_ext_info *ext_info;
244 const char *extend_name;
245 const char *datasheet_name;
246 unsigned modified:1;
247 unsigned indexed:1;
248 unsigned output:1;
249 unsigned differential:1;
250 };

来看一下 iio_chan_spec 结构体中一些比较重要的成员变量： 第 224 行，type 为通道类型， iio_chan_type 是一个枚举类型，列举出了可以选择的通道类 型，定义在 include/uapi/linux/iio/types.h 文件里面，内容如下：

13 enum iio_chan_type {
14 IIO_VOLTAGE, /* 电压类型 */
15 IIO_CURRENT, /* 电流类型 */
16 IIO_POWER, /* 功率类型 */
17 IIO_ACCEL, /* 加速度类型 */
18 IIO_ANGL_VEL, /* 角度类型(陀螺仪) */
19 IIO_MAGN, /* 电磁类型(磁力计) */
20 IIO_LIGHT, /* 灯光类型 */
21 IIO_INTENSITY, /* 强度类型(光强传感器) */
22 IIO_PROXIMITY, /* 接近类型(接近传感器) */
23 IIO_TEMP, /* 温度类型 */
24 IIO_INCLI, /* 倾角类型(倾角测量传感器) */
25 IIO_ROT, /* 旋转角度类型 */
26 IIO_ANGL, /* 转动角度类型(电机旋转角度测量传感器) */
27 IIO_TIMESTAMP, /* 时间戳类型 */
28 IIO_CAPACITANCE, /* 电容类型 */
29 IIO_ALTVOLTAGE, /* 频率类型 */
30 IIO_CCT, /* 笔者暂时未知的类型 */
31 IIO_PRESSURE, /* 压力类型 */ 
32 IIO_HUMIDITYRELATIVE, /* 湿度类型 */
33 IIO_ACTIVITY, /* 活动类型(计步传感器) */
34 IIO_STEPS, /* 步数类型 */
35 IIO_ENERGY, /* 能量类型(卡路里) */
36 IIO_DISTANCE, /* 距离类型 */
37 IIO_VELOCITY, /* 速度类型 */
38 };

从示例代码 75.1.3.2 可以看出，目前 Linux 内核支持的传感器类型非常丰富，而且支持类 型也会不断的增加。如果是 ADC，那就是 IIO_VOLTAGE 类型。如果是 ICM20608 这样的多轴 传感器，那么就是复合类型了，陀螺仪部分是 IIO_ANGL_VEL 类型，加速度计部分是 IIO_ACCEL 类型，温度部分就是 IIO_TEMP。 继续来看示例代码 75.1.3.1 中的 iio_chan_spec 结构体，第 225 行，当成员变量 indexed 为 1 时候，channel 为通道索引。

第 226 行，当成员变量 modified 为 1 的时候，channel2 为通道修饰符。Linux 内核给出了 可用的通道修饰符，定义在 include/uapi/linux/iio/types.h 文件里面，内容如下(有省略)

40 enum iio_modifier {
41 IIO_NO_MOD,
42 IIO_MOD_X, /* X 轴 */
43 IIO_MOD_Y, /* Y 轴 */
44 IIO_MOD_Z, /* Z 轴 */
......
73 };

比如 ICM20608 的加速度计部分，类型设置为 IIO_ACCEL，X、Y、Z 这三个轴就用 channel2 的通道修饰符来区分。IIO_MOD_X、IIO_MOD_Y、IIO_MOD_Z 就分别对应 X、Y、Z 这三个 轴。通道修饰符主要是影响 sysfs 下的通道文件名字，后面我们会讲解 sysfs 下通道文件名字组 成形式。 继续回到示例代码 75.1.3.1，

第 227 行的 address 成员变量用户可以自定义，但是一般会设 置为此通道对应的芯片数据寄存器地址。比如 ICM20608 的加速度计 X 轴这个通道，它的数据首地址就是 0X3B。address 也可以用作其他功能，自行选择，也可以不使用 address，一切以实 际情况为准。

第 228 行，当使用触发缓冲区的时候，scan_index 是扫描索引。

第 229~236，scan_type 是一个结构体，描述了扫描数据在缓冲区中的存储格式。我们依次 来看一下 scan_type 各个成员变量的涵义：

scan_type.sign：如果为‘u’表示数据为无符号类型，为‘s’的话为有符号类型。 scan_type.realbits：数据真实的有效位数，比如很多传感器说的 10 位 ADC，其真实有效数 据就是 10 位。 scan_type.storagebits：存储位数，有效位数+填充位。比如有些传感器 ADC 是 12 位的， 那么我们存储的话肯定要用到 2 个字节，也就是 16 位，这 16 位就是存储位数。 scan_type.shift:右移位数，也就是存储位数和有效位数不一致的时候，需要右移的位数，这 个参数不总是需要，一切以实际芯片的数据手册位数。 scan_type.repeat：实际或存储位的重复数量。 scan_type.endianness:数据的大小端模式，可设置为 IIO_CPU、IIO_BE(大端)或 IIO_LE(小 端)。

第 237 行，info_mask_separate 标记某些属性专属于此通道，include/linux/iio/types.h 文件中 的 iio_chan_info_enum 枚举类型描述了可选的属性值，如下所示：

23 enum iio_chan_info_enum {
24 IIO_CHAN_INFO_RAW = 0,
25 IIO_CHAN_INFO_PROCESSED,
26 IIO_CHAN_INFO_SCALE,
27 IIO_CHAN_INFO_OFFSET,
......
45 IIO_CHAN_INFO_DEBOUNCE_TIME,
46 };

比如 ICM20608 加速度计的 X、Y、Z 这三个轴，在 sysfs 下这三个轴肯定是对应三个不同 的文件，我们通过读取这三个文件就能得到每个轴的原始数据。IIO_CHAN_INFO_RAW 这个属 性表示原始数据，当我们在配置 X、Y、Z 这三个通道的时候，在 info_mask_separate 中使能 IIO_CHAN_INFO_RAW 这个属性，那么就表示在 sysfs 下生成三个不同的文件分别对应 X、Y、 Z 轴，这三个轴的 IIO_CHAN_INFO_RAW 属性是相互独立的。

第 238 行，info_mask_shared_by_type 标记导出的信息由相同类型的通道共享。也就是 iio_chan_spec.type 成员变量相同的通道。比如 ICM20608 加速度计的 X、Y、Z 轴他们的 type 都 是 IIO_ACCEL，也就是类型相同。而这三个轴的分辨率(量程)是一样的，那么在配置这三个通 道的时候就可以在 info_mask_shared_by_type 中使能 IIO_CHAN_INFO_SCALE 这个属性，表示 这三个通道的分辨率是共用的，这样在 sysfs 下就会只生成一个描述分辨率的文件，这三个通道 都可以使用这一个分辨率文件。

第 239 行，info_mask_shared_by_dir 标记某些导出的信息由相同方向的通道共享。

第 240 行，info_mask_shared_by_all 表设计某些信息所有的通道共享，无论这些通道的类 型、方向如何，全部共享。

第 246 行，modified 为 1 的时候，channel2 为通道修饰符。

第 247 行，indexed 为 1 的时候，channel 为通道索引。

第 248 行，output 表示为输出通道。

第 249 行，differential 表示为差分通道。

2：IIO 驱动框架创建

前面我们已经对 IIO 设备、IIO 通道进行了详细的讲解，本节我们就来学习如何搭建 IIO 驱 动框架。在上一小节分析 IIO 子系统的时候大家应该看出了，IIO 框架主要用于 ADC 类的传感 器，比如陀螺仪、加速度计、磁力计、光强度计等，这些传感器基本都是 IIC 或者 SPI 接口的。 因此 IIO 驱动的基础框架就是 IIC 或者 SPI，我们可以在 IIC 或 SPI 驱动里面在加上上一章讲解 的 regmap。当然了，有些 SOC 内部的 ADC 也会使用 IIO 框架，那么这个时候驱动的基础框架 就是 platfrom。

2.1：基础驱动框架建立

我们以 SPI 接口为例，首先是 SPI 驱动框架，如下所示：

1 /*
2 * @description : spi 驱动的 probe 函数，当驱动与
3 * 设备匹配以后此函数就会执行
4 * @param - spi : spi 设备
5 * @return : 0,成功；其他值，失败
6 */ 
7 static int xxx_probe(struct spi_device *spi)
8 {
9 return 0;
10 }
11
12 /*
13 * @description : spi 驱动的 remove 函数，移除 spi 驱动的时候此函数会执行
14 * @param - spi : spi 设备
15 * @return : 0，成功;其他负值,失败
16 */
17 static int xxx_remove(struct spi_device *spi)
18 {
19 return 0;
20 }
21
22 /* 传统匹配方式 ID 列表 */
23 static const struct spi_device_id xxx_id[] = {
24 {"alientek,xxx", 0},
25 {}
26 };
27
28 /* 设备树匹配列表 */
29 static const struct of_device_id xxx_of_match[] = {
30 { .compatible = "alientek,xxx" },
31 { /* Sentinel */ }
32 };
33
34 /* SPI 驱动结构体 */
35 static struct spi_driver xxx_driver = {
36 .probe = xxx_probe,
37 .remove = xxx_remove,
38 .driver = {
39 .owner = THIS_MODULE,
40 .name = "xxx",
41 .of_match_table = xxx_of_match,
42 },
43 .id_table = xxx_id,
44 };
45
46 /*
47 * @description : 驱动入口函数
48 * @param : 无
49 * @return : 无
50 */
51 static int __init xxx_init(void)
52 {
53 return spi_register_driver(&xxx_driver);
54 }
55
56 /*
57 * @description : 驱动出口函数
58 * @param : 无
59 * @return : 无
60 */
61 static void __exit xxx_exit(void)
62 {
63 spi_unregister_driver(&xxx_driver);
64 }
65
66 module_init(xxx_init);
67 module_exit(xxx_exit);
68 MODULE_LICENSE("GPL");
69 MODULE_AUTHOR("ALIENTEK");

示例代码 75.2.1.1 就是标准的 SPI 驱动框架，如果所使用的传感器是 IIC 接口的，那么就 是 IIC 驱动框架，没啥好说的。

2.2：IIO 设备申请与初始化

IIO 设备的申请、初始化以及注册在 probe 函数中完成，在注销驱动的时候还需要在 remove 函数中注销掉 IIO 设备、释放掉申请的一些内存。添加完 IIO 框架以后的 probe 和 remove 函数 如下所示：

1 /* 自定义设备结构体 */
2 struct xxx_dev {
3 struct spi_device *spi; /* spi 设备 */
4 struct regmap *regmap; /* regmap */
5 struct regmap_config regmap_config;
6 struct mutex lock;
7 };
8 
9 /*
10 * 通道数组
11 */
12 static const struct iio_chan_spec xxx_channels[] = {
13 
14 };
15 
16 /*
17 * @description : 读函数，当读取 sysfs 中的文件的时候最终此函数会执行，
18 * ：此函数里面会从传感器里面读取各种数据，然后上传给应用。
19 * @param - indio_dev : IIO 设备
20 * @param - chan : 通道
21 * @param - val : 读取的值，如果是小数值的话，val 是整数部分。
22 * @param - val2 : 读取的值，如果是小数值的话，val2 是小数部分。
23 * @param - mask : 掩码。
24 * @return : 0，成功；其他值，错误
25 */
26 static int xxx_read_raw(struct iio_dev *indio_dev,
27 struct iio_chan_spec const *chan,
28 int *val, int *val2, long mask)
29 {
30 return 0;
31 } 
32 
33 /*
34 * @description : 写函数，当向 sysfs 中的文件写数据的时候最终此函数
35 * ：会执行，一般在此函数里面设置传感器，比如量程等。
36 * @param - indio_dev : IIO 设备
37 * @param - chan : 通道
38 * @param - val : 应用程序写入值，如果是小数的话，val 是整数部分。
39 * @param - val2 : 应用程序写入值，如果是小数的话，val2 是小数部分。
40 * @return : 0，成功；其他值，错误
41 */
42 static int xxx_write_raw(struct iio_dev *indio_dev,
43 struct iio_chan_spec const *chan,
44 int val, int val2, long mask)
45 {
46 return 0;
47 }
48 
49 /*
50 * @description : 用户空间写数据格式，比如我们在用户空间操作 sysfs 来设
51 * ：置传感器的分辨率，如果分辨率带小数，那么这个小数传递到
52 * : 内核空间应该扩大多少倍，此函数就是用来设置这个的。
53 * @param - indio_dev : iio_dev
54 * @param - chan : 通道
55 * @param - mask : 掩码
56 * @return : 0，成功；其他值，错误
57 */
58 static int xxx_write_raw_get_fmt(struct iio_dev *indio_dev,
59 struct iio_chan_spec const *chan, long mask)
60 {
61 return 0;
62 }
63 
64 /*
65 * iio_info 结构体变量
66 */
67 static const struct iio_info xxx_info = {
68 .read_raw = xxx_read_raw,
69 .write_raw = xxx_write_raw,
70 .write_raw_get_fmt = &xxx_write_raw_get_fmt,
71 };
72 
73 /*
74 * @description : spi 驱动的 probe 函数，当驱动与
75 * 设备匹配以后此函数就会执行
76 * @param - spi : spi 设备
77 * 
78 */ 
79 static int xxx_probe(struct spi_device *spi)
80 {
81 int ret;
82 struct xxx_dev *data;
83 struct iio_dev *indio_dev;
84 
85 /* 1、申请 iio_dev 内存 */
86 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data));
87 if (!indio_dev)
88 return -ENOMEM;
89 
90 /* 2、获取 xxx_dev 结构体地址 */
91 data = iio_priv(indio_dev);
92 data->spi = spi;
93 spi_set_drvdata(spi, indio_dev);
94 mutex_init(&data->lock);
95 
96 /* 3、初始化 iio_dev 成员变量 */
97 indio_dev->dev.parent = &spi->dev;
98 indio_dev->info = &xxx_info;
99 indio_dev->name = "xxx";
100 indio_dev->modes = INDIO_DIRECT_MODE; /* 直接模式 /
101 indio_dev->channels = xxx_channels;
102 indio_dev->num_channels = ARRAY_SIZE(xxx_channels);
103
104 iio_device_register(indio_dev);
105
106 /* 4、regmap 相关设置 */
107
108 /* 5、SPI 相关设置*/
109 
110 /* 6、芯片初始化 */
111
112 return 0;
113
114 }
115
116 /*
117 * @description : spi 驱动的 remove 函数，移除 spi 驱动的时候此函数会执行
118 * @param - spi : spi 设备
119 * @return : 0，成功;其他负值,失败
120 */
121 static int xxx_remove(struct spi_device *spi)
122 {
123 struct iio_dev *indio_dev = spi_get_drvdata(spi);
124 struct xxx_dev *data;
125 
126 data = iio_priv(indio_dev); ;
127
128 /* 1、其他资源的注销以及释放 */
129 
130 /* 2、注销 IIO */
131 iio_device_unregister(indio_dev);
132 
133 return 0;
134 }

第 2~7 行，用户自定义的设备结构体。

第 12 行，IIO 通道数组。

第 16~71 行， 这部分为 iio_info，当应用程序读取相应的驱动文件的时候，xxx_read_raw 函数就会执行，我们在此函数中会读取传感器数据，然后返回给应用层。当应用层向相应的驱 动写数据的时候，xxx_write_raw 函数就会执行。因此 xxx_read_raw 和 xxx_write_raw 这两个函 数是非常重要的！需要我们根据具体的传感器来编写，这两个函数是编写 IIO 驱动的核心。

第 79~114 行，xxx_probe 函数，此函数的核心就是分配并初始化 iio_dev，最后向内核注册 iio_dev。

第 86 行调用 devm_iio_device_alloc 函数分配 iio_dev 内存，这里连用户自定义的设备 结构体变量内存一起申请了。

第 91 行调用 iio_priv 函数从 iio_dev 中提取出私有数据，这个私 有数据就是设备结构体变量。

第 97~102 行初始化 iio_dev，重点是第 98 行设置 iio_dev 的 info 成员变量。

第 101 行设置 iio_dev 的通道。初始化完成以后就要调用 iio_device_register 函数向 内核注册 iio_dev。整个过程就是：申请 iio_dev、初始化、注册，和我们前面讲解的其他驱动框 架步骤一样。

第 121~134 行，xxx_remove 函数里面需要做的就是释放 xxx_probe 函数申请到的 IIO 相关 资源，比如第 131 行，使用 iio_device_unregister 注销掉前面注册的 iio_dev。由于前面我们使用 devm_iio_device_alloc 函数申请的 iio_dev，因此不需要在 remove 函数中手动释放 iio_dev。

IIO 框架示例就讲解到这里，剩下的就是根据所使用的具体传感器，在 IIO 驱动框架里面添 加相关的处理，接下来我们就以正点原子 I.MX6ULL 开发板上的 ICM20608 为例，进行 IIO 驱 动实战！

3：实验程序编写

接下来我们就直接使用 IIO 驱动框架编写 ICM20608 驱动，ICM20608 驱动核心就是 SPI， 上一章我们也讲解了如何在 SPI 总线上使用 regmap。因此本章 ICM20608 驱动底层没啥好讲解 的，重点是如何套上 IIO 驱动框架，因此关于 ICM20608 芯片内部寄存器、SPI 驱动、regmap 等 不会做讲解，有什么不懂的可以看前面相应的实验章节。

本实验对应的例程路径为：开发板光盘→01、程序源码→02、Linux 驱动例程→27_iio→spi

3.1：使能内核 IIO 相关配置

Linux 内核默认使能了 IIO 子系统，但是有一些 IIO 模块没有选择上，这样会导致我们编译 驱动的时候会提示某些 API 函数不存在，需要使能的项目如下：

-> Device Drivers 
     -> Industrial I/O support (IIO [=y]) 
        -> [*]Enable buffer support within IIO //选中
            -> <*>Industrial I/O buffering based on kfifo //选中

如图 75.3.1.1 所示：

3.2：ICM20608 的 IIO 驱动框架搭建

3.2.1：驱动框架搭建

设备树不需要做任何修改！ 首先我们基于上一章实验，搭建出 ICM20608 的 IIO 驱动框架，IIO 框架部分我们已经在示 例代码 75.2.2.1 中进行了详细的讲解。新建名为 icm20608.c 的驱动文件，搭建好的 ICM20608 IIO 驱动框架内容如下所示：

/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : icm20608.c
作者 : 正点原子 Linux 团队
版本 : V1.0
描述 : ICM20608 SPI 驱动程序
其他 : 无
论坛 : www.openedv.com
日志 : 初版 V1.0 2021/03/22 正点原子 Linux 团队创建
 V1.1 2021/08/10 
 使用 regmap 读写 SPI 外设内部寄存器。
 V1.2 2021/08/13 
 使用 IIO 框架，参考 bma220_spi.c
1 #include <linux/spi/spi.h>
2 #include <linux/kernel.h>
3 #include <linux/module.h>
4 #include <linux/init.h>
5 #include <linux/delay.h>
6 #include <linux/ide.h>
7 #include <linux/errno.h>
8 #include <linux/platform_device.h>
9 #include "icm20608reg.h"
10 #include <linux/gpio.h>
11 #include <linux/device.h>
12 #include <asm/uaccess.h>
13 #include <linux/cdev.h>
14 #include <linux/regmap.h>
15 #include <linux/iio/iio.h>
16 #include <linux/iio/sysfs.h>
17 #include <linux/iio/buffer.h>
18 #include <linux/iio/trigger.h>
19 #include <linux/iio/triggered_buffer.h>
20 #include <linux/iio/trigger_consumer.h>
21 #include <linux/unaligned/be_byteshift.h>
22 
23 #define ICM20608_NAME "icm20608"
24 
25 #define ICM20608_CHAN(_type, _channel2, _index) \
26 { \
27 .type = _type, \
28 .modified = 1, \
29 .channel2 = _channel2, \
30 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
31 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
32 BIT(IIO_CHAN_INFO_CALIBBIAS), \
33 .scan_index = _index, \
34 .scan_type = { \
35 .sign = 's', \
36 .realbits = 16, \
37 .storagebits = 16, \
38 .shift = 0, \
39 .endianness = IIO_BE, \
40 }, \
41 }
42
43 /* 
44 * ICM20608 的扫描元素，3 轴加速度计、
45 * 3 轴陀螺仪、1 路温度传感器，1 路时间戳
46 */
47 enum inv_icm20608_scan {
48 INV_ICM20608_SCAN_ACCL_X,
49 INV_ICM20608_SCAN_ACCL_Y,
50 INV_ICM20608_SCAN_ACCL_Z,
51 INV_ICM20608_SCAN_TEMP,
52 INV_ICM20608_SCAN_GYRO_X,
53 INV_ICM20608_SCAN_GYRO_Y,
54 INV_ICM20608_SCAN_GYRO_Z,
55 INV_ICM20608_SCAN_TIMESTAMP,
56 };
57 
58 struct icm20608_dev {
59 struct spi_device *spi; /* spi 设备 */
60 struct regmap *regmap; /* regmap */
61 struct regmap_config regmap_config;
62 struct mutex lock;
63 };
64 
65 /*
66 * icm20608 通道，1 路温度通道，3 路陀螺仪，3 路加速度计
67 */
68 static const struct iio_chan_spec icm20608_channels[] = {
69 /* 温度通道 */
70 {
71 .type = IIO_TEMP,
72 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
73 | BIT(IIO_CHAN_INFO_OFFSET)
74 | BIT(IIO_CHAN_INFO_SCALE),
75 .scan_index = INV_ICM20608_SCAN_TEMP,
76 .scan_type = {
77 .sign = 's',
78 .realbits = 16,
79 .storagebits = 16,
80 .shift = 0,
81 .endianness = IIO_BE,
82 },
83 },
84 
85 ICM20608_CHAN(IIO_ANGL_VEL, IIO_MOD_X,INV_ICM20608_SCAN_GYRO_X),
86 ICM20608_CHAN(IIO_ANGL_VEL, IIO_MOD_Y,INV_ICM20608_SCAN_GYRO_Y),
87 ICM20608_CHAN(IIO_ANGL_VEL, IIO_MOD_Z,INV_ICM20608_SCAN_GYRO_Z), 
88 
89 ICM20608_CHAN(IIO_ACCEL, IIO_MOD_Y, INV_ICM20608_SCAN_ACCL_Y), 
90 ICM20608_CHAN(IIO_ACCEL, IIO_MOD_X, INV_ICM20608_SCAN_ACCL_X), 
91 ICM20608_CHAN(IIO_ACCEL, IIO_MOD_Z, INV_ICM20608_SCAN_ACCL_Z), 
92 };
93 
94 /*
95 * @description : 读取 icm20608 指定寄存器值，读取一个寄存器
96 * @param – dev : icm20608 设备
97 * @param – reg : 要读取的寄存器
98 * @return : 读取到的寄存器值
99 */
100 static unsigned char icm20608_read_onereg(struct icm20608_dev *dev,
u8 reg)
101 {
102 u8 ret;
103 unsigned int data;
104
105 ret = regmap_read(dev->regmap, reg, &data);
106 return (u8)data;
107 }
108
109 /*
110 * @description : 向 icm20608 指定寄存器写入指定的值，写一个寄存器
111 * @param – dev : icm20608 设备
112 * @param – reg : 要写的寄存器
113 * @param – data : 要写入的值
114 * @return : 无
115 */
116 static void icm20608_write_onereg(struct icm20608_dev *dev, u8 reg,
u8 value)
117 {
118 regmap_write(dev->regmap, reg, value);
119 }
120
121 /*
122 * @description : ICM20608 内部寄存器初始化函数
123 * @param – spi : 要操作的设备
124 * @return : 无
125 */
126 void icm20608_reginit(struct icm20608_dev *dev)
127 {
128 u8 value = 0;
129 
130 icm20608_write_onereg(dev, ICM20_PWR_MGMT_1, 0x80);
131 mdelay(50);
132 icm20608_write_onereg(dev, ICM20_PWR_MGMT_1, 0x01);
133 mdelay(50);
134
135 value = icm20608_read_onereg(dev, ICM20_WHO_AM_I);
136 printk("ICM20608 ID = %#X\r\n", value);
137
138 icm20608_write_onereg(dev, ICM20_SMPLRT_DIV, 0x00); 
139 icm20608_write_onereg(dev, ICM20_GYRO_CONFIG, 0x18); 
140 icm20608_write_onereg(dev, ICM20_ACCEL_CONFIG, 0x18);
141 icm20608_write_onereg(dev, ICM20_CONFIG, 0x04); 
142 icm20608_write_onereg(dev, ICM20_ACCEL_CONFIG2, 0x04);
143 icm20608_write_onereg(dev, ICM20_PWR_MGMT_2, 0x00); 
144 icm20608_write_onereg(dev, ICM20_LP_MODE_CFG, 0x00); 
145 icm20608_write_onereg(dev, ICM20_INT_ENABLE, 0x01); 
146 }
147
148 /*
149 * @description : 读函数，当读取 sysfs 中的文件的时候最终此函数会执
150 * ：行，此函数里面会从传感器里面读取各种数据，然后上传给应用。
151 * @param - indio_dev : iio_dev
152 * @param - chan : 通道
153 * @param - val : 读取的值，如果是小数值的话，val 是整数部分。
154 * @param - val2 : 读取的值，如果是小数值的话，val2 是小数部分。
155 * @param - mask : 掩码。
156 * @return : 0，成功；其他值，错误
157 */
158 static int icm20608_read_raw(struct iio_dev *indio_dev,
159 struct iio_chan_spec const *chan,
160 int *val, int *val2, long mask)
161 {
162 printk("icm20608_read_raw\r\n");
163 return 0;
164 } 
165
166 /*
167 * @descriptio : 写函数，当向 sysfs 中的文件写数据的时候最终此函数会
168 * ：执行，一般在此函数里面设置传感器，比如量程等。
169 * @param - indio_dev : iio_dev
170 * @param – chan : 通道
171 * @param – val : 应用程序写入的值，如果是小数值的话，val 是整数部分。
172 * @param - val2 : 应用程序写入的值，如果是小数值的话，val2 是小数部分。
173 * @return : 0，成功；其他值，错误
174 */
175 static int icm20608_write_raw(struct iio_dev *indio_dev,
176 struct iio_chan_spec const *chan,
177 int val, int val2, long mask)
178 {
179 printk("icm20608_write_raw\r\n");
180 return 0;
181
182 }
183
184 /*
185 * @description : 用户空间写数据格式，比如我们在用户空间操作 sysfs 来设置传
186 * ：感器的分辨率，如果分辨率带小数，那么这个小数传递到内核空间
187 * : 应该扩大多少倍，此函数就是用来设置这个的。
188 * @param - indio_dev : iio_dev
189 * @param - chan : 通道
190 * @param - mask : 掩码
191 * @return : 0，成功；其他值，错误
192 */
193 static int icm20608_write_raw_get_fmt(struct iio_dev *indio_dev,
194 struct iio_chan_spec const *chan, long mask)
195 {
196 printk("icm20608_write_raw_get_fmt\r\n");
197 return 0;
198
199 }
200
201 /*
202 * iio_info 结构体变量
203 */
204 static const struct iio_info icm20608_info = {
205 .read_raw = icm20608_read_raw,
206 .write_raw = icm20608_write_raw,
207 .write_raw_get_fmt = &icm20608_write_raw_get_fmt,
208 };
209
210 /*
211 * @description : spi 驱动的 probe 函数，当驱动与
212 * 设备匹配以后此函数就会执行
213 * @param – spi : spi 设备
214 * @return : 0,成功；其他值，失败
215 */ 
216 static int icm20608_probe(struct spi_device *spi)
217 {
218 int ret;
219 struct icm20608_dev *dev;
220 struct iio_dev *indio_dev;
221
222 /* 1、申请 iio_dev 内存 */
223 indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*dev));
224 if (!indio_dev)
225 return -ENOMEM;
226
227 /* 2、获取 icm20608_dev 结构体地址 */
228 dev = iio_priv(indio_dev);
229 dev->spi = spi;
230 spi_set_drvdata(spi, indio_dev);
231 mutex_init(&dev->lock);
232
233 /* 3、iio_dev 的其他成员变量 */
234 indio_dev->dev.parent = &spi->dev;
235 indio_dev->info = &icm20608_info;
236 indio_dev->name = ICM20608_NAME; 
237 indio_dev->modes = INDIO_DIRECT_MODE;/* 直接模式，提供 sysfs 接口 */
238 indio_dev->channels = icm20608_channels;
239 indio_dev->num_channels = ARRAY_SIZE(icm20608_channels);
240
241 /* 4、注册 iio_dev */
242 ret = iio_device_register(indio_dev);
243 if (ret < 0) {
244 dev_err(&spi->dev, "iio_device_register failed\n");
245 goto err_iio_register;
246 }
247
248 /* 5、初始化 regmap_config 设置 */
249 dev->regmap_config.reg_bits = 8; /* 寄存器长度 8bit */
250 dev->regmap_config.val_bits = 8; /* 值长度 8bit */
251 dev->regmap_config.read_flag_mask = 0x80; /* 读掩码设置为 0X80 */
252
253 /* 6、初始化 SPI 接口的 regmap */
254 dev->regmap = regmap_init_spi(spi, &dev->regmap_config);
255 if (IS_ERR(dev->regmap)) {
256 ret = PTR_ERR(dev->regmap);
257 goto err_regmap_init;
258 }
259
260 /* 7、初始化 spi_device */
261 spi->mode = SPI_MODE_0; /*MODE0，CPOL=0，CPHA=0*/
262 spi_setup(spi);
263 
264 /* 初始化 ICM20608 内部寄存器 */
265 icm20608_reginit(dev); 
266 return 0;
267
268 err_regmap_init:
269 iio_device_unregister(indio_dev);
270 err_iio_register:
271 return ret;
272 }
273
274 /*
275 * @description : spi 驱动的 remove 函数，移除 spi 驱动的时候此函数会执行
276 * @param - spi : spi 设备
277 * @return : 0，成功;其他负值,失败
278 */
279 static int icm20608_remove(struct spi_device *spi)
280 {
281 struct iio_dev *indio_dev = spi_get_drvdata(spi);
282 struct icm20608_dev *dev;
283 
284 dev = iio_priv(indio_dev);
285
286 /* 1、删除 regmap */
287 regmap_exit(dev->regmap);
288
289 /* 2、注销 IIO */
290 iio_device_unregister(indio_dev);
291 return 0;
292 }
293
294 /* 传统匹配方式 ID 列表 */
295 static const struct spi_device_id icm20608_id[] = {
296 {"alientek,icm20608", 0},
297 {}
298 };
299
300 /* 设备树匹配列表 */
301 static const struct of_device_id icm20608_of_match[] = {
302 { .compatible = "alientek,icm20608" },
303 { /* Sentinel */ }
304 };
305
306 /* SPI 驱动结构体 */
307 static struct spi_driver icm20608_driver = {
308 .probe = icm20608_probe,
309 .remove = icm20608_remove,
310 .driver = {
311 .owner = THIS_MODULE,
312 .name = "icm20608",
313 .of_match_table = icm20608_of_match,
314 },
315 .id_table = icm20608_id,
316 };
317
318 /*
319 * @description : 驱动入口函数
320 * @param : 无
321 * @return : 无
322 */
323 static int __init icm20608_init(void)
324 {
325 return spi_register_driver(&icm20608_driver);
326 }
327
328 /*
329 * @description : 驱动出口函数
330 * @param : 无
331 * @return : 无
332 */
333 static void __exit icm20608_exit(void)
334 {
335 spi_unregister_driver(&icm20608_driver);
336 }
337
338 module_init(icm20608_init);
339 module_exit(icm20608_exit);
340 MODULE_LICENSE("GPL");
341 MODULE_AUTHOR("ALIENTEK");
342 MODULE_INFO(intree, "Y");

示例代码 75.3.1.1 就是在上一章例程的基础上添加 IIO 驱动框架而来的，这里我们重点讲 解一下 IIO 部分。

第 25~41 行，通道宏定义，用于陀螺仪和加速度计，第 28 行 modified 成员变量为 1，所以 channel2 就是通道修饰符，用来指定 X、Y、Z 轴。第 30 行设置相同类型的通道 IIO_CHAN_INFO_SCALE 属性相同，“scale”是比例的意思，在这里就是量程(分辨率)，因为 ICM20608 的陀螺仪和加速度计的量程是可以调整的，量程不同分辨率也就不同。陀螺仪或加 速度计的三个轴也是一起设置的，因此对于陀螺仪或加速度计而言，X、Y、Z 这三个轴的量程 是共享的。

第 31 行，设置每个通道的 IIO_CHAN_INFO_RAW 和 IIO_CHAN_INFO_CALIBBIAS 这两个属性都是独立的，IIO_CHAN_INFO_RAW 表示 ICM20608 每个通道的原始值，这个肯定 是每个通道独立的。IIO_CHAN_INFO_CALIBBIAS 是 ICM20608 每个通道的校准值，这个是 ICM20608 的特性，不是所有的传感器都有校准值，一切都要以实际所使用的传感器为准。

第 34 行，设置扫描数据类型，也就是 ICM20608 原始数据类型，ICM20608 的陀螺仪和加速度计都是 16 位 ADC，因此这里是通用的：为有符号类型、实际位数 16bit，存储位数 16bit，大端模式 (ICM20608 数据寄存器为大端模式)。

第 47~56 行，自定义的扫描索引枚举类型 inv_icm20608_scan，包括陀螺仪、加速度计的 6 个通道，温度计的 1 个通道、以及 1 个 ICM20608 时间戳通道。

第 58~63 行，设备结构体，由于采用了 regmap 和 IIO 框架，因此 ICM20608 的设备结构体 非常简单。

第 68~92 行，ICM20608 通道，这里定义了 7 个通道，分别是：1 个温度通道，3 个陀螺仪 通道(X、Y、Z)，3 个加速度计通道(X、Y、Z)。温度通道有三个属性，IIO_CHAN_INFO_RAW 为温度通道的原始值，IIO_CHAN_INFO_OFFSET 是 ICM20608 温度 offset 值，这个要查阅数 据手册。IIO_CHAN_INFO_SCALE 是 ICM20608 的比例，也就是一个单位的原始值为多少℃， 这个也要查阅 ICM20608 的数据手册。从这里可以看出，想要得到 ICM20608 的具体温度值， 需要三个数据：原始值、offset 值、比例值，也就是应用程序需要能够从 IIO 驱动框架中的到这 三个值，一般是应用程序读取相应的文件，所以这里就要有三个独立的文件分别表示原始值、 offset 值、比例值，这就是三个属性的来源。剩下的陀螺仪和加速度计通道设置使用宏 ICM20608_CHAN 即可，IIO_MOD_X、IIO_MOD_Y 和 IIO_MOD_Z 分别是 X、Y、Z 这三个轴 的修饰符。

第 204~208 行，这部分就是 iio_info，icm20608_read_raw 为读取函数，应用程序读取相应 文件的时候此函数执行，icm20608_write_raw 为写函数，应用程序向相应的文件写数据的时候 此函数执行。icm20608_write_raw_get_fmt 函数用来设置应用程序向驱动写入的数据格式， icm20608_info 就是具体的 iio_info 变量，初始化 iio_dev 的时候需要用到。

第 216 行，icm20608_probe 函数，一般在此函数里面申请 iio_dev、初始化并注册，初始化 regmap、初始化 ICM20608 等。

第 216 行通过 devm_iio_device_alloc 函数申请 iio_dev 以及自定 义设备结构体内存，本章节就是 icm20608_dev。

第 234~239 行，初始化 iio_dev，

第 242 行，调 用 iio_device_register 函数想内核注册 iio_dev。 关于 ICM20608 的 IIO 驱动框架就讲解到这里，接下来就是测试此驱动框架。

3.2.2：驱动框架测试

我们已经搭建好了 ICM20608 的 IIO 驱动框架，通道也已经设置好了，虽然还不能直接读 取到 ICM20608 的原始数据，但是我们可以通过驱动框架来窥探 IIO 在用户空间的存在方式。 编译驱动，得到 icm20608.ko 驱动文件。入如下命令加载 icm20608.ko 这个驱动模块。

depmod //第一次加载驱动的时候需要运行此命令
modprobe icm20608.ko //加载驱动模块

我们在 icm20608_probe 函数里面设置了打印 ICM20608 ID 值，因此如果驱动加载成功， SPI 工作正常的话就会读取 ICM20608 的 ID 值并打印出来，如图 75.3.2.1 所示：

IIO 驱动框架提供了 sysfs 接口，因此加载成功以后我们可以在用户空间访问对应的 sysfs 目录项，进入目录“/sys/bus/iio/devices/”目录里面，此目录下都是 IIO 框架设备，如图 75.3.2.2 所示：

 从图 75.3.2.2 可以看出，此时有两个 IIO 设备“iio:device0”，iio:device0 是 I.MX6ULL 内 部 ADC，iio:device1 才是 ICM20608。大家进入到对应的设备目录就可以看出对应的 IIO 设 备，我们进入图 75.3.2.2 中的“iio:device1”目录，此目录下的内容如图 75.3.2.3 所示：

 从图 75.3.2.3 可以看出，iio:device1 对应 spi2.0 上的设备，也就是 ICM20608，此目录下有 很多文件，比如 in_accel_scale、in_accel_x_calibias、in_accel_x_raw 等，这些就是我们设置的通 道。in_accel_scale 就是加速度计的比例，也就是分辨率(量程)，in_accel_x_calibias 就是加速度 计 X 轴的校准值，in_accel_x_raw 就是加速度计的 X 轴原始值。我们在配置通道的时候，设置 了类型相同的所有通道共用 SCALE，所以这里只有一个 in_accel_scale，而 X、Y、Z 轴的原始 值和校准值每个轴都有一个文件，陀螺仪和温度计同理。

3.2.3：通道文件命名方式

我们来看一下图 75.3.2.3 中这些文件名字组成方式，以 in_accel_x_raw 为例，这是加速度 计的 X 轴原始值，驱动代码中此通道的配置内容展开以后如下(演示代码)：

1 .type = IIO_ANGL_VEL, 
2 .modified = 1, 
3 .channel2 = IIO_MOD_X, 
4 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE),
5 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 
6 BIT(IIO_CHAN_INFO_CALIBBIAS), 
7 .scan_index = INV_ICM20608_SCAN_GYRO_X, 
8 .scan_type = { 
9 .sign = 's', 
10 .realbits = 16, 
11 .storagebits = 16, 
12 .shift = 0, 
13 .endianness = IIO_BE, 
14 }, 

第 5 行设置了此通道有 IIO_CHAN_INFO_RAW 和 IIO_CHAN_INFO_CALIBBIAS 这两个 专属属性，因此才会有图 75.3.2.2 中的 in_accel_x_raw 和 in_accel_x_calibias 这两个文件。 通 道 属 性 的 命 名 ， 也 就 是 图 75.3.2.2 中 文 件 的 命 名 模 式 为 ： [direction]_[type]_[index]_[modifier]_[info_mask]，我们依次来看一下这些命名组织模块： direction：为属性对应的方向，iio_direction 结构体定义了方向，内容如下：

48 static const char * const iio_direction[] = {
49 [0] = "in",
50 [1] = "out",
51 };

可以看出，就有两个方向：in 和 out。

type：也就是配置通道的时候 type 值，type 对应的字符可以参考 iio_chan_type_name_spec， 如下：

53 static const char * const iio_chan_type_name_spec[] = {
54 [IIO_VOLTAGE] = "voltage",
55 [IIO_CURRENT] = "current",
56 [IIO_POWER] = "power",
57 [IIO_ACCEL] = "accel",
58 [IIO_ANGL_VEL] = "anglvel",
59 [IIO_MAGN] = "magn",
......
85 [IIO_GRAVITY] = "gravity",
86 [IIO_POSITIONRELATIVE] = "positionrelative",
87 [IIO_PHASE] = "phase",
88 [IIO_MASSCONCENTRATION] = "massconcentration",
89 };

所以，当通道的 type 设置为 IIO_ACCEL 的时候，对应的名字就是“accel”。 index：索引，如果配置通道的时候设置了 indexed=1，那么就会使用通道的 channel 成员变 量来替代此部分命名。比如，有个 ADC 芯片支持 8 个通道，那么就可以使用 channel 来表示对 应的通道，最终在用户空间呈现的每个通道文件名的 index 部分就是通道号。

modifier：当通道的 modified 成员变量为 1 的时候，channel2 就是修饰符，修饰符对应的 字符串参考结构体 iio_modifier_names，内容如下：

91 static const char * const iio_modifier_names[] = {
92 [IIO_MOD_X] = "x",
93 [IIO_MOD_Y] = "y",
94 [IIO_MOD_Z] = "z",
......
131 [IIO_MOD_PM4] = "pm4",
132 [IIO_MOD_PM10] = "pm10",
133 };

当通道的修饰符设置为 IIO_MOD_X 的时候，对应的名字就是“x”。 info_mask：属性掩码，也就是属性，不同属性对应的字符如下所示：

136 static const char * const iio_chan_info_postfix[] = {
137 [IIO_CHAN_INFO_RAW] = "raw",
138 [IIO_CHAN_INFO_PROCESSED] = "input",
139 [IIO_CHAN_INFO_SCALE] = "scale",
140 [IIO_CHAN_INFO_OFFSET] = "offset",
141 [IIO_CHAN_INFO_CALIBSCALE] = "calibscale",
142 [IIO_CHAN_INFO_CALIBBIAS] = "calibbias",
......
161 [IIO_CHAN_INFO_DEBOUNCE_TIME] = "debounce_time",
162 [IIO_CHAN_INFO_CALIBEMISSIVITY] = "calibemissivity",
163 [IIO_CHAN_INFO_OVERSAMPLING_RATIO] = "oversampling_ratio",
164 };

可以看出，IIO_CHAN_INFO_RAW 属性对应的就是“raw”，IIO_CHAN_INFO_SCALE 属 性对应的是“scale”。 综上所述，in_accel_x_raw 组成形式如图 75.3.2.4 所示

其他文件的命名组成方式类似，大家自行分析即可。

3.2.4：文件读测试

我们可以测试一下对图 75.3.2.3 中的这些文件进行读写操作，看看有什么效果，比如 in_accel_x_raw 文件是 ICM20608 的加速度计 X 轴原始值通道，使用 cat 命令查看此文件内容， 结果如图 75.3.2.5 所示：

从图 75.3.2.5 可以看出，当用户空间读取相应文件的时候，iio_info 下的 read 函数会被调 用，因此关于传感器数据读取的操作都是在此函数中完成的。由于驱动还不完善，大家就先不要测试向指定文件写操作，否则可能会报错，后面再测试写操作。大家也可以读取一下其他文 件，比如陀螺仪的 X 轴文件 in_anglvel_x_raw，结果最终都是调用的 icm20608_read_raw 这个函 数。 接下来的重点就是完善驱动中的 icm20608_read_raw 函数，实现传感器数据的读取操作。

3.3：完善 icm20608_read_raw 函数

应 用 程 序 所 有 的 读 取 操 作 ， 最 终 都 会 汇 总 到 iio_info 的 read 函 数 ， 这 里 就 是 icm20608_read_raw 函数。由于所有的读取操作都会触发 icm20608_read_raw 函数，比如加速度 计、陀螺仪、温度计等，因此我们需要做区分。配置通道的时候设置了 type 值，就可以使用 type 值来区分是陀螺仪、加速度计还是温度计，修改后的 icm20608_read_raw 函数如下：

1 static int icm20608_read_raw(struct iio_dev *indio_dev,
2 struct iio_chan_spec const *chan,
3 int *val, int *val2, long mask)
4 
5 struct icm20608_dev *dev = iio_priv(indio_dev);
6 int ret = 0;
7 unsigned char regdata = 0;
8 printk("icm20608_read_raw\r\n");
9 
10 switch (mask) {
11 case IIO_CHAN_INFO_RAW: /* 读取加速度计、陀螺仪、温度传感器原始值 */
12 printk("read raw data\r\n"); 
13 return ret;
14 case IIO_CHAN_INFO_SCALE:
15 switch (chan->type) {
16 case IIO_ANGL_VEL:
17 printk("read gyro sacle\r\n");
18 return ret;
19 case IIO_ACCEL:
20 printk("read accel sacle\r\n");
21 return 0;
22 case IIO_TEMP: 
23 printk("read temp sacle\r\n");
24 return ret;
25 default:
26 return -EINVAL;
27 }
28 case IIO_CHAN_INFO_OFFSET: /* ICM20608 温度传感器 offset 值 */
29 switch (chan->type) {
30 case IIO_TEMP:
31 printk("read temp offset\r\n");
32 return ret;
33 default:
34 return -EINVAL;
35 }
36 return ret;
37 case IIO_CHAN_INFO_CALIBBIAS: /* ICM20608 加速度计和陀螺仪校准值 */
38 switch (chan->type) {
39 case IIO_ANGL_VEL: /* 陀螺仪的校准值 */
40 printk("read gyro calibbias\r\n");
41 return ret;
42 case IIO_ACCEL: /* 加速度计的校准值 */
43 printk("read accel calibbias\r\n");
44 return ret;
45 default:
46 return -EINVAL;
47 }
48 default:
49 return ret -EINVAL;
50 } 

示例代码 75.3.3.1 给出了很多分支，这些分支对应不同的文件读操作。比如我们读取 in_accel_scale 这个文件，这个是加速度计的比例文件，对应的就是第 19 行这个分支，结果如图 75.3.3.1 所示：

从图 75.3.3.1 可以看出，输出了“read accelscale”这行字符串，这行字符串正好是第 19 行 的分支。我们就可以在这个分支里面读取 ICM20608 的加速度计比例值，也就是量程。其他文 件也一样，最终都会对应到相应的分支里面，我们只需要在相应的分支里面做具体的操作就行 了。剩下的操作就是读取 ICM20608 的内部寄存器数据，最终修改好的 icm20608_read_raw 函 数和其他一些配套函数如下：

22 #define ICM20608_TEMP_OFFSET 0
23 #define ICM20608_TEMP_SCALE 326800000
......
65 /* icm20608 陀螺仪分辨率，对应 250、500、1000、2000，计算方法：
66 * 以正负 250 度量程为例，500/2^16=0.007629，扩大 1000000 倍，就是 7629
67 */
68 static const int gyro_scale_icm20608[] = {7629, 15258,
30517, 61035};
69 
70 /* icm20608 加速度计分辨率，对应 2、4、8、16 计算方法：
71 * 以正负 2g 量程为例，4/2^16=0.000061035，扩大 1000000000 倍，就是 61035
72 */
73 static const int accel_scale_icm20608[] = {61035, 122070,
 244140, 488281};
74 
......
155
156 /*
157 * @description : 读取 ICM20608 传感器数据，可以用于陀螺仪、加速度计、温度
158 * @param – dev : icm20608 设备
159 * @param - reg : 要读取的通道寄存器首地址。
160 * @param – anix : 需要读取的通道，比如 X，Y，Z。
161 * @param - *val : 保存读取到的值。
162 * @return : 0，成功；其他值，错误
163 */
164 static int icm20608_sensor_show(struct icm20608_dev *dev, int reg,
165 int axis, int *val)
166 {
167 int ind, result;
168 __be16 d;
169
170 ind = (axis - IIO_MOD_X) * 2;
171 result = regmap_bulk_read(dev->regmap, reg + ind, (u8 *)&d, 2);
172 if (result)
173 return -EINVAL;
174 *val = (short)be16_to_cpup(&d);
175
176 return IIO_VAL_INT;
177 }
178
179 /*
180 * @description : 读取 ICM20608 陀螺仪、加速度计、温度通道值
181 * @param - indio_dev : iio 设备
182 * @param - chan : 通道。
183 * @param - val : 保存读取到的通道值。
184 * @return : 0，成功；其他值，错误
185 */
186 static int icm20608_read_channel_data(struct iio_dev *indio_dev,
187 struct iio_chan_spec const *chan,
188 int *val)
189 {
190 struct icm20608_dev *dev = iio_priv(indio_dev);
191 int ret = 0;
192
193 switch (chan->type) {
194 case IIO_ANGL_VEL: /* 读取陀螺仪数据 */
195 ret = icm20608_sensor_show(dev, ICM20_GYRO_XOUT_H,
chan->channel2, val); /* channel2 为 X、Y、Z 轴 */
196 break;
197 case IIO_ACCEL: /* 读取加速度计数据 */
198 ret = icm20608_sensor_show(dev, ICM20_ACCEL_XOUT_H,
chan->channel2, val); /* channel2 为 X、Y、Z 轴 */
199 break;
200 case IIO_TEMP: /* 读取温度 */
201 ret = icm20608_sensor_show(dev, ICM20_TEMP_OUT_H,
IIO_MOD_X, val); 
202 break;
203 default:
204 ret = -EINVAL;
205 break;
206 }
207 return ret;
208 }
209
210 /*
211 * @description : 读函数，当读取 sysfs 中的文件的时候最终此函数会执行，此函
212 * ：数里面会从传感器里面读取各种数据，然后上传给应用。
213 * @param - indio_dev : iio_dev
214 * @param - chan : 通道
215 * @param - val : 读取的值，如果是小数值的话，val 是整数部分。
216 * @param - val2 : 读取的值，如果是小数值的话，val2 是小数部分。
217 * @param - mask : 掩码。
218 * @return : 0，成功；其他值，错误
219 */
220 static int icm20608_read_raw(struct iio_dev *indio_dev,
221 struct iio_chan_spec const *chan,
222 int *val, int *val2, long mask)
223 {
224 struct icm20608_dev *dev = iio_priv(indio_dev);
225 int ret = 0;
226 unsigned char regdata = 0;
227
228 switch (mask) {
229 case IIO_CHAN_INFO_RAW: /* 读取 ICM20608 加速度计、陀螺仪、
温度传感器原始值 */
230 iio_device_claim_direct_mode(indio_dev);/* 保持 direct 模式 */
231 mutex_lock(&dev->lock); /* 上锁 */
232 ret = icm20608_read_channel_data(indio_dev, chan, val); 
233 mutex_unlock(&dev->lock); /* 释放锁 */
234 iio_device_release_direct_mode(indio_dev);
235 return ret;
236 case IIO_CHAN_INFO_SCALE:
237 switch (chan->type) {
238 case IIO_ANGL_VEL:
239 mutex_lock(&dev->lock);
240 regdata = (icm20608_read_onereg(dev, ICM20_GYRO_CONFIG)
& 0X18) >> 3;
241 *val = 0;
242 *val2 = gyro_scale_icm20608[regdata];
243 mutex_unlock(&dev->lock);
244 return IIO_VAL_INT_PLUS_MICRO; /* 值为 val+val2/1000000 */
245 case IIO_ACCEL:
246 mutex_lock(&dev->lock);
247 regdata = (icm20608_read_onereg(dev, ICM20_ACCEL_CONFIG)
& 0X18) >> 3;
248 *val = 0;
249 *val2 = accel_scale_icm20608[regdata];;
250 mutex_unlock(&dev->lock);
251 return IIO_VAL_INT_PLUS_NANO;/* 值为 val+val2/1000000000 */
252 case IIO_TEMP: 
253 *val = ICM20608_TEMP_SCALE/ 1000000;
254 *val2 = ICM20608_TEMP_SCALE % 1000000;
255 return IIO_VAL_INT_PLUS_MICRO; /* 值为 val+val2/1000000 */
256 default:
257 return -EINVAL;
258 }
259 return ret;
260 case IIO_CHAN_INFO_OFFSET: /* ICM20608 温度传感器 offset 值 */
261 switch (chan->type) {
262 case IIO_TEMP:
263 *val = ICM20608_TEMP_OFFSET;
264 return IIO_VAL_INT;
265 default:
266 return -EINVAL;
267 }
268 return ret;
269 case IIO_CHAN_INFO_CALIBBIAS: /* ICM20608 加速度计和陀螺仪校准值 */
270 switch (chan->type) {
271 case IIO_ANGL_VEL: /* 陀螺仪的校准值*/
272 mutex_lock(&dev->lock);
273 ret = icm20608_sensor_show(dev, ICM20_XG_OFFS_USRH,
chan->channel2, val);
274 mutex_unlock(&dev->lock);
275 return ret;
276 case IIO_ACCEL: /* 加速度计的校准值*/
277 mutex_lock(&dev->lock);
278 ret = icm20608_sensor_show(dev, ICM20_XA_OFFSET_H,
chan->channel2, val);
279 mutex_unlock(&dev->lock);
280 return ret;
281 default:
282 return -EINVAL;
283 }
284 
285 default:
286 return ret -EINVAL;
287 }
288 } 

第 68 行，gyro_scale_icm20608 是 ICM20608 的陀螺仪比例，也就是陀螺仪不同量程对应的 分辨率。ICM20608 陀螺仪为 16bit，可选的量程有±250、±500、±1000 和±2000°/s。以± 250 这个量程为例，每个数值对应的度数就是 500/2^10≈0.007629°/s。同理，±500 量程对应 的度数为 0.015258，±1000 量程对应的度数为 0.030517，±2000 量程为 0.061035。假设现在设 置量程为±2000，读取到的原始值为 12540，那么对应的度数就是 12540*0.061035≈765.37°/s。 注意，这里扩大了 1000000 倍

第 73 行，accel_scale_icm20608 是 ICM20608 的加速度计比例，也就是加速度计不同量程 对应的分辨率，计算方法和陀螺仪一样。这里扩大了 1000000000 倍。

第 164~177 行，icm20608_sensor_show 函数用于读取加速度计、陀螺仪、温度的原始数据 的。

第 186~08 行，icm20608_read_channel_data 函数用于读取指定通道的数据，根据 type 类型 的不同，给 icm20608_sensor_show 函数传递不同的参数，读取陀螺仪、加速度计或温度数据。

第 220~288 行，修改完善的 icm20608_read_raw 函数，我们就以读取陀螺仪、加速度计或 温度原始数据为例，当应用程序读取这几个通道的原始数据的时候第 229 行的分支会执行。

第 232 行直接调用 icm20608_read_channel_data 函数来根据通道的 type 值来读取 ICM20608 相应 的寄存器。其他分支内容大同小异，这些就是 ICM20608 寄存器读取内容了，这里就不在多讲。

修改完成以后重新编译驱动文件，然后加载新的驱动，测试是否可以正常读取到相应的内 容。我们读取一下 in_accel_scale 这个文件，这是加速度计的分辨率，我们默认设置了加速度计 量程为±16g，因此分辨率为 0.000488281。结果如图 75.3.3.1 所示：

从图 75.3.3.1 可以看出，此时 in_accel_scale 为 0.000488281，是正确的。这时候有朋友可能 会疑问，在示例代码 75.3.3.2 中，我们设置加速度计±16g 的分辨率为 4882了 1000000000 倍，为啥这里读出来的是 0.000488281 这个原始值？

大家注意看示例代码 75.3.3.2 中第 245~251 行所在的分支，这部分是读取加速度计的分辨率，读取完成以后在第 251 行返回 IIO_VAL_INT_PLUS_NANO 这个值，这里就是告诉用户空间，小数部分(val2)扩大了1000000000 倍 ， 因 此 用 户 空 间 得 到 分 辨 率 以 后 会 除 以 1000000000 ，得到真实 的 分 辨 率 ， 488281/1000000000=0.000488281，所以图 75.3.3.1 中得到的值就是 0.000488281。 我们在读取一下 in_accel_z_raw 这个文件，这个文件是加速度计的 Z 轴原始值，静态情况 下 Z 轴应该是 1g 的重力加速度计，我们可以读取 in_accel_z_raw 这个文件的值，然后在结合上 面读取到的加速度计分辨率，计算一下对应的 Z 轴重力值，看看是不是 1g 左右。81，也就是是扩大

2074×0.000488281≈1.01g，此时 Z 轴重力为 1g，结果正确。

3.4：完善 icm20608_write_raw 函数

最后我们完善icm20608_write_raw函数，用户空间向驱动写数据的时候icm20608_write_raw 函数会执行。我们可以在用户空间设置陀螺仪、加速度计的量程、校准值等，这时候就需要向 驱动写入数据。本章我们简单一点，就只实现设置陀螺仪和加速度计的量程，至于其他的设置 项大家可以自行实现，修改后的 icm20608_write_raw 函数和其他相关内容如下：

180 /*
181 * @description : 设置 ICM20608 传感器，可以用于陀螺仪、加速度计设置
182 * @param - dev : icm20608 设备
183 * @param - reg : 要设置的通道寄存器首地址。
184 * @param – anix : 要设置的通道，比如 X，Y，Z。
185 * @param - val : 要设置的值。
186 * @return : 0，成功；其他值，错误
187 */
188 static int icm20608_sensor_set(struct icm20608_dev *dev, int reg,
189 int axis, int val)
190 {
191 int ind, result;
192 __be16 d = cpu_to_be16(val);
193
194 ind = (axis - IIO_MOD_X) * 2;
195 result = regmap_bulk_write(dev->regmap, reg + ind, (u8 *)&d, 2);
196 if (result)
197 return -EINVAL;
198
199 return 0;
200 }
......
256 /*
257 * @description : 设置 ICM20608 的陀螺仪计量程(分辨率)
258 * @param - dev : icm20608 设备
259 * @param - val : 量程(分辨率值)。
260 * @return : 0，成功；其他值，错误
261 */
262 static int icm20608_write_gyro_scale(struct icm20608_dev *dev,
int val)
263 {
264 int result, i;
265 u8 d;
266
267 for (i = 0; i < ARRAY_SIZE(gyro_scale_icm20608); ++i) {
268 if (gyro_scale_icm20608[i] == val) {
269 d = (i << 3);
270 result = regmap_write(dev->regmap, ICM20_GYRO_CONFIG, d);
271 if (result)
272 return result;
273 return 0;
274 }
275 }
276 return -EINVAL;
277 }
278
279 /*
280 * @description : 设置 ICM20608 的加速度计量程(分辨率)
281 * @param - dev : icm20608 设备
282 * @param - val : 量程(分辨率值)。
283 * @return : 0，成功；其他值，错误
284 */
285 static int icm20608_write_accel_scale(struct icm20608_dev *dev,
int val)
286 {
287 int result, i;
288 u8 d;
289
290 for (i = 0; i < ARRAY_SIZE(accel_scale_icm20608); ++i) {
291 if (accel_scale_icm20608[i] == val) {
292 d = (i << 3);
293 result = regmap_write(dev->regmap,
ICM20_ACCEL_CONFIG, d);
294 if (result)
295 return result;
296 return 0;
297 }
298 }
299 return -EINVAL;
300 }
......
382 /*
383 * @description : 写函数，当向 sysfs 中的文件写数据的时候最终此函数会执行，
384 * ：一般在此函数里面设置传感器，比如量程等。
385 * @param - indio_dev : iio_dev
386 * @param - chan : 通道
387 * @param - val : 应用程序写入的值，如果是小数值的话，val 是整数部分。
388 * @param - val2 : 应用程序写入的值，如果是小数值的话，val2 是小数部分。
389 * @return : 0，成功；其他值，错误
390 */
391 static int icm20608_write_raw(struct iio_dev *indio_dev,
392 struct iio_chan_spec const *chan,
393 int val, int val2, long mask)
394 {
395 struct icm20608_dev *dev = iio_priv(indio_dev);
396 int ret = 0;
397
398 iio_device_claim_direct_mode(indio_dev); 
399 switch (mask) {
400 case IIO_CHAN_INFO_SCALE: /* 设置陀螺仪和加速度计的分辨率 */
401 switch (chan->type) {
402 case IIO_ANGL_VEL: /* 设置陀螺仪 */
403 mutex_lock(&dev->lock);
404 ret = icm20608_write_gyro_scale(dev, val2);
405 mutex_unlock(&dev->lock);
406 break;
407 case IIO_ACCEL: /* 设置加速度计 */
408 mutex_lock(&dev->lock);
409 ret = icm20608_write_accel_scale(dev, val2);
410 mutex_unlock(&dev->lock);
411 break;
412 default:
413 ret = -EINVAL;
414 break;
415 }
416 break;
417 case IIO_CHAN_INFO_CALIBBIAS: /* 设置陀螺仪和加速度计的校准值 */
418 switch (chan->type) {
419 case IIO_ANGL_VEL: /* 设置陀螺仪校准值 */
420 mutex_lock(&dev->lock);
421 ret = icm20608_sensor_set(dev, ICM20_XG_OFFS_USRH,
422 chan->channel2, val);
423 mutex_unlock(&dev->lock);
424 break;
425 case IIO_ACCEL: /* 加速度计校准值 */
426 mutex_lock(&dev->lock);
427 ret = icm20608_sensor_set(dev, ICM20_XA_OFFSET_H,
428 chan->channel2, val);
429 mutex_unlock(&dev->lock);
430 break;
431 default:
432 ret = -EINVAL;
433 break;
434 }
435 break;
436 default:
437 ret = -EINVAL;
438 break;
439 }
440
441 iio_device_release_direct_mode(indio_dev); 
442 return ret;
443 }
444
445 /*
446 * @description : 用户空间写数据格式，比如我们在用户空间操作 sysfs 来设置传
447 * ：感器的分辨率，如果分辨率带小数，那么这个小数传递到内核空间
448 * : 应该扩大多少倍，此函数就是用来设置这个的。
449 * @param - indio_dev : iio_dev
450 * @param - chan : 通道
451 * @param - mask : 掩码
452 * @return : 0，成功；其他值，错误
453 */
454 static int icm20608_write_raw_get_fmt(struct iio_dev *indio_dev,
455 struct iio_chan_spec const *chan, long mask)
456 {
457 switch (mask) {
458 case IIO_CHAN_INFO_SCALE:
459 switch (chan->type) {
460 case IIO_ANGL_VEL: 
461 return IIO_VAL_INT_PLUS_MICRO;
462 default: 
463 return IIO_VAL_INT_PLUS_NANO;
464 }
465 default:
466 return IIO_VAL_INT_PLUS_MICRO;
467 }
468 return -EINVAL;
469 }
470
471 /*
472 * iio_info 结构体变量
473 */
474 static const struct iio_info icm20608_info = {
475 .read_raw = icm20608_read_raw,
476 .write_raw = icm20608_write_raw,
477 .write_raw_get_fmt = &icm20608_write_raw_get_fmt, 
478 };

第 188~200 行，icm20608_sensor_set 函数用于设置指定通道，也就是向 ICM20608 的指定 寄存器写入数据，用于设置陀螺仪和加速度计的校准值。

第 262~277 行，icm20608_write_gyro_scale 函数用于设置 ICM20608 陀螺仪量程。

第 285~300 行，icm20608_write_accel_scale 函数用于设置 ICM20608 加速度计量程

第 391~443 行，icm20608_write_raw 函数，也就是 iio_info 的 write 函数，用户空间向驱动 程序写入数据以后此函数就会执行，这里我们用来配置 ICM20608 的陀螺仪和加速度量程和校 准值。

第 400 行的 IIO_CHAN_INFO_SCALE 表示此分支是设置比例(量程的)，

第 404 行设置陀 螺仪的量程，

第 409 行设置加速度计的量程。

第 417 行的 IIO_CHAN_INFO_CALIBBIAS 表示 此分支是设置校准值的，

第 421 行设置陀螺仪各轴校准值，

第 427 行设置加速度计各轴校准值。

第 454~469 行，icm20608_write_raw_get_fmt 函数，也就是 iio_info 的 write_raw_get_fmt 函 数。此函数用来指定用户空间写入的数据格式，

第 458 行的 IIO_CHAN_INFO_SCALE 分支表 示要操作的是比例，也就是用户空间要设置陀螺仪和加速度计的量程。

第 460 行表示如果写入 的是陀螺仪比例，那么小数部分就要扩大 1000000 倍。

第 463 行表示如果是其他的就扩 1000000000 倍，比如加速度计。比如我们在用户空间要设置加速度计量程为±4g，只需要向 in_accel_scale 写 入 0.000122070 ， 那 么 最 终 传 入 到 驱 动 里 面 的 就 是 0.000122070*1000000000=122070。 ICM20608 的 IIO 驱动就已经编写完成了，接下来就是编写测试 APP。

4：测试应用程序编写

4.1：linux 文件流读取

前面我们都是直接使用 cat 命令读取对应文件的内容，如果要连续不断的读取传感器数据 就不能用 cat 命令了，我们需要编写对应的 APP 软件，在编写 APP 之前我们先了解一下所要用 到的 API 函数。 首先我们要知道，前面使用 cat 命令读取到的文件内容字符串，虽然看起来像是数字。比 如我们使用 cat 命令读取到的 in_accel_scale 如图 75.4.1 所示：

 图 75.4.1 中 in_accel_scale 文件内容为 0.000488281，但是这里的 0.000488281 是字符串， 并不是具体的数字，所以我们需要将其转换为对应的数字。另外 in_accel_scale 是流文件，也叫 做标准文件 I/O 流，因此打开、读写操作要使用文件流操作函数。

4.1.1：打开文件流

打开文件流使用 fopen 函数，函数原型如下：

FILE *fopen(const char *pathname, const char *mode)

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

pathname：需要打开的文件流路径。

mode：打开方式，可选的打开方式如表 75.4.1 所示：

 返回值：NULL，打开错误；其他值，打开成功的文件流指针，为 FILE 类型。

4.1.2：关闭文件流

关闭文件流使用函数 fclose，函数原型如下：

int fclose(FILE *stream)

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

stream：要关闭的文件流指针。

返回值：0，关闭成功；EOF，关闭错误。

4.1.3：读取文件流

要读取文件流使用 fread 函数，函数原型如下：

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)

fread 函数用于从给定的输入流中读取最多 nmemb 个对象到数组 ptr 中，函数参数和返回值 含义如下：

ptr：要读取的数组中首个对象的指针。

size：每个对象的大小。

nmemb：要读取的对象个数。

stream：要读取的文件流。

返回值：返回读取成功的对象个数，如果出现错误或到文件末尾，那么返回一个短计数值 (或者 0)。

4.1.4：写文件流

要向文件流写入数据，使用 fwrite 函数，函数原型如下

size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream);

fwrite 函数用于向给定的文件流中写入最多 nmemb 个对象，函数参数和返回值含义如下：

ptr：要写入的数组中首个对象的指针。

size：每个对象的大小。

nmemb：要写入的对象个数。

stream：要写入的文件流。

返回值：返回成功写入的对象个数，如果出现错误或到文件末尾，那么返回一个短计数值 (或者 0)。

4.1.5：格式化输入文件流

fscanf 函数用于从一个文件流中格式化读取数据，fscanf 函数在遇到空格和换行符的时候 就会结束。前面我们说了 IIO 框架下的 sysfs 文件内容都是字符串，比如 in_accel_scale 文件内 容为“0.000488281”，这是一串字符串，并不是具体的数字，因此我们在读取的时候就需要使 用字符串读取格式。在这里就可以使用 fscanf 函数来格式化读取文件内容，函数原型如下：

int fscanf(FILE *stream, const char *format, ,[argument...])

fscanf 用法和 scanf 类似，函数参数和返回值含义如下： stream：要操作的文件流。 format：格式。 argument：保存读取到的数据。 返回值：成功读取到的数据个数，如果读到文件末尾或者读取错误就返回 EOF。

4.2：编写测试 APP

新建名为 icm20608App.c 的文件，输入如下内容：

/***************************************************************
Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
文件名 : icm20608.c
作者 : 左忠凯
版本 : V1.0
描述 : icm20608 设备 iio 框架测试程序。
其他 : 无
使用方法 ：./icm20608App 
论坛 : www.openedv.com
日志 : 初版 V1.0 2021/8/17 左忠凯创建
***************************************************************/
1 #include "stdio.h"
2 #include "unistd.h"
3 #include "sys/types.h"
4 #include "sys/stat.h"
5 #include "sys/ioctl.h"
6 #include "fcntl.h"
7 #include "stdlib.h"
8 #include "string.h"
9 #include <poll.h>
10 #include <sys/select.h>
11 #include <sys/time.h>
12 #include <signal.h>
13 #include <fcntl.h>
14 #include <errno.h>
15 
16 /* 字符串转数字，将浮点小数字符串转换为浮点数数值 */
17 #define SENSOR_FLOAT_DATA_GET(ret, index, str, member)\
18 ret = file_data_read(file_path[index], str);\
19 dev->member = atof(str);\
20 
21 /* 字符串转数字，将整数字符串转换为整数数值 */
22 #define SENSOR_INT_DATA_GET(ret, index, str, member)\
23 ret = file_data_read(file_path[index], str);\
24 dev->member = atoi(str);\
25 
26 /* icm20608 iio 框架对应的文件路径 */
27 static char *file_path[] = {
28 "/sys/bus/iio/devices/iio:device1/in_accel_scale",
29 "/sys/bus/iio/devices/iio:device1/in_accel_x_calibbias",
30 "/sys/bus/iio/devices/iio:device1/in_accel_x_raw",
31 "/sys/bus/iio/devices/iio:device1/in_accel_y_calibbias",
32 "/sys/bus/iio/devices/iio:device1/in_accel_y_raw",
33 "/sys/bus/iio/devices/iio:device1/in_accel_z_calibbias",
34 "/sys/bus/iio/devices/iio:device1/in_accel_z_raw",
35 "/sys/bus/iio/devices/iio:device1/in_anglvel_scale",
36 "/sys/bus/iio/devices/iio:device1/in_anglvel_x_calibbias",
37 "/sys/bus/iio/devices/iio:device1/in_anglvel_x_raw",
38 "/sys/bus/iio/devices/iio:device1/in_anglvel_y_calibbias",
39 "/sys/bus/iio/devices/iio:device1/in_anglvel_y_raw",
40 "/sys/bus/iio/devices/iio:device1/in_anglvel_z_calibbias",
41 "/sys/bus/iio/devices/iio:device1/in_anglvel_z_raw",
42 "/sys/bus/iio/devices/iio:device1/in_temp_offset",
43 "/sys/bus/iio/devices/iio:device1/in_temp_raw",
44 "/sys/bus/iio/devices/iio:device1/in_temp_scale",
45 };
46 
47 /* 文件路径索引，要和 file_path 里面的文件顺序对应 */
48 enum path_index {
49 IN_ACCEL_SCALE = 0,
50 IN_ACCEL_X_CALIBBIAS,
51 IN_ACCEL_X_RAW,
52 IN_ACCEL_Y_CALIBBIAS,
53 IN_ACCEL_Y_RAW,
54 IN_ACCEL_Z_CALIBBIAS,
55 IN_ACCEL_Z_RAW,
56 IN_ANGLVEL_SCALE,
57 IN_ANGLVEL_X_CALIBBIAS,
58 IN_ANGLVEL_X_RAW,
59 IN_ANGLVEL_Y_CALIBBIAS,
60 IN_ANGLVEL_Y_RAW,
61 IN_ANGLVEL_Z_CALIBBIAS,
62 IN_ANGLVEL_Z_RAW,
63 IN_TEMP_OFFSET,
64 IN_TEMP_RAW,
65 IN_TEMP_SCALE,
66 };
67 
68 /*
69 * icm20608 数据设备结构体
70 */
71 struct icm20608_dev{
72 int accel_x_calibbias, accel_y_calibbias, accel_z_calibbias;
73 int accel_x_raw, accel_y_raw, accel_z_raw;
74 
75 int gyro_x_calibbias, gyro_y_calibbias, gyro_z_calibbias;
76 int gyro_x_raw, gyro_y_raw, gyro_z_raw;
77 
78 int temp_offset, temp_raw;
79 
80 float accel_scale, gyro_scale, temp_scale;
81 
82 float gyro_x_act, gyro_y_act, gyro_z_act;
83 float accel_x_act, accel_y_act, accel_z_act;
84 float temp_act;
85 };
86 
87 struct icm20608_dev icm20608;
88 
89 /*
90 * @description : 读取指定文件内容
91 * @param – filename : 要读取的文件路径
92 * @param - str : 读取到的文件字符串
93 * @return : 0 成功;其他 失败
94 */
95 static int file_data_read(char *filename, char *str)
96 {
97 int ret = 0;
98 FILE *data_stream;
99 
100 data_stream = fopen(filename, "r"); /* 只读打开 */
101 if(data_stream == NULL) {
102 printf("can't open file %s\r\n", filename);
103 return -1;
104 }
105
106 ret = fscanf(data_stream, "%s", str);
107 if(!ret) {
108 printf("file read error!\r\n");
109 } else if(ret == EOF) {
110 /* 读到文件末尾的话将文件指针重新调整到文件头 */
111 fseek(data_stream, 0, SEEK_SET); 
112 }
113 fclose(data_stream); /* 关闭文件 */ 
114 return 0;
115 }
116
117 /*
118 * @description : 获取 ICM20608 数据
119 * @param - dev : 设备结构体
120 * @return : 0 成功;其他 失败
121 */
122 static int sensor_read(struct icm20608_dev *dev)
123 {
124 int ret = 0;
125 char str[50];
126
127 /* 1、获取陀螺仪原始数据 */
128 SENSOR_FLOAT_DATA_GET(ret, IN_ANGLVEL_SCALE, str, gyro_scale);
129 SENSOR_INT_DATA_GET(ret, IN_ANGLVEL_X_RAW, str, gyro_x_raw);
130 SENSOR_INT_DATA_GET(ret, IN_ANGLVEL_Y_RAW, str, gyro_y_raw);
131 SENSOR_INT_DATA_GET(ret, IN_ANGLVEL_Z_RAW, str, gyro_z_raw);
132
133 /* 2、获取加速度计原始数据 */
134 SENSOR_FLOAT_DATA_GET(ret, IN_ACCEL_SCALE, str, accel_scale);
135 SENSOR_INT_DATA_GET(ret, IN_ACCEL_X_RAW, str, accel_x_raw);
136 SENSOR_INT_DATA_GET(ret, IN_ACCEL_Y_RAW, str, accel_y_raw);
137 SENSOR_INT_DATA_GET(ret, IN_ACCEL_Z_RAW, str, accel_z_raw);
138
139 /* 3、获取温度值 */
140 SENSOR_FLOAT_DATA_GET(ret, IN_TEMP_SCALE, str, temp_scale);
141 SENSOR_INT_DATA_GET(ret, IN_TEMP_OFFSET, str, temp_offset);
142 SENSOR_INT_DATA_GET(ret, IN_TEMP_RAW, str, temp_raw);
143
144 /* 3、转换为实际数值 */
145 dev->accel_x_act = dev->accel_x_raw * dev->accel_scale;
146 dev->accel_y_act = dev->accel_y_raw * dev->accel_scale;
147 dev->accel_z_act = dev->accel_z_raw * dev->accel_scale;
148
149 dev->gyro_x_act = dev->gyro_x_raw * dev->gyro_scale;
150 dev->gyro_y_act = dev->gyro_y_raw * dev->gyro_scale;
151 dev->gyro_z_act = dev->gyro_z_raw * dev->gyro_scale;
152
153 dev->temp_act = ((dev->temp_raw - dev->temp_offset) /
dev->temp_scale) + 25;
154 return ret;
155 }
156
157 /*
158 * @description : main 主程序
159 * @param – argc : argv 数组元素个数
160 * @param – argv : 具体参数
161 * @return : 0 成功;其他 失败
162 */
163 int main(int argc, char *argv[])
164 {
165 int ret = 0;
166
167 if (argc != 1) {
168 printf("Error Usage!\r\n");
169 return -1;
170 }
171
172 while (1) {
173 ret = sensor_read(&icm20608);
174 if(ret == 0) { /* 数据读取成功 */
175 printf("\r\n 原始值:\r\n");
176 printf("gx = %d, gy = %d, gz = %d\r\n",
icm20608.gyro_x_raw,
icm20608.gyro_y_raw,
icm20608.gyro_z_raw);
177 printf("ax = %d, ay = %d, az = %d\r\n",
icm20608.accel_x_raw,
icm20608.accel_y_raw,
icm20608.accel_z_raw);
178 printf("temp = %d\r\n", icm20608.temp_raw);
179 printf("实际值:");
180 printf("act gx = %.2f°/S, act gy = %.2f°/S, 
act gz = %.2f°/S\r\n", icm20608.gyro_x_act,
icm20608.gyro_y_act, icm20608.gyro_z_act);
181 printf("act ax = %.2fg, act ay = %.2fg, 
act az = %.2fg\r\n", icm20608.accel_x_act,
icm20608.accel_y_act,
icm20608.accel_z_act);
182 printf("act temp = %.2f°C\r\n", icm20608.temp_act);
183 }
184 usleep(100000); /*100ms */
185 }
186
187 return 0;
188 }

第 17~19 行，SENSOR_FLOAT_DATA_GET 宏用读取指定路径的文件内容，然后将读到 的浮点型字符串数据转换为具体的浮点数据。

第 19 行使用 atof 函数将浮点字符串转换为具体 的浮点数值。

第 22~24 行，SENSOR_INT_DATA_GET 宏用于读取指定路径的文件内容，将读取到的整 数型字符串数据转换为具体的整数值，

第 24 行使用 atoi 函数将整数字符串转换为具体的整数 数值。 atof 和 atoi 这两个函数是标准的 C 库函数，并不需要我们自己编写，添加“stdlib.h”头文 件就可以直接调用。这两个函数都只有一个参数，就是要转换的字符串。返回值就是转换成功 以后字符串对应的数值。

第 27~45 行，需要操作的文件路径。

第 48~66 行，文件路径索引，顺序要和 file_path 里面的文件路径对应。

第 71~85 行，icm20608_dev 结构体为自定义设备结构体，

用于保存 ICM20608 传感器数 据。

第 95~115 行，file_data_read 函数用于读取指定文件，第一个参数 filename 是要读取的文 件路径。第二个参数 str 为读取到的文件内容，为字符串类型，因为本章例程所读取的文件内 容都是字符串。

第 100 行调用 fopen 函数打开指定的文件流，

第 106 行调用 fscanf 函数进行格 式化读取，也就是按照字符串方式读取文件，文件内容保存到 str 参数里面。当读取到文件末 尾的时候，

第 111 行调用 fseek 函数将读取指针调整到文件头，以备下次重新读取。

第 113 行 调用 fclose 函数关闭对应的文件流。

第 122~155 行，sensor_read 函数用于读取 ICM20608 传感器数据，包括陀螺仪、加速度和 温度计的原始值，还有加速度计和陀螺仪的分辨率等，最后将获取到的原始值转换为具体的数 值。

第 163~188 行，main 函数，在 while 循环中调用 sensor_read 函数读取 ICM20608 数据， 并将读到的数据打印出来。

4.3：运行测试

输入如下命令编译测试 icm20608App.c 这个测试程序：

arm-linux-gnueabihf-gcc icm20608App.c -o icm20608App

编译成功以后就会生成 icm20608App 这个应用程序。 将 icm20608.ko 和 icm20608App 这两个文件拷贝到 rootfs/lib/modules/4.1.15 目录中，重启 开发板，进入到目录 lib/modules/4.1.15 中，输入如下命令加载 icm20608.ko 驱动模块：

depmod //第一次加载驱动的时候需要运行此命令
modprobe icm20608.ko //加载驱动

驱动加载成功以后使用如下命令来测试：

/icm20608App

如果驱动和 APP 工作正常的话就会不断的打印出 ICM20608 数据，包括陀螺仪和加速度计 的原始数据和转换后的实际数值、温度等，如图 75.4.3.1 所示：

另外，我们也编写 AP3216C 这个光传感器的对应的 IIO 驱动，但是由于 AP3216C 没有数 据准备就绪中断，因此 AP3216C 的 IIO 驱动没有实现触发缓冲功能。AP3216C 的 IIO 驱动程序 已经放到了开发板光盘中，路径为：开发板光盘->01、程序源码->02、Linux 驱动例程->27_iio->iic。