4.2 设计模式

驱动模型

可复用性（操作系统无关）

硬件层：设计一个通用的驱动模型，使得驱动程序可以在不同的操作系统上复用。
1. 只包括硬件相关的代码，避免与操作系统的特定实现绑定。
2. 涉及修改的操作使用mut，将锁交由操作系统处理，避免引入锁。
3. 暴露中断handler，将中断注册交由操作系统处理。
4. 可用异步简化中断回调。
5. 适度unsafe。
操作系统连接层: 单元测试所在层级，基于操作系统的特性和API实现驱动程序的连接。
1. 通过包裹系统的mutex等锁实现保证并发安全。
2. 中断注册系统注册中断回调。
3. work创建。
4. 连接上层组件接口(fs、net等)。

寄存器定义

推荐使用 tock-registers 库来定义寄存器。

定义寄存器结构体。
定义字段bit。

AI辅助

上下文提供手册，定义格式。

example: https://developer.arm.com/documentation/ddi0183/g/programmers-model/summary-of-registers

锁的实现

spinlock、atomic

中断

设备树中的中断信息

中断handler

基于中断的异步模式

原理概述

在传统的驱动开发中，中断处理通常使用回调函数或状态机来管理设备状态的变化。而基于中断的异步模式利用Rust的async/await语法，将中断驱动的状态变化转换为异步任务，使代码更加直观和易于维护。

核心实现机制

1. Future和Waker机制

2. 中断处理器与异步任务的桥接

中断处理器通过Waker唤醒等待的异步任务

3. 驱动异步接口

与传统状态机模式的对比

传统状态机模式

#![allow(unused)]
fn main() {
enum DeviceState {
    Idle,
    Reading,
    Writing,
    Error,
}

struct Device {
    state: DeviceState,
    callback: Option<Box<dyn Fn(Result<Vec<u8>, Error>)>>,
}

impl Device {
    fn start_read(&mut self, callback: Box<dyn Fn(Result<Vec<u8>, Error>)>) {
        self.state = DeviceState::Reading;
        self.callback = Some(callback);
        // 启动硬件操作
    }
    
    fn handle_interrupt(&mut self) {
        match self.state {
            DeviceState::Reading => {
                let data = self.get_data();
                if let Some(callback) = self.callback.take() {
                    callback(Ok(data));
                }
                self.state = DeviceState::Idle;
            }
            // 其他状态处理...
        }
    }
}
}

异步模式优势

代码可读性：异步模式使用线性的控制流，避免了状态机的复杂状态转换逻辑
错误处理：可以使用标准的?操作符和try-catch模式处理错误
组合性：异步函数可以轻松组合和链式调用
资源管理：自动的生命周期管理，减少内存泄漏风险

实际应用示例

复杂设备操作的异步实现

#![allow(unused)]
fn main() {
impl NetworkDevice {
    pub async fn send_packet(&mut self, packet: &[u8]) -> Result<(), NetworkError> {
        // 1. 检查设备状态
        self.wait_device_ready().await?;
        
        // 2. 设置DMA传输
        self.setup_dma_transfer(packet).await?;
        
        // 3. 启动传输
        self.start_transmission();
        
        // 4. 等待传输完成中断
        self.wait_for_tx_complete().await?;
        
        // 5. 清理资源
        self.cleanup_dma();
        
        Ok(())
    }
    
    async fn wait_device_ready(&mut self) -> Result<(), NetworkError> {
        loop {
            if self.is_ready() {
                break Ok(());
            }
            
            // 等待状态变化中断
            self.wait_for_status_interrupt().await?;
            
            // 检查是否出现错误状态
            if self.has_error() {
                break Err(NetworkError::DeviceError);
            }
        }
    }
}
}

同步调用异步模型

spin_on 等效于 spin_loop

性能考虑

零成本抽象

Rust的异步实现是零成本抽象，编译后的代码性能与手写状态机相当：

Future在编译时被展开为状态机
无运行时开销的轮询机制
内存使用效率高

中断延迟优化

#![allow(unused)]
fn main() {
// 快速中断处理器，最小化中断处理时间
fn fast_interrupt_handler() {
    // 仅做必要的硬件操作
    let status = read_interrupt_status();
    clear_interrupt_flag();
    
    // 唤醒等待的异步任务
    task_awake(pid);
}

## 最佳实践

1. **中断处理器保持简洁**：只做必要的硬件操作，复杂逻辑移至异步任务
2. **合理使用超时**：避免异步任务无限等待
3. **错误传播**：充分利用`?`操作符进行错误传播
4. **资源清理**：使用RAII模式确保资源正确释放

这种基于中断的异步模式为驱动开发提供了一种现代化的解决方案，既保持了性能优势，又显著提高了代码的可维护性和可读性。
}

飞腾派驱动开发实验指导书