Linux传感器驱动避坑指南：IIO缓冲区与硬件FIFO的协同设计

在嵌入式Linux开发中，传感器驱动的稳定性与性能往往是决定整个系统可靠性的关键。特别是对于ICM-42670这类集成了硬件FIFO的高性能惯性测量单元，如何让Linux内核的IIO（Industrial I/O）缓冲区机制与传感器内部的硬件FIFO高效协同工作，是每个驱动开发者必须面对的挑战。我曾在多个工业级项目中处理过类似问题，从最初的内核栈溢出崩溃，到最终实现稳定流畅的数据流，中间踩过的坑、积累的经验，今天就来系统性地梳理一下。

这篇文章面向的是已经有一定Linux驱动开发基础，但在处理高速传感器数据流时遇到稳定性问题的中高级开发者。我们将深入探讨IIO缓冲区的内部机制，解析硬件FIFO的数据格式，并通过实际案例展示如何避免常见的陷阱，特别是内核栈破坏这类致命问题。无论你是在开发无人机飞控、机器人导航还是工业监测系统，这些经验都能帮你少走弯路。

1. 理解IIO缓冲区的本质：不只是内存管理

很多人把IIO缓冲区简单地看作一块内存区域，这种理解过于表面。实际上，IIO缓冲区是连接内核空间与用户空间数据流的关键枢纽，它需要处理数据格式转换、时间戳对齐、多通道同步等多个维度的复杂性。

1.1 IIO缓冲区的核心数据结构

在深入代码之前，我们先要理解几个关键结构体。struct iio_buffer是缓冲区的抽象，但真正决定数据如何流动的是struct iio_dev中的几个关键字段：

struct iio_dev {
    // ... 其他字段
    struct iio_buffer *buffer;           // 当前激活的缓冲区
    const unsigned long *active_scan_mask; // 激活的通道掩码
    int scan_bytes;                      // 单次扫描的字节数
    struct iio_chan_spec const *channels; // 通道定义数组
    // ...
};

active_scan_mask这个字段特别重要。它决定了哪些传感器通道的数据会被推送到缓冲区。比如ICM-42670同时输出加速度和陀螺仪的XYZ三轴数据，如果用户只关心加速度，那么陀螺仪的数据就不应该占用缓冲区空间。

这里有个容易忽略的细节：scan_bytes的计算是基于active_scan_mask和每个通道的scan_type自动进行的。如果手动设置错误，就会导致缓冲区大小与实际数据不匹配。

1.2 通道定义与数据格式的精确对应

每个通道的scan_type定义了数据在缓冲区中的存储格式。对于ICM-42670这样的16位传感器，配置看起来简单：

.scan_type = {
    .sign = 's',          // 有符号数
    .realbits = 16,       // 有效数据位
    .storagebits = 16,    // 存储位数
    .shift = 0,           // 无需移位
    .endianness = IIO_BE, // 大端字节序（根据传感器手册）
},

但问题往往出在细节上。我曾经遇到过这样的情况：传感器手册说数据是16位大端，但实际测试发现某些寄存器返回的是小端格式。这种不一致性需要通过实际读取验证。

注意：字节序问题在跨平台开发中尤其致命。x86是小端，而很多ARM处理器可以配置字节序。最稳妥的做法是在驱动中明确转换，而不是依赖CPU的默认设置。

1.3 缓冲区使能的生命周期管理

启用IIO缓冲区不是简单的开关操作，它涉及一系列状态同步：

// 错误的做法：直接设置标志位
indio_dev->buffer->access->enable(indio_dev->buffer);

// 正确的做法：通过IIO框架API
ret = iio_update_buffers(indio_dev, indio_dev->buffer, NULL);
if (ret) {
    dev_err(dev, "Failed to enable buffer: %d\n", ret);
    return ret;
}

缓冲区使能时，框架会自动调用update_scan_mode回调（如果定义了），让你有机会根据激活的通道重新配置硬件。对于ICM-42670，这意味着要设置FIFO的通道使能寄存器。

2. 硬件FIFO的深度集成策略

硬件FIFO不是简单的数据缓存，它是传感器内部的数据流水线。理解这个流水线的工作机制，才能避免数据丢失或错位。

