Linux IIO驱动

工业场合里面也有大量的模拟量和数字量之间的转换，也就是我们常说的 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

iio_dev 结构体

第 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 结构体类型，内容如下：

iio_dev 申请与释放

iio_dev 注册与注销

1.2 iio_info

iio_dev 有个成员变量：info，为 iio_info 结构体指针变量，这个是我们在编写 IIO 驱动的时候需要着重去实现的，因为用户空间对设备的具体操作最终都会反映到 iio_info 里面。iio_info结构体定义在 include/linux/iio/iio.h 中，结构体定义如下(有省略)：
第 355 行，attrs 是通用的设备属性。
第 357 和 370 行，分别为 read_raw 和 write_raw 函数，这两个函数就是最终读写设备内部数据的操作函数，需要程序编写人员去实现的。比如应用读取一个陀螺仪传感器的原始数据，那么最终完成工作的就是 read_raw 函数，我们需要在 read_raw 函数里面实现对陀螺仪芯片的读取操作。同理，write_raw 是应用程序向陀螺仪芯片写数据，一般用于配置芯片，比如量程、数据速率等。这两个函数的参数都是一样的，我们依次来看一下：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 文件中，内容如下：
来看一下 iio_chan_spec 结构体中一些比较重要的成员变量：
第 224 行，type 为通道类型， iio_chan_type 是一个枚举类型，列举出了可以选择的通道类型，定义在 include/uapi/linux/iio/types.h 文件里面，内容如下：
从示例代码 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 文件里面，内容如下(有省略)
比如 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 各个成员变量的涵义：
比如 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驱动框架创建

2.1 基础驱动框架建立

同spi和IIC驱动框架

2.2 IIO设备申请与初始化

第 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。

3. 驱动代码

3.1 使能内核设置

3.2 代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include  
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include                         /* 异步通知 */
#include 
#include 
#include 
#include "icm20608reg.h"
#include 
/* IIO框架 */
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define ICM20608_NAME	        "icm20608_"

#define ICM20608_TEMP_OFFSET 0
#define ICM20608_TEMP_SCALE 326800000

/* icm20608 陀螺仪分辨率，对应 250、500、1000、2000，计算方法：
* 以正负 250 度量程为例，500/2^16=0.007629，扩大 1000000 倍，就是 7629
*/

static const int gyro_scale_icm20608[] = {7629, 15258, 30517, 61035};

/* icm20608 加速度计分辨率，对应 2、4、8、16 计算方法：
* 以正负 2g 量程为例，4/2^16=0.000061035，扩大 1000000000 倍，就是 61035
*/
static const int accel_scale_icm20608[] = {61035, 122070, 244140, 488281};



/* 通道修饰符，用来指定 X、Y、Z 轴 */
	/* 行设置相同类型的通道
	   IIO_CHAN_INFO_SCALE 属性相同，“scale”是比例的意思，在这里就是量程(分辨率)，因为
	   ICM20608 的陀螺仪和加速度计的量程是可以调整的，量程不同分辨率也就不同。陀螺仪或加
	   速度计的三个轴也是一起设置的，因此对于陀螺仪或加速度计而言，X、Y、Z 这三个轴的量程
	   是共享的 */
	   /* 设置每个通道的 IIO_CHAN_INFO_RAW 和 IIO_CHAN_INFO_CALIBBIAS
	   这两个属性都是独立的，IIO_CHAN_INFO_RAW 表示 ICM20608 每个通道的原始值，这个肯定
	   是每个通道独立的。IIO_CHAN_INFO_CALIBBIAS 是 ICM20608 每个通道的校准值，这个是
	   ICM20608 的特性，不是所有的传感器都有校准值，一切都要以实际所使用的传感器为准 */
		/* 设置扫描数据类型，也就是 ICM20608 原始数据类型 */
	/* 为有符号类型、实际位数 16bit，存储位数 16bit，大端模式 */
