ax-runtime 0.12.0

Runtime library of ArceOS
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

use alloc::{collections::VecDeque, sync::Arc};

use rdif_serial::Config;

use crate::{
    RuntimeError, RuntimeResult,
    task::sync::{Mutex, SpinLock, WaitQueue},
};

pub(super) const CONTROL_QUEUE_CAPACITY: usize = 32;

pub(super) enum ControlOp {
    Start(Config),
    AdoptFirmwareConsole,
    Shutdown,
    SetConfig(Config),
    DiscardRx,
    DiscardTx,
}

pub(super) struct ControlCommand {
    pub(super) op: ControlOp,
    completion: Arc<CommandCompletion>,
}

impl ControlCommand {
    pub(super) fn complete(self, result: RuntimeResult) {
        self.completion.complete(result);
    }
}

pub(super) struct DrainCompletion {
    completion: Arc<CommandCompletion>,
}

impl DrainCompletion {
    pub(super) fn complete(self, result: RuntimeResult) {
        self.completion.complete(result);
    }
}

pub(super) enum ControlRequest {
    Command(ControlCommand),
    DrainTx(DrainCompletion),
}

pub(super) struct ControlQueue {
    requests: SpinLock<VecDeque<ControlRequest>>,
}

impl ControlQueue {
    pub(super) fn new() -> Self {
        Self {
            requests: SpinLock::new(VecDeque::with_capacity(CONTROL_QUEUE_CAPACITY)),
        }
    }

    pub(super) fn submit(&self, op: ControlOp, notify: impl FnOnce()) -> RuntimeResult {
        let completion = Arc::new(CommandCompletion::new());
        {
            let mut requests = self.requests.lock_irqsave();
            if requests.len() == CONTROL_QUEUE_CAPACITY {
                return Err(RuntimeError::SerialControlBusy);
            }
            requests.push_back(ControlRequest::Command(ControlCommand {
                op,
                completion: completion.clone(),
            }));
        }
        notify();
        completion.wait()
    }

    pub(super) fn submit_drain(&self, notify: impl FnOnce()) -> RuntimeResult {
        let completion = Arc::new(CommandCompletion::new());
        {
            let mut requests = self.requests.lock_irqsave();
            if requests.len() == CONTROL_QUEUE_CAPACITY {
                return Err(RuntimeError::SerialControlBusy);
            }
            requests.push_back(ControlRequest::DrainTx(DrainCompletion {
                completion: completion.clone(),
            }));
        }
        notify();
        completion.wait()
    }

    pub(super) fn try_pop(&self) -> Option<ControlRequest> {
        self.requests.lock_irqsave().pop_front()
    }

    pub(super) fn has_pending(&self) -> bool {
        !self.requests.lock_irqsave().is_empty()
    }
}

struct CommandCompletion {
    result: Mutex<Option<RuntimeResult>>,
    wait: WaitQueue,
}

impl CommandCompletion {
    fn new() -> Self {
        Self {
            result: Mutex::new(None),
            wait: WaitQueue::new(),
        }
    }

    fn complete(&self, result: RuntimeResult) {
        *self.result.lock() = Some(result);
        self.wait.notify_all();
    }

    fn wait(&self) -> RuntimeResult {
        self.wait.wait_until(|| self.result.lock().is_some());
        self.result
            .lock()
            .take()
            .expect("serial command completion was published without a result")
    }
}