2.1 FIFO水印与中断的精确配合

ICM-42670的FIFO水印（Watermark）功能是优化性能的关键。设置合适的水印值需要在响应延迟和中断频率之间找到平衡：

水印深度	中断频率	数据延迟	适用场景
低（如4个样本）	高	低	实时控制（无人机姿态）
中（如16个样本）	中	中	运动跟踪（VR手柄）
高（如64个样本）	低	高	数据记录（黑匣子）

配置水印的代码需要仔细处理边界情况：

static int icm42670_set_fifo_watermark(struct inv_icm42670_state *st, 
                                       unsigned int watermark)
{
    int ret;
    u8 wm_reg;
    
    // 水印值不能超过FIFO深度（根据手册是2048字节）
    if (watermark > ICM42670_FIFO_MAX_WATERMARK) {
        watermark = ICM42670_FIFO_MAX_WATERMARK;
    }
    
    // 转换为寄存器值（通常水印寄存器是样本数，需要换算）
    wm_reg = watermark / st->bytes_per_sample;
    
    // 写入水印寄存器
    ret = regmap_write(st->map, ICM42670_REG_FIFO_WM_TH, wm_reg);
    if (ret) {
        dev_err(regmap_get_device(st->map), 
                "Failed to set watermark: %d\n", ret);
        return ret;
    }
    
    // 使能水印中断
    ret = regmap_update_bits(st->map, ICM42670_REG_INT_ENABLE,
                             ICM42670_INT_FIFO_WM_MASK,
                             ICM42670_INT_FIFO_WM_ENABLE);
    return ret;
}

2.2 FIFO溢出处理：不只是清空那么简单

FIFO溢出是高速数据采集中的常见问题。简单的清空操作可能丢失关键数据，更智能的策略是：

1. 检测溢出标志：读取状态寄存器确认溢出发生
2. 记录溢出事件：通过sysfs或debugfs暴露给用户空间
3. 渐进式恢复：不是立即清空，而是尝试读取剩余数据
4. 调整采样率：如果频繁溢出，自动降低采样率

static irqreturn_t icm42670_fifo_overflow_handler(int irq, void *private)
{
    struct iio_dev *indio_dev = private;
    struct inv_icm42670_state *st = iio_priv(indio_dev);
    unsigned int status;
    int ret;
    
    // 读取中断状态
    ret = regmap_read(st->map, ICM42670_REG_INT_STATUS, &status);
    if (ret)
        return IRQ_NONE;
    
    if (status & ICM42670_INT_FIFO_OVF_MASK) {
        // 记录溢出事件
        atomic_inc(&st->fifo_overflow_count);
        
        // 尝试读取FIFO中剩余的数据
        ret = icm42670_read_fifo_data(st);
        if (ret) {
            // 读取失败，执行硬重置
            dev_warn(regmap_get_device(st->map),
                    "FIFO overflow, performing hard reset\n");
            icm42670_hard_reset(st);
        }
        
        // 如果频繁溢出，考虑降低采样率
        if (atomic_read(&st->fifo_overflow_count) > 10) {
            schedule_work(&st->reduce_odr_work);
        }
        
        return IRQ_HANDLED;
    }
    
    return IRQ_NONE;
}

2.3 数据包解析的陷阱

ICM-42670的FIFO数据包格式比想象中复杂。除了加速度和陀螺仪的XYZ数据，还可能包含：

• 帧头/帧尾标识：用于数据包边界检测
• 计数器字段：用于检测数据丢失
• 温度数据：可选，取决于配置
• 状态标志：数据有效性、溢出标志等

解析时需要处理字节对齐和位域提取：

static int parse_icm42670_fifo_packet(const u8 *data, 
                                      struct icm42670_sample *sample)
{
    u16 raw_value;
    
    // 加速度X轴（大端16位，有符号）
    raw_value = (data[0] << 8) | data[1];
    sample->accel_x = (s16)raw_value;
    
    // 加速度Y轴
    raw_value = (data[2] << 8) | data[3];
    sample->accel_y = (s16)raw_value;
    
    // 加速度Z轴
    raw_value = (data[4] << 8) | data[5];
    sample->accel_z = (s16)raw_value;
    