#define ICM20608_CHAN(_type, _channel2, _index) \
{ 												\
	.type = _type, 								\
	.modified = 1, 								\
	.channel2 = _channel2,  					\
	.info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), 	\
	.info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_CALIBBIAS), \
	.scan_index = _index, \
	.scan_type = { \
		.sign = 's', \
		.realbits = 16, \
		.storagebits = 16, \
		.shift = 0, \
		.endianness = IIO_BE, \
	}, \
}

/* 
* ICM20608 的扫描元素，3 轴加速度计、
* 3 轴陀螺仪、1 路温度传感器，1 路时间戳
*/
/* 自定义的扫描索引枚举类型 inv_icm20608_scan，包括陀螺仪、加速度计的 6
个通道，温度计的 1 个通道、以及 1 个 ICM20608 时间戳通道 */
enum inv_icm20608_scan {
	INV_ICM20608_SCAN_ACCL_X,
	INV_ICM20608_SCAN_ACCL_Y,
	INV_ICM20608_SCAN_ACCL_Z,
	INV_ICM20608_SCAN_TEMP,
	INV_ICM20608_SCAN_GYRO_X,
	INV_ICM20608_SCAN_GYRO_Y,
	INV_ICM20608_SCAN_GYRO_Z,
	INV_ICM20608_SCAN_TIMESTAMP,
};

struct icm20608_dev {
	struct spi_device *spi; 			/* spi 设备 */
	struct regmap *regmap; 				/* regmap */
	struct regmap_config regmap_config;
	struct mutex lock;
};

/*
* icm20608 通道，1 路温度通道，3 路陀螺仪，3 路加速度计
*/
/* 这里定义了 7 个通道，分别是：1 个温度通道，3 个陀螺仪
通道(X、Y、Z)，3 个加速度计通道(X、Y、Z)。 */
static const struct iio_chan_spec icm20608_channels[] = {
/* 温度通道 */
	{
		.type = IIO_TEMP,
		/* IIO_CHAN_INFO_RAW
		为温度通道的原始值，IIO_CHAN_INFO_OFFSET 
		是 ICM20608 温度 offset 值 */
		/* IIO_CHAN_INFO_SCALE 是 ICM20608 的比例，
		也就是一个单位的原始值为多少℃ */
		.info_mask_separate = BIT(IIO_CHAN_INFO_RAW)
							| BIT(IIO_CHAN_INFO_OFFSET)
							| BIT(IIO_CHAN_INFO_SCALE),
		.scan_index = INV_ICM20608_SCAN_TEMP,
			.scan_type = {
			.sign = 's',
			.realbits = 16,
			.storagebits = 16,
			.shift = 0,
			.endianness = IIO_BE,
		},
	},

	/* IIO_MOD_X、IIO_MOD_Y 和 IIO_MOD_Z 分别是 X、Y、Z 这三个轴
的修饰符 */
	ICM20608_CHAN(IIO_ANGL_VEL, IIO_MOD_X,INV_ICM20608_SCAN_GYRO_X),
	ICM20608_CHAN(IIO_ANGL_VEL, IIO_MOD_Y,INV_ICM20608_SCAN_GYRO_Y),
	ICM20608_CHAN(IIO_ANGL_VEL, IIO_MOD_Z,INV_ICM20608_SCAN_GYRO_Z), 

	ICM20608_CHAN(IIO_ACCEL, IIO_MOD_Y, INV_ICM20608_SCAN_ACCL_Y), 
	ICM20608_CHAN(IIO_ACCEL, IIO_MOD_X, INV_ICM20608_SCAN_ACCL_X), 
	ICM20608_CHAN(IIO_ACCEL, IIO_MOD_Z, INV_ICM20608_SCAN_ACCL_Z), 
};

/*
* @description : 读取 icm20608 指定寄存器值，读取一个寄存器
* @param – dev : icm20608 设备
* @param – reg : 要读取的寄存器
* @return : 读取到的寄存器值
*/
static unsigned char icm20608_read_onereg(struct icm20608_dev *dev, u8 reg)
{
	u8 ret;
	unsigned int data;

	ret = regmap_read(dev->regmap, reg, &data);
	return (u8)data;
}

