rdrive 0.8.0

A dyn driver manager.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

# RDrive Rust 动态驱动组件

## 架构设计

### rdif-* 接口

硬件通用操作接口，为支持动态分发，接口均设计为 `dyn-compatible(object safe)`。

### rdrive-macros

便于驱动注册的宏。

### rdrive 动态驱动容器

驱动容器，负责驱动注册、遍历、所有权控制。

设备所有权设计为长期借用模式，通过 `Device<T>` 进行包装，不同于 `Mutex<T>`，当一个任务借用了设备后，会获取其所有权，其他任务在尝试借用时会得到 `Error` 并得到拥有者的任务ID，可用于强制关闭任务。借用者获取所有权后，可进行无锁操作。对 `Device<T>` 的复制会获取其弱指针，方便其他任务进行快速索引，在中断中可使用弱指针强制获取所有权。

驱动可在不同 `crate` 进行注册，可实现在一个单独文件中完成所有注册流程，例如：

```rust
module_driver!(
    name: "GICv3",
    probe_kinds: &[
        ProbeKind::Fdt {
            compatibles: &["arm,gic-v3"],
            on_probe: OnProbeKindFdt::Intc(probe_gic)
        }
    ]
);

fn probe_gic(node: Node<'_>) -> Result<FdtProbeInfo, Box<dyn Error>> {
    let mut reg = node.reg().ok_or(format!("[{}] has no reg", node.name))?;

    let gicd_reg = reg.next().unwrap();
    let gicr_reg = reg.next().unwrap();
    let gicd = iomap(
        (gicd_reg.address as usize).into(),
        gicd_reg.size.unwrap_or(0x1000),
    );
    let gicr = iomap(
        (gicr_reg.address as usize).into(),
        gicr_reg.size.unwrap_or(0x1000),
    );

    Ok(FdtProbeInfo {
        hardware: Box::new(Gic::new(gicd, gicr, Default::default())),
        fdt_parse_config_fn: fdt_parse_irq_config,
    })
}
```

上述代码完成了 `Gic` 驱动注册，在后续 `probe` 阶段会调用 `probe_gic` 函数进行驱动创建。

支持通过设备树遍历设备、静态配置设备。

## 系统适配

1. `LinkerScript` 添加：

    ```ld
    .driver.register : ALIGN(4K) {
        _sdriver = .;
        *(.driver.register .driver.register.*)
        _edriver = .;
        . = ALIGN(4K);
    }
    ```

2. 系统代码中添加：

    ```rust
    fn driver_registers() -> &'static [u8] {
        unsafe extern "C" {
            fn _sdriver();
            fn _edriver();
        }

        unsafe { &*slice_from_raw_parts(
            _sdriver as *const u8, 
            _edriver as usize - _sdriver as usize) }
    }

    fn driver_registers() -> DriverRegisterSlice {
        DriverRegisterSlice::from_raw(driver_registers())
    }

    ```

3. 初始化(设备树方式)：

    ```rust
    fn init() {
        let info = DriverInfoKind::Fdt {
            addr: // 设备树地址,
        };

        // 库初始化
        rdrive::init(info);

        // 添加驱动注册器
        rdrive::register_append(driver_registers().as_slice());

        // 其他设备依赖中断控制器，优先初始化
        rdrive::probe_intc().unwrap();

        irq::init_main_cpu();

        // 任务等功能依赖系统时钟，优先初始化
        rdrive::probe_timer().unwrap();

        time::init_current_cpu();
    }
    ```

4. 遍历设备：

    ```rust
    rdrive::probe().unwrap();
    ```

5. 获取设备：

    ```rust
    let mut ls = rdrive::read(|m| m.timer.all());
    let (_, timer) = ls.pop()?;

    let mut timer = timer.upgrade()?.spin_try_borrow_by(0.into());

    // 可自由使用 mut timer，此时其他任务尝试借用会返回 Error
    ```

可参照样例：

[初始化](https://github.com/qclic/sparreal-os/blob/main/crates/sparreal-kernel/src/driver/mod.rs)

[驱动注册](https://github.com/qclic/sparreal-os/blob/main/crates/sparreal-rt/src/arch/aarch64/gic/gic_v3.rs)

[设备获取](https://github.com/qclic/sparreal-os/blob/main/crates/sparreal-kernel/src/time/mod.rs)