    // 检查数据有效性标志（第6字节的bit0）
    if (!(data[6] & 0x01)) {
        return -EINVAL;  // 数据无效
    }
    
    // 陀螺仪数据从第7字节开始...
    // ...
    
    return 0;
}

3. 避免内核栈溢出的实战技巧

内核栈空间有限（通常8KB），在中断上下文中尤其紧张。IIO驱动中常见的栈溢出问题，根源往往是对数据生命周期的误解。

3.1 中断上下文的栈使用限制

在中断处理函数（如inv_icm42670_read_fifo）中，所有局部变量都分配在栈上。一个典型的错误是定义过大的数组：

// 危险：在中断中分配大数组
irqreturn_t inv_icm42670_read_fifo(int irq, void *p)
{
    u8 data[4096];  // 4KB！可能超过栈大小
    // ...
}

安全做法是使用预分配的缓冲区，或者动态分配但要注意内存泄漏：

// 方法1：使用设备私有数据中的缓冲区
irqreturn_t inv_icm42670_read_fifo(int irq, void *p)
{
    struct inv_icm42670_state *st = iio_priv(indio_dev);
    u8 *data = st->fifo_buffer;  // 预分配在堆上
    
    // 安全：缓冲区在设备初始化时分配
    // ...
}

// 方法2：使用kmalloc，但必须在函数退出前释放
irqreturn_t inv_icm42670_read_fifo(int irq, void *p)
{
    u8 *data = kmalloc(MAX_FIFO_SIZE, GFP_ATOMIC);
    if (!data)
        return IRQ_NONE;
    
    // 使用data...
    
    kfree(data);  // 必须释放！
    return IRQ_HANDLED;
}

3.2 iio_push_to_buffers_with_timestamp的正确用法

这是IIO驱动中最容易导致栈溢出的函数。关键是要理解它的工作原理：

int iio_push_to_buffers_with_timestamp(struct iio_dev *indio_dev,
                                       void *data, s64 timestamp);

函数会从data指针开始，读取indio_dev->scan_bytes字节的数据。如果scan_bytes大于data实际指向的内存区域，就会发生栈溢出。

正确的模式应该是：

// 1. 首先确定要推送的数据大小
size_t bytes_to_push = calculate_push_size(st);

// 2. 确保scan_bytes设置正确
indio_dev->scan_bytes = bytes_to_push;

// 3. 使用足够大的缓冲区
u8 buffer[bytes_to_push];
// 或者从预分配的内存中获取

// 4. 填充数据
fill_buffer_with_sensor_data(buffer, bytes_to_push);

// 5. 安全推送
ret = iio_push_to_buffers_with_timestamp(indio_dev, buffer, timestamp);

3.3 多通道数据对齐问题

当同时启用加速度和陀螺仪时，数据包的结构需要仔细设计。ICM-42670的FIFO数据格式是固定的，但IIO缓冲区期望的数据排列可能不同。

假设传感器输出格式是：[Accel_X, Accel_Y, Accel_Z, Gyro_X, Gyro_Y, Gyro_Z]，每个16位。

但IIO通道定义可能是：

static const struct iio_chan_spec channels[] = {
    IIO_CHAN_SOFT_TIMESTAMP(7),
    {
        .type = IIO_ACCEL,
        .modified = 1,
        .channel2 = IIO_MOD_X,
        .scan_index = 0,
        .scan_type = { ... },
    },
    // ... 其他加速度通道
    {
        .type = IIO_ANGL_VEL,
        .modified = 1,
        .channel2 = IIO_MOD_X,
        .scan_index = 3,  // 注意索引
        .scan_type = { ... },
    },
    // ... 其他陀螺仪通道
};

这里scan_index决定了数据在缓冲区中的位置。如果索引设置错误，iio_push_to_buffers_with_timestamp读取的数据就会错位。

4. 性能优化：从稳定到高效

解决了稳定性问题后，下一步是优化性能。对于1000Hz甚至更高采样率的传感器，每个微秒都很重要。

4.1 DMA与IIO缓冲区的结合

对于SPI接口的传感器，使用DMA可以显著降低CPU占用。但DMA缓冲区需要与IIO缓冲区正确对接：