/*
* @description : 向 icm20608 指定寄存器写入指定的值，写一个寄存器
* @param – dev : icm20608 设备
* @param – reg : 要写的寄存器
* @param – data : 要写入的值
* @return : 无
*/
static void icm20608_write_onereg(struct icm20608_dev *dev, u8 reg, u8 value)
{
	regmap_write(dev->regmap, reg, value);
}

/*
* @description : 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); 
	icm20608_write_onereg(dev, ICM20_ACCEL_CONFIG, 0x18);
	icm20608_write_onereg(dev, ICM20_CONFIG, 0x04); 
	icm20608_write_onereg(dev, ICM20_ACCEL_CONFIG2, 0x04);
	icm20608_write_onereg(dev, ICM20_PWR_MGMT_2, 0x00); 
	icm20608_write_onereg(dev, ICM20_LP_MODE_CFG, 0x00); 
	icm20608_write_onereg(dev, ICM20_INT_ENABLE, 0x01); 
}


/*
* @description : 读取 ICM20608 传感器数据，可以用于陀螺仪、加速度计、温度
* @param – dev : icm20608 设备
* @param - reg : 要读取的通道寄存器首地址。
* @param – anix : 需要读取的通道，比如 X，Y，Z。
* @param - *val : 保存读取到的值。
* @return : 0，成功；其他值，错误
*/
static int icm20608_sensor_show(struct icm20608_dev *dev, int reg, int axis, int *val)
{
	int ind, result;
	__be16 d;

	ind = (axis - IIO_MOD_X) * 2;
	result = regmap_bulk_read(dev->regmap, reg + ind, (u8 *)&d, 2);
	if (result)
		return -EINVAL;
	*val = (short)be16_to_cpup(&d);

	return IIO_VAL_INT;
}
/*
* @description : 读取 ICM20608 陀螺仪、加速度计、温度通道值
* @param - indio_dev : iio 设备
* @param - chan : 通道。
* @param - val : 保存读取到的通道值。
* @return : 0，成功；其他值，错误
*/
static int icm20608_read_channel_data(struct iio_dev *indio_dev,
									  struct iio_chan_spec const *chan,
									  int *val)
{
	struct icm20608_dev *dev = iio_priv(indio_dev);
	int ret = 0;
	switch (chan->type) {
		case IIO_ANGL_VEL: /* 读取陀螺仪数据 */
			ret = icm20608_sensor_show(dev, ICM20_GYRO_XOUT_H, chan->channel2, val); /* channel2 为 X、Y、Z 轴 */
			break;
		case IIO_ACCEL: /* 读取加速度计数据 */
			ret = icm20608_sensor_show(dev, ICM20_ACCEL_XOUT_H, chan->channel2, val); /* channel2 为 X、Y、Z 轴 */
			break;
		case IIO_TEMP: /* 读取温度 */
			ret = icm20608_sensor_show(dev, ICM20_TEMP_OUT_H, IIO_MOD_X, val); 
			break;
		default:
			ret = -EINVAL;
			break;
	}
	return ret;
}