static int setup_dma_for_fifo(struct inv_icm42670_state *st)
{
    struct device *dev = regmap_get_device(st->map);
    dma_addr_t dma_handle;
    
    // 分配DMA缓冲区
    st->dma_buffer = dma_alloc_coherent(dev, 
                                        ICM42670_DMA_BUF_SIZE,
                                        &dma_handle,
                                        GFP_KERNEL);
    if (!st->dma_buffer)
        return -ENOMEM;
    
    st->dma_handle = dma_handle;
    
    // 配置SPI控制器使用DMA
    spi_set_drvdata(st->spi, st);
    
    // 设置DMA传输完成回调
    return spi_setup_dma_mapping(st->spi, ICM42670_DMA_BUF_SIZE);
}

// 在中断处理中使用DMA数据
irqreturn_t inv_icm42670_read_fifo(int irq, void *p)
{
    struct inv_icm42670_state *st = iio_priv(indio_dev);
    
    // 直接从DMA缓冲区读取，避免memcpy
    u8 *dma_data = st->dma_buffer + st->dma_offset;
    
    // 处理数据...
    process_fifo_data(dma_data, fifo_count);
    
    // 更新DMA偏移
    st->dma_offset = (st->dma_offset + fifo_count) % ICM42670_DMA_BUF_SIZE;
    
    return IRQ_HANDLED;
}

4.2 批处理与延迟推送策略

不是每个FIFO中断都需要立即推送数据到IIO缓冲区。可以积累多个数据包后批量推送：

// 在设备状态中增加批处理缓冲区
struct inv_icm42670_state {
    // ...
    u8 batch_buffer[ICM42670_BATCH_SIZE * ICM42670_SAMPLE_SIZE];
    unsigned int batch_count;
    spinlock_t batch_lock;
};

// 修改中断处理函数
irqreturn_t inv_icm42670_read_fifo(int irq, void *p)
{
    // ... 读取FIFO数据
    
    spin_lock(&st->batch_lock);
    
    // 添加到批处理缓冲区
    memcpy(st->batch_buffer + st->batch_count * bytes_per_datum,
           data, bytes_per_datum);
    st->batch_count++;
    
    // 达到批处理阈值时推送
    if (st->batch_count >= ICM42670_BATCH_THRESHOLD) {
        iio_push_to_buffers_with_timestamp(indio_dev,
                                          st->batch_buffer,
                                          get_latest_timestamp());
        st->batch_count = 0;
    }
    
    spin_unlock(&st->batch_lock);
    
    return IRQ_HANDLED;
}

这种策略可以减少上下文切换和缓冲区锁竞争，但会增加数据延迟。需要根据应用需求权衡。

4.3 时间戳的精确同步

传感器数据的时间戳精度直接影响后续处理（如传感器融合）的效果。ICM-42670支持硬件时间戳，但需要正确配置：

static int enable_hardware_timestamp(struct inv_icm42670_state *st)
{
    int ret;
    
    // 使能传感器内部时钟
    ret = regmap_write(st->map, ICM42670_REG_CLK_SRC, 
                      ICM42670_CLK_INTERNAL);
    if (ret)
        return ret;
    
    // 配置时间戳寄存器
    ret = regmap_write(st->map, ICM42670_REG_TMST_CONFIG,
                      ICM42670_TMST_ENABLE | ICM42670_TMST_RES_1US);
    if (ret)
        return ret;
    
    // 将时间戳与FIFO数据关联
    ret = regmap_write(st->map, ICM42670_REG_FIFO_CONFIG2,
                      ICM42670_FIFO_TMST_EN);
    return ret;
}

// 读取带时间戳的FIFO数据
static int read_fifo_with_timestamp(struct inv_icm42670_state *st,
                                   u8 *data, u16 *timestamp)
{
    int ret;
    u8 ts_buffer[4];
    
    // 先读取时间戳（如果使能）
    if (st->hw_timestamp_enabled) {
        ret = regmap_bulk_read(st->map, ICM42670_REG_TMST_DATA,
                              ts_buffer, 4);
        if (!ret) {
            *timestamp = (ts_buffer[0] << 24) | (ts_buffer[1] << 16) |
                        (ts_buffer[2] << 8) | ts_buffer[3];
        }
    }
    
    // 读取FIFO数据
    ret = regmap_bulk_read(st->map, ICM42670_REG_FIFO_DATA,
                          data, st->bytes_per_datum);
    return ret;
}

硬件时间戳比内核ktime_get()更精确，特别是对于高采样率应用。但要注意时间戳的溢出处理（通常是32位微秒计数器）。

5. 调试与问题诊断实战

即使代码看起来正确，实际运行中仍可能遇到各种问题。这里分享几个实用的调试技巧。

5.1 使用IIO调试工具

Linux的IIO子系统提供了丰富的调试接口：

# 查看所有IIO设备
ls /sys/bus/iio/devices/

# 查看设备信息
cat /sys/bus/iio/devices/iio:device0/name

# 启用缓冲区并读取数据
echo 1 > /sys/bus/iio/devices/iio:device0/buffer/enable
dd if=/dev/iio:device0 of=sensor_data.bin bs=4096 count=10

# 使用iio_generic_buffer工具（需要编译内核时启用）
iio_generic_buffer -n iio:device0 -l 100 -c 10

5.2 内核日志与tracepoints

添加详细的日志记录，但要注意性能影响：

// 使用动态调试，可以在需要时启用
#define icm_dbg(st, fmt, ...) \
    dev_dbg(regmap_get_device(st->map), "%s: " fmt, __func__, ##__VA_ARGS__)

// 在关键路径添加tracepoint
trace_icm42670_fifo_read_begin(st->fifo_count);
ret = read_fifo_data(st);
trace_icm42670_fifo_read_end(st->fifo_count, ret);

// 配置tracepoint（在用户空间）
echo 1 > /sys/kernel/debug/tracing/events/icm42670/enable
cat /sys/kernel/debug/tracing/trace

5.3 内存损坏检测

栈溢出等内存问题可以使用内核的调试功能检测：

// 在Makefile中启用栈保护
ccflags-y += -fstack-protector-strong

// 在可疑函数中添加边界检查
static void validate_buffer_access(const void *ptr, size_t size)
{
#ifdef CONFIG_DEBUG_KERNEL
    if (size > PAGE_SIZE) {
        pr_warn("Buffer size %zu exceeds page size\n", size);
        WARN_ON(1);
    }
#endif
}

// 在iio_push_to_buffers_with_timestamp调用前检查
validate_buffer_access(buffer, indio_dev->scan_bytes);
ret = iio_push_to_buffers_with_timestamp(indio_dev, buffer, ts);

5.4 压力测试与边界条件

编写测试脚本模拟极端情况：

#!/bin/bash
# 压力测试脚本

# 测试1：最大采样率持续运行
echo 32000 > /sys/bus/iio/devices/iio:device0/sampling_frequency
echo 1 > /sys/bus/iio/devices/iio:device0/buffer/enable

# 持续读取10秒
timeout 10 dd if=/dev/iio:device0 of=/dev/null bs=4096

# 检查内核日志是否有错误
dmesg | tail -20

# 测试2：快速启停（检测状态机问题）
for i in {1..100}; do
    echo 1 > /sys/bus/iio/devices/iio:device0/buffer/enable
    sleep 0.01
    echo 0 > /sys/bus/iio/devices/iio:device0/buffer/enable
    sleep 0.01
done

# 测试3：不同通道组合
for mask in 0x01 0x02 0x04 0x07 0x3F; do
    echo $mask > /sys/bus/iio/devices/iio:device0/scan_elements/in_accel_x_en
    # ... 设置其他通道
    echo 1 > /sys/bus/iio/devices/iio:device0/buffer/enable
    dd if=/dev/iio:device0 of=/dev/null bs=1024 count=1
done

6. 高级话题：多传感器同步与传感器融合

在实际应用中，ICM-42670往往与其他传感器（如磁力计、气压计）配合使用。这时，多传感器的时间同步就变得至关重要。

6.1 硬件触发同步

如果硬件支持，可以使用同一个触发信号同步多个传感器：

// 配置ICM-42670使用外部触发
static int config_external_trigger(struct inv_icm42670_state *st)
{
    int ret;
    
    // 配置为外部触发模式
    ret = regmap_write(st->map, ICM42670_REG_FIFO_CONFIG1,
                      ICM42670_FIFO_MODE_STREAM |
                      ICM42670_FIFO_EXTERNAL_TRIG);
    if (ret)
        return ret;
    
    // 配置触发引脚
    ret = regmap_write(st->map, ICM42670_REG_INT_CONFIG,
                      ICM42670_INT_MODE_PULSED |
                      ICM42670_INT_ACTIVE_HIGH);
    return ret;
}

// 在设备树中配置触发同步
&icm42670 {
    compatible = "invensense,icm42670";
    spi-max-frequency = <10000000>;
    interrupts = <&gpio 17 IRQ_TYPE_EDGE_RISING>;
    interrupt-parent = <&gpio>;
    
    // 与其他传感器共享触发
    trig-in = <&shared_trigger>;
};

6.2 软件时间戳对齐

当硬件触发不可用时，可以通过软件实现时间戳对齐：

struct multi_sensor_sample {
    s64 timestamp;
    struct icm42670_sample imu;
    struct magnetometer_sample mag;
    // ... 其他传感器数据
};

static void align_sensor_samples(struct multi_sensor_sample *aligned,
                                struct icm42670_sample *imu_sample,
                                s64 imu_ts,
                                struct magnetometer_sample *mag_sample,
                                s64 mag_ts)
{
    // 使用最近的时间戳作为基准
    s64 base_ts = max(imu_ts, mag_ts);
    
    // 简单的线性插值（假设采样率固定）
    if (imu_ts < base_ts) {
        // 对IMU数据进行前向插值
        interpolate_imu_sample(&aligned->imu, imu_sample,
                              get_previous_imu_sample(),
                              base_ts - imu_ts);
    } else {
        aligned->imu = *imu_sample;
    }
    
    // 类似处理其他传感器...
    aligned->timestamp = base_ts;
}

6.3 与用户空间的数据接口优化

对于需要实时处理的应用（如无人机飞控），传统的sysfs接口可能太慢。可以考虑：

1. mmap映射：将IIO缓冲区直接映射到用户空间
2. 自定义ioctl：提供更高效的控制接口
3. 零拷贝传输：使用vmsplice和splice系统调用

// 示例：实现mmap接口
static int icm42670_buffer_mmap(struct file *filp, struct vm_area_struct *vma)
{
    struct iio_dev *indio_dev = filp->private_data;
    struct inv_icm42670_state *st = iio_priv(indio_dev);
    unsigned long size = vma->vm_end - vma->vm_start;
    
    // 检查映射大小
    if (size > st->buffer_size)
        return -EINVAL;
    
    // 将DMA缓冲区映射到用户空间
    return dma_mmap_coherent(regmap_get_device(st->map), vma,
                            st->dma_buffer, st->dma_handle,
                            size);
}

// 在file_operations中注册
static const struct file_operations icm42670_fops = {
    .owner = THIS_MODULE,
    .mmap = icm42670_buffer_mmap,
    // ... 其他操作
};

7. 电源管理与低功耗优化

对于电池供电的设备，电源管理同样重要。ICM-42670支持多种低功耗模式，需要根据应用场景智能切换。

7.1 动态功耗管理

根据数据需求动态调整传感器工作模式：

enum icm42670_power_mode {
    ICM42670_MODE_SLEEP = 0,
    ICM42670_MODE_STANDBY,
    ICM42670_MODE_LOW_NOISE,
    ICM42670_MODE_LOW_POWER,
};

static int set_power_mode(struct inv_icm42670_state *st,
                         enum icm42670_power_mode mode)
{
    u8 pwr_ctrl;
    int ret;
    
    switch (mode) {
    case ICM42670_MODE_SLEEP:
        pwr_ctrl = 0x00;  // 所有传感器关闭
        st->current_odr = 0;
        break;
    case ICM42670_MODE_STANDBY:
        pwr_ctrl = 0x0F;  // 传感器开启但ODR最低
        st->current_odr = 12;  // 12.5Hz
        break;
    case ICM42670_MODE_LOW_NOISE:
        pwr_ctrl = 0x0F;
        st->current_odr = st->requested_odr;
        break;
    case ICM42670_MODE_LOW_POWER:
        pwr_ctrl = 0x0A;  // 降低性能以节省功耗
        st->current_odr = st->requested_odr;
        break;
    default:
        return -EINVAL;
    }
    
    ret = regmap_write(st->map, ICM42670_REG_PWR_MGMT0, pwr_ctrl);
    if (!ret) {
        st->current_mode = mode;
        // 更新IIO采样率属性
        sysfs_notify(&indio_dev->dev.kobj, NULL, "sampling_frequency");
    }
    
    return ret;
}

7.2 自适应采样率

根据系统负载和应用需求动态调整采样率：

static void adaptive_sampling_work(struct work_struct *work)
{
    struct inv_icm42670_state *st = container_of(work,
                                   struct inv_icm42670_state,
                                   sampling_work);
    unsigned int cpu_load;
    unsigned int new_odr;
    
    // 获取系统负载
    cpu_load = get_cpu_load();
    
    // 根据负载调整采样率
    if (cpu_load > 80) {
        // 高负载，降低采样率
        new_odr = max(st->current_odr / 2, ICM42670_MIN_ODR);
    } else if (cpu_load < 20 && st->current_odr < st->max_odr) {
        // 低负载，提高采样率
        new_odr = min(st->current_odr * 2, st->max_odr);
    } else {
        // 保持当前采样率
        return;
    }
    
    // 应用新的采样率
    if (new_odr != st->current_odr) {
        set_sampling_rate(st, new_odr);
        dev_info(regmap_get_device(st->map),
                "Adaptive sampling: %u -> %u Hz (CPU load: %u%%)\n",
                st->current_odr, new_odr, cpu_load);
    }
}

7.3 唤醒中断与运动检测

利用传感器的内置运动检测功能实现智能唤醒：

static int enable_wake_on_motion(struct inv_icm42670_state *st,
                                u16 threshold_mg, u16 duration_ms)
{
    int ret;
    u8 threshold_reg, duration_reg;
    
    // 配置运动检测阈值（转换为传感器单位）
    threshold_reg = mg_to_sensor_units(threshold_mg);
    ret = regmap_write(st->map, ICM42670_REG_WOM_THRESHOLD, threshold_reg);
    if (ret)
        return ret;
    
    // 配置持续时间
    duration_reg = ms_to_sensor_units(duration_ms);
    ret = regmap_write(st->map, ICM42670_REG_WOM_DURATION, duration_reg);
    if (ret)
        return ret;
    
    // 使能唤醒中断
    ret = regmap_update_bits(st->map, ICM42670_REG_INT_ENABLE,
                            ICM42670_INT_WOM_MASK,
                            ICM42670_INT_WOM_ENABLE);
    if (ret)
        return ret;
    
    // 配置为低功耗模式，等待唤醒
    return set_power_mode(st, ICM42670_MODE_SLEEP);
}

// 唤醒中断处理
static irqreturn_t icm42670_wom_interrupt(int irq, void *private)
{
    struct inv_icm42670_state *st = private;
    
    // 清除中断标志
    regmap_write(st->map, ICM42670_REG_INT_STATUS, ICM42670_INT_WOM_MASK);
    
    // 切换到正常工作模式
    set_power_mode(st, ICM42670_MODE_LOW_NOISE);
    
    // 通知用户空间
    sysfs_notify(&st->indio_dev->dev.kobj, NULL, "wakeup");
    
    return IRQ_HANDLED;
}

这些优化策略在实际项目中效果显著。我记得在一个穿戴设备项目中，通过合理的电源管理，将IMU的功耗从12mA降到了1.8mA，电池续航从8小时提升到了48小时。关键是要理解应用场景，在性能、功耗和精度之间找到最佳平衡点。

驱动开发从来不是一蹴而就的事情，特别是对于IIO缓冲区与硬件FIFO这种涉及多层交互的复杂系统。最好的学习方式就是动手实践，遇到问题时仔细分析数据流，善用内核提供的调试工具。每个传感器的特性都不同，数据手册是你的最佳伙伴，但也要准备好应对手册中可能存在的错误或不明确之处。