/*
* @description : 读函数，当读取 sysfs 中的文件的时候最终此函数会执
* ：行，此函数里面会从传感器里面读取各种数据，然后上传给应用。
* @param - indio_dev : iio_dev
* @param - chan : 通道
* @param - val : 读取的值，如果是小数值的话，val 是整数部分。
* @param - val2 : 读取的值，如果是小数值的话，val2 是小数部分。
* @param - mask : 掩码。
* @return : 0，成功；其他值，错误
*/
static int icm20608_read_raw(struct iio_dev *indio_dev,
							 struct iio_chan_spec const *chan,
							 int *val, int *val2, long mask)
{
	struct icm20608_dev *dev = iio_priv(indio_dev);
	int ret = 0;
	unsigned char regdata = 0;

	switch (mask) {
		case IIO_CHAN_INFO_RAW: /* 读取 ICM20608 加速度计、陀螺仪、温度传感器原始值 */
			iio_device_claim_direct_mode(indio_dev);/* 保持 direct 模式 */
			mutex_lock(&dev->lock); /* 上锁 */
			ret = icm20608_read_channel_data(indio_dev, chan, val); 
			mutex_unlock(&dev->lock); /* 释放锁 */
			iio_device_release_direct_mode(indio_dev);
			return ret;
		case IIO_CHAN_INFO_SCALE:
			switch (chan->type) {
				case IIO_ANGL_VEL:
					mutex_lock(&dev->lock);
					regdata = (icm20608_read_onereg(dev, ICM20_GYRO_CONFIG) & 0X18) >> 3;
					*val = 0;
					*val2 = gyro_scale_icm20608[regdata];
					mutex_unlock(&dev->lock);
					return IIO_VAL_INT_PLUS_MICRO; /* 值为 val+val2/1000000 */
				case IIO_ACCEL:
					mutex_lock(&dev->lock);
					regdata = (icm20608_read_onereg(dev, ICM20_ACCEL_CONFIG) & 0X18) >> 3;
					*val = 0;
					*val2 = accel_scale_icm20608[regdata];;
					mutex_unlock(&dev->lock);
					return IIO_VAL_INT_PLUS_NANO;/* 值为 val+val2/1000000000 */
				case IIO_TEMP: 
					*val = ICM20608_TEMP_SCALE/ 1000000;
					*val2 = ICM20608_TEMP_SCALE % 1000000;
					return IIO_VAL_INT_PLUS_MICRO; /* 值为 val+val2/1000000 */
				default:
					return -EINVAL;
			}
			return ret;
		case IIO_CHAN_INFO_OFFSET: /* ICM20608 温度传感器 offset 值 */
			switch (chan->type) {
				case IIO_TEMP:
					*val = ICM20608_TEMP_OFFSET;
					return IIO_VAL_INT;
				default:
					return -EINVAL;
			}
			return ret;
		case IIO_CHAN_INFO_CALIBBIAS: /* ICM20608 加速度计和陀螺仪校准值 */
			switch (chan->type) {
				case IIO_ANGL_VEL: /* 陀螺仪的校准值*/
					mutex_lock(&dev->lock);
					ret = icm20608_sensor_show(dev, ICM20_XG_OFFS_USRH, chan->channel2, val);
					mutex_unlock(&dev->lock);
					return ret;
				case IIO_ACCEL: /* 加速度计的校准值*/
					mutex_lock(&dev->lock);
					ret = icm20608_sensor_show(dev, ICM20_XA_OFFSET_H, chan->channel2, val);
					mutex_unlock(&dev->lock);
					return ret;
				default:
					return -EINVAL;
			}
		
		default:
		return ret -EINVAL;
	}
}

/* @description : 设置 ICM20608 传感器，可以用于陀螺仪、加速度计设置
* @param - dev : icm20608 设备
* @param - reg : 要设置的通道寄存器首地址。
* @param – anix : 要设置的通道，比如 X，Y，Z。
* @param - val : 要设置的值。
* @return : 0，成功；其他值，错误
*/
static int icm20608_sensor_set(struct icm20608_dev *dev, int reg, int axis, int val)
{
	int ind, result;
	__be16 d = cpu_to_be16(val);

	ind = (axis - IIO_MOD_X) * 2;
	result = regmap_bulk_write(dev->regmap, reg + ind, (u8 *)&d, 2);
	if (result)
		return -EINVAL;

	return 0;
}

/* @description : 设置 ICM20608 的陀螺仪计量程(分辨率)
* @param - dev : icm20608 设备
* @param - val : 量程(分辨率值)。
* @return : 0，成功；其他值，错误
*/
static int icm20608_write_gyro_scale(struct icm20608_dev *dev, int val)
{
	int result, i;
	u8 d;

	for (i = 0; i < ARRAY_SIZE(gyro_scale_icm20608); ++i) {
		if (gyro_scale_icm20608[i] == val) {
			d = (i << 3);
			result = regmap_write(dev->regmap, ICM20_GYRO_CONFIG, d);
			if (result)
				return result;
			return 0;
		}
	}
	return -EINVAL;
}

/*
* @description : 设置 ICM20608 的加速度计量程(分辨率)
* @param - dev : icm20608 设备
* @param - val : 量程(分辨率值)。
* @return : 0，成功；其他值，错误
*/
static int icm20608_write_accel_scale(struct icm20608_dev *dev, int val)
{
	int result, i;
	u8 d;

	for (i = 0; i < ARRAY_SIZE(accel_scale_icm20608); ++i) {
		if (accel_scale_icm20608[i] == val) {
			d = (i << 3);
			result = regmap_write(dev->regmap, ICM20_ACCEL_CONFIG, d);
			if (result)
				return result;
			return 0;
		}
	}
	return -EINVAL;
}

/*
* @descriptio : 写函数，当向 sysfs 中的文件写数据的时候最终此函数会
* ：执行，一般在此函数里面设置传感器，比如量程等。
* @param - indio_dev : iio_dev
* @param – chan : 通道
* @param – val : 应用程序写入的值，如果是小数值的话，val 是整数部分。
* @param - val2 : 应用程序写入的值，如果是小数值的话，val2 是小数部分。
* @return : 0，成功；其他值，错误
*/
static int icm20608_write_raw(struct iio_dev *indio_dev,
							  struct iio_chan_spec const *chan,
							  int val, int val2, long mask)
{
	struct icm20608_dev *dev = iio_priv(indio_dev);
	int ret = 0;

	iio_device_claim_direct_mode(indio_dev); 
	switch (mask) {
		case IIO_CHAN_INFO_SCALE: /* 设置陀螺仪和加速度计的分辨率 */
			switch (chan->type) {
				case IIO_ANGL_VEL: /* 设置陀螺仪 */
					mutex_lock(&dev->lock);
					ret = icm20608_write_gyro_scale(dev, val2);
					mutex_unlock(&dev->lock);
					break;
				case IIO_ACCEL: /* 设置加速度计 */
					mutex_lock(&dev->lock);
					ret = icm20608_write_accel_scale(dev, val2);
					mutex_unlock(&dev->lock);
					break;
				default:
					ret = -EINVAL;
					break;
				}
			break;
		case IIO_CHAN_INFO_CALIBBIAS: /* 设置陀螺仪和加速度计的校准值 */
			switch (chan->type) {
				case IIO_ANGL_VEL: /* 设置陀螺仪校准值 */
					mutex_lock(&dev->lock);
					ret = icm20608_sensor_set(dev, ICM20_XG_OFFS_USRH,
					chan->channel2, val);
					mutex_unlock(&dev->lock);
					break;
				case IIO_ACCEL: /* 加速度计校准值 */
					mutex_lock(&dev->lock);
					ret = icm20608_sensor_set(dev, ICM20_XA_OFFSET_H,
					chan->channel2, val);
					mutex_unlock(&dev->lock);
					break;
				default:
					ret = -EINVAL;
				break;
			}
			break;
		default:
			ret = -EINVAL;
		break;
	}

	iio_device_release_direct_mode(indio_dev); 
	return ret;

}

/*
* @description : 用户空间写数据格式，比如我们在用户空间操作 sysfs 来设置传
* ：感器的分辨率，如果分辨率带小数，那么这个小数传递到内核空间
* : 应该扩大多少倍，此函数就是用来设置这个的。
* @param - indio_dev : iio_dev
* @param - chan : 通道
* @param - mask : 掩码
* @return : 0，成功；其他值，错误
*/
static int icm20608_write_raw_get_fmt(struct iio_dev *indio_dev,
struct iio_chan_spec const *chan, long mask)
{
	switch (mask) {
		case IIO_CHAN_INFO_SCALE:
			switch (chan->type) {
				case IIO_ANGL_VEL: 
					return IIO_VAL_INT_PLUS_MICRO;
				default:
					return IIO_VAL_INT_PLUS_NANO;
			}
		default:
			return IIO_VAL_INT_PLUS_MICRO;
	}
	return -EINVAL;

}

/*
* iio_info 结构体变量
*/
static const struct iio_info icm20608_info = {
	.read_raw = icm20608_read_raw,
	.write_raw = icm20608_write_raw,
	.write_raw_get_fmt = &icm20608_write_raw_get_fmt,
};

/*
* @description : spi 驱动的 probe 函数，当驱动与
* 设备匹配以后此函数就会执行
* @param – spi : spi 设备
* @return : 0,成功；其他值，失败
*/ 
static int icm20608_probe(struct spi_device *spi)
{
	int ret;
	struct icm20608_dev *dev;
	struct iio_dev *indio_dev;

	/* 1、申请 iio_dev 内存 */
	indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*dev));
	if (!indio_dev)
		return -ENOMEM;

	/* 2、获取 icm20608_dev 结构体地址 */
	dev = iio_priv(indio_dev);
	dev->spi = spi;
	spi_set_drvdata(spi, indio_dev);
	mutex_init(&dev->lock);

	/* 3、iio_dev 的其他成员变量 */
	indio_dev->dev.parent = &spi->dev;
	indio_dev->info = &icm20608_info;
	indio_dev->name = ICM20608_NAME; 
	indio_dev->modes = INDIO_DIRECT_MODE;/* 直接模式，提供 sysfs 接口 */
	indio_dev->channels = icm20608_channels;
	indio_dev->num_channels = ARRAY_SIZE(icm20608_channels);

	/* 4、注册 iio_dev */
	ret = iio_device_register(indio_dev);
	if (ret < 0) {
		dev_err(&spi->dev, "iio_device_register failed\n");
		goto err_iio_register;
	}

	/* 5、初始化 regmap_config 设置 */
	dev->regmap_config.reg_bits = 8; 			/* 寄存器长度 8bit */
	dev->regmap_config.val_bits = 8; 			/* 值长度 8bit */
	dev->regmap_config.read_flag_mask = 0x80; 	/* 读掩码设置为 0X80 */

	/* 6、初始化 SPI 接口的 regmap */
	dev->regmap = regmap_init_spi(spi, &dev->regmap_config);
	if (IS_ERR(dev->regmap)) {
		ret = PTR_ERR(dev->regmap);
		goto err_regmap_init;
	}

	/* 7、初始化 spi_device */
	spi->mode = SPI_MODE_0; /*MODE0，CPOL=0，CPHA=0*/
	spi_setup(spi);

	/* 初始化 ICM20608 内部寄存器 */
	icm20608_reginit(dev); 
	return 0;

err_regmap_init:
	iio_device_unregister(indio_dev);
err_iio_register:
	return ret;
}

/*
* @description : spi 驱动的 remove 函数，移除 spi 驱动的时候此函数会执行
* @param - spi : spi 设备
* @return : 0，成功;其他负值,失败
*/
static int icm20608_remove(struct spi_device *spi)
{
	struct iio_dev *indio_dev = spi_get_drvdata(spi);
	struct icm20608_dev *dev;

	dev = iio_priv(indio_dev);

	/* 1、删除 regmap */
	regmap_exit(dev->regmap);

	/* 2、注销 IIO */
	iio_device_unregister(indio_dev);
	return 0;
}

/* 传统匹配方式 ID 列表 */
static const struct spi_device_id icm20608_id[] = {
	{"alientek,icm20608", 0},
	{}
};

/* 设备树匹配列表 */
static const struct of_device_id icm20608_of_match[] = {
	{ .compatible = "alientek,icm20608" },
	{ /* Sentinel */ }
};

/* SPI 驱动结构体 */
static struct spi_driver icm20608_driver = {
	.probe = icm20608_probe,
	.remove = icm20608_remove,
	.driver = {
		.owner = THIS_MODULE,
		.name = "icm20608",
		.of_match_table = icm20608_of_match,
	},
	.id_table = icm20608_id,
};

/*
* @description : 驱动入口函数
* @param : 无
* @return : 无
*/
static int __init icm20608_init(void)
{
	return spi_register_driver(&icm20608_driver);
}

/*
* @description : 驱动出口函数
* @param : 无
* @return : 无
*/
static void __exit icm20608_exit(void)
{
spi_unregister_driver(&icm20608_driver);
}

module_init(icm20608_init);
module_exit(icm20608_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Shao Zheming");

MODULE_INFO(intree, "Y");

4.应用代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include "linux/ioctl.h"
#include "poll.h"
#include "sys/select.h"
#include "sys/time.h"
#include "signal.h"

#include 



/* 字符串转数字，将浮点小数字符串转换为浮点数数值 */
#define SENSOR_FLOAT_DATA_GET(ret, index, str, member)\
            ret = file_data_read(file_path[index], str);\
            dev->member = atof(str);\

/* 字符串转数字，将整数字符串转换为整数数值 */
#define SENSOR_INT_DATA_GET(ret, index, str, member)\
            ret = file_data_read(file_path[index], str);\
            dev->member = atoi(str);\

/* icm20608 iio 框架对应的文件路径 */
static char *file_path[] = {
    "/sys/bus/iio/devices/iio:device1/in_accel_scale",
    "/sys/bus/iio/devices/iio:device1/in_accel_x_calibbias",
    "/sys/bus/iio/devices/iio:device1/in_accel_x_raw",
    "/sys/bus/iio/devices/iio:device1/in_accel_y_calibbias",
    "/sys/bus/iio/devices/iio:device1/in_accel_y_raw",
    "/sys/bus/iio/devices/iio:device1/in_accel_z_calibbias",
    "/sys/bus/iio/devices/iio:device1/in_accel_z_raw",
    "/sys/bus/iio/devices/iio:device1/in_anglvel_scale",
    "/sys/bus/iio/devices/iio:device1/in_anglvel_x_calibbias",
    "/sys/bus/iio/devices/iio:device1/in_anglvel_x_raw",
    "/sys/bus/iio/devices/iio:device1/in_anglvel_y_calibbias",
    "/sys/bus/iio/devices/iio:device1/in_anglvel_y_raw",
    "/sys/bus/iio/devices/iio:device1/in_anglvel_z_calibbias",
    "/sys/bus/iio/devices/iio:device1/in_anglvel_z_raw",
    "/sys/bus/iio/devices/iio:device1/in_temp_offset",
    "/sys/bus/iio/devices/iio:device1/in_temp_raw",
    "/sys/bus/iio/devices/iio:device1/in_temp_scale",
};

/* 文件路径索引，要和 file_path 里面的文件顺序对应 */
enum path_index {
    IN_ACCEL_SCALE = 0,
    IN_ACCEL_X_CALIBBIAS,
    IN_ACCEL_X_RAW,
    IN_ACCEL_Y_CALIBBIAS,
    IN_ACCEL_Y_RAW,
    IN_ACCEL_Z_CALIBBIAS,
    IN_ACCEL_Z_RAW,
    IN_ANGLVEL_SCALE,
    IN_ANGLVEL_X_CALIBBIAS,
    IN_ANGLVEL_X_RAW,
    IN_ANGLVEL_Y_CALIBBIAS,
    IN_ANGLVEL_Y_RAW,
    IN_ANGLVEL_Z_CALIBBIAS,
    IN_ANGLVEL_Z_RAW,
    IN_TEMP_OFFSET,
    IN_TEMP_RAW,
    IN_TEMP_SCALE,
};

/*
* icm20608 数据设备结构体
*/
struct icm20608_dev{
    int accel_x_calibbias, accel_y_calibbias, accel_z_calibbias;
    int accel_x_raw, accel_y_raw, accel_z_raw;

    int gyro_x_calibbias, gyro_y_calibbias, gyro_z_calibbias;
    int gyro_x_raw, gyro_y_raw, gyro_z_raw;

    int temp_offset, temp_raw;

    float accel_scale, gyro_scale, temp_scale;

    float gyro_x_act, gyro_y_act, gyro_z_act;
    float accel_x_act, accel_y_act, accel_z_act;
    float temp_act;
};

struct icm20608_dev icm20608;

/*
* @description : 读取指定文件内容
* @param – filename : 要读取的文件路径
* @param - str : 读取到的文件字符串
* @return : 0 成功;其他 失败
*/
static int file_data_read(char *filename, char *str)
{
    int ret = 0;
    FILE *data_stream;
    data_stream = fopen(filename, "r"); /* 只读打开 */
    if(data_stream == NULL) {
        printf("can't open file %s\r\n", filename);
        return -1;
    }

    ret = fscanf(data_stream, "%s", str);
    if(!ret) {
        
    } else if(ret == EOF) {
        /* 读到文件末尾的话将文件指针重新调整到文件头 */
        fseek(data_stream, 0, SEEK_SET); 
    }
    fclose(data_stream); /* 关闭文件 */ 
    return 0;
}

/*
* @description : 获取 ICM20608 数据
* @param - dev : 设备结构体
* @return : 0 成功;其他 失败
*/
static int sensor_read(struct icm20608_dev *dev)
{
    int ret = 0;
    char str[50];

    /* 1、获取陀螺仪原始数据 */
    SENSOR_FLOAT_DATA_GET(ret, IN_ANGLVEL_SCALE, str, gyro_scale);
    SENSOR_INT_DATA_GET(ret, IN_ANGLVEL_X_RAW, str, gyro_x_raw);
    SENSOR_INT_DATA_GET(ret, IN_ANGLVEL_Y_RAW, str, gyro_y_raw);
    SENSOR_INT_DATA_GET(ret, IN_ANGLVEL_Z_RAW, str, gyro_z_raw);

    /* 2、获取加速度计原始数据 */
    SENSOR_FLOAT_DATA_GET(ret, IN_ACCEL_SCALE, str, accel_scale);
    SENSOR_INT_DATA_GET(ret, IN_ACCEL_X_RAW, str, accel_x_raw);
    SENSOR_INT_DATA_GET(ret, IN_ACCEL_Y_RAW, str, accel_y_raw);
    SENSOR_INT_DATA_GET(ret, IN_ACCEL_Z_RAW, str, accel_z_raw);
    
    /* 3、获取温度值 */
    SENSOR_FLOAT_DATA_GET(ret, IN_TEMP_SCALE, str, temp_scale);
    SENSOR_INT_DATA_GET(ret, IN_TEMP_OFFSET, str, temp_offset);
    SENSOR_INT_DATA_GET(ret, IN_TEMP_RAW, str, temp_raw);
    
    /* 3、转换为实际数值 */
    dev->accel_x_act = dev->accel_x_raw * dev->accel_scale;
    dev->accel_y_act = dev->accel_y_raw * dev->accel_scale;
    dev->accel_z_act = dev->accel_z_raw * dev->accel_scale;
    
    dev->gyro_x_act = dev->gyro_x_raw * dev->gyro_scale;
    dev->gyro_y_act = dev->gyro_y_raw * dev->gyro_scale;
    dev->gyro_z_act = dev->gyro_z_raw * dev->gyro_scale;
    
    dev->temp_act = ((dev->temp_raw - dev->temp_offset) /
    dev->temp_scale) + 25;
    return ret;
}

/*
* @description : main 主程序
* @param – argc : argv 数组元素个数
* @param – argv : 具体参数
* @return : 0 成功;其他 失败
*/
int main(int argc, char *argv[])
{
    int ret = 0;

    if (argc != 1) {
    printf("Error Usage!\r\n");
    return -1;
    }

    while (1) {
        ret = sensor_read(&icm20608);
        if(ret == 0) { /* 数据读取成功 */
            printf("\r\n 原始值:\r\n");
            printf("gx = %d, gy = %d, gz = %d\r\n",
                    icm20608.gyro_x_raw, icm20608.gyro_y_raw, icm20608.gyro_z_raw);
            printf("ax = %d, ay = %d, az = %d\r\n",
                    icm20608.accel_x_raw,icm20608.accel_y_raw,icm20608.accel_z_raw);
            printf("temp = %d\r\n", icm20608.temp_raw);
            printf("实际值:");
            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);
            printf("act ax = %.2fg, act ay = %.2fg,  act az = %.2fg\r\n", 
                    icm20608.accel_x_act, icm20608.accel_y_act, icm20608.accel_z_act);
            printf("act temp = %.2f°C\r\n", icm20608.temp_act);
        }
        usleep(100000); /*100ms */
    }

    return 0;
}