firmware for my Touchscreen E-Paper Input Module for Framework Laptop 16
eepy-sys: switch manual enum conversions to strum::FromRepr
+66
-197
+2
-1
Cargo.toml
+2
-1
Cargo.toml
+1
eepy-sys/Cargo.toml
+1
eepy-sys/Cargo.toml
+1
-13
eepy-sys/src/critical_section.rs
+1
-13
eepy-sys/src/critical_section.rs
···
1
1
#[repr(usize)]
2
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
2
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
3
3
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
4
4
pub enum CsSyscall {
5
5
Acquire = 0,
6
6
Release = 1,
7
-
}
8
-
9
-
impl TryFrom<usize> for CsSyscall {
10
-
type Error = ();
11
-
12
-
fn try_from(value: usize) -> Result<Self, Self::Error> {
13
-
match value {
14
-
x if x == CsSyscall::Acquire as usize => Ok(CsSyscall::Acquire),
15
-
x if x == CsSyscall::Release as usize => Ok(CsSyscall::Release),
16
-
_ => Err(()),
17
-
}
18
-
}
19
7
}
+1
-15
eepy-sys/src/flash.rs
+1
-15
eepy-sys/src/flash.rs
···
2
2
use crate::syscall::SyscallNumber;
3
3
4
4
#[repr(usize)]
5
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
5
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
6
6
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7
7
pub enum FlashSyscall {
8
8
Erase = 0,
9
9
Program = 1,
10
10
EraseAndProgram = 2,
11
11
InvalidateCache = 3,
12
-
}
13
-
14
-
impl TryFrom<usize> for FlashSyscall {
15
-
type Error = ();
16
-
17
-
fn try_from(value: usize) -> Result<Self, Self::Error> {
18
-
match value {
19
-
x if x == FlashSyscall::Erase as usize => Ok(FlashSyscall::Erase),
20
-
x if x == FlashSyscall::Program as usize => Ok(FlashSyscall::Program),
21
-
x if x == FlashSyscall::EraseAndProgram as usize => Ok(FlashSyscall::EraseAndProgram),
22
-
x if x == FlashSyscall::InvalidateCache as usize => Ok(FlashSyscall::InvalidateCache),
23
-
_ => Err(()),
24
-
}
25
-
}
26
12
}
27
13
28
14
pub unsafe fn erase(start_addr: u32, len: u32) {
+5
-30
eepy-sys/src/image.rs
+5
-30
eepy-sys/src/image.rs
···
3
3
use crate::syscall::SyscallNumber;
4
4
5
5
#[repr(usize)]
6
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
6
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
7
7
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
8
8
pub enum ImageSyscall {
9
9
WriteImage = 0,
10
10
Refresh = 1,
11
11
}
12
12
13
-
impl TryFrom<usize> for ImageSyscall {
14
-
type Error = ();
15
-
16
-
fn try_from(value: usize) -> Result<Self, Self::Error> {
17
-
match value {
18
-
x if x == ImageSyscall::WriteImage as usize => Ok(ImageSyscall::WriteImage),
19
-
x if x == ImageSyscall::Refresh as usize => Ok(ImageSyscall::Refresh),
20
-
_ => Err(()),
21
-
}
22
-
}
23
-
}
24
-
25
13
#[repr(usize)]
26
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
14
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
27
15
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
28
16
pub enum RefreshBlockMode {
29
-
NonBlocking,
30
-
BlockAcknowledge,
31
-
BlockFinish,
32
-
}
33
-
34
-
impl TryFrom<usize> for RefreshBlockMode {
35
-
type Error = ();
36
-
37
-
fn try_from(value: usize) -> Result<Self, Self::Error> {
38
-
match value {
39
-
x if x == RefreshBlockMode::NonBlocking as usize => Ok(RefreshBlockMode::NonBlocking),
40
-
x if x == RefreshBlockMode::BlockAcknowledge as usize => Ok(RefreshBlockMode::BlockAcknowledge),
41
-
x if x == RefreshBlockMode::BlockFinish as usize => Ok(RefreshBlockMode::BlockFinish),
42
-
_ => Err(()),
43
-
}
44
-
}
17
+
NonBlocking = 0,
18
+
BlockAcknowledge = 1,
19
+
BlockFinish = 2,
45
20
}
46
21
47
22
pub fn write_image(image: &[u8; IMAGE_BYTES]) {
+1
-14
eepy-sys/src/input.rs
+1
-14
eepy-sys/src/input.rs
···
4
4
use crate::syscall::SyscallNumber;
5
5
6
6
#[repr(usize)]
7
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
7
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
8
8
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
9
9
pub enum InputSyscall {
10
10
NextEvent = 0,
11
11
SetTouchEnabled = 1,
12
12
HasEvent = 2,
13
-
}
14
-
15
-
impl TryFrom<usize> for InputSyscall {
16
-
type Error = ();
17
-
18
-
fn try_from(value: usize) -> Result<Self, Self::Error> {
19
-
match value {
20
-
x if x == InputSyscall::NextEvent as usize => Ok(InputSyscall::NextEvent),
21
-
x if x == InputSyscall::SetTouchEnabled as usize => Ok(InputSyscall::SetTouchEnabled),
22
-
x if x == InputSyscall::HasEvent as usize => Ok(InputSyscall::HasEvent),
23
-
_ => Err(()),
24
-
}
25
-
}
26
13
}
27
14
28
15
pub fn next_event() -> Option<Event> {
+2
-29
eepy-sys/src/misc.rs
+2
-29
eepy-sys/src/misc.rs
···
6
6
use once_cell::sync::OnceCell;
7
7
8
8
#[repr(usize)]
9
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
9
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
10
10
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
11
11
pub enum MiscSyscall {
12
12
GetSerial = 0,
13
13
LogMessage = 1,
14
14
}
15
15
16
-
impl TryFrom<usize> for MiscSyscall {
17
-
type Error = ();
18
-
19
-
fn try_from(value: usize) -> Result<Self, Self::Error> {
20
-
match value {
21
-
x if x == MiscSyscall::GetSerial as usize => Ok(MiscSyscall::GetSerial),
22
-
x if x == MiscSyscall::LogMessage as usize => Ok(MiscSyscall::LogMessage),
23
-
_ => Err(()),
24
-
}
25
-
}
26
-
}
27
-
28
16
#[repr(usize)]
29
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
17
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
30
18
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
31
19
pub enum LogLevel {
32
20
Trace = 0,
···
34
22
Info = 2,
35
23
Warn = 3,
36
24
Error = 4,
37
-
}
38
-
39
-
impl TryFrom<usize> for LogLevel {
40
-
type Error = ();
41
-
42
-
fn try_from(value: usize) -> Result<Self, ()> {
43
-
match value {
44
-
x if x == LogLevel::Trace as usize => Ok(LogLevel::Trace),
45
-
x if x == LogLevel::Info as usize => Ok(LogLevel::Info),
46
-
x if x == LogLevel::Debug as usize => Ok(LogLevel::Debug),
47
-
x if x == LogLevel::Warn as usize => Ok(LogLevel::Warn),
48
-
x if x == LogLevel::Error as usize => Ok(LogLevel::Error),
49
-
_ => Err(()),
50
-
}
51
-
}
52
25
}
53
26
54
27
pub fn get_serial_raw() -> [u8; 16] {
+2
-19
eepy-sys/src/syscall.rs
+2
-19
eepy-sys/src/syscall.rs
···
1
1
#[repr(u8)]
2
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
2
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
3
3
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
4
4
pub enum SyscallNumber {
5
5
Misc = 0,
···
9
9
Exec = 4,
10
10
CriticalSection = 5,
11
11
Flash = 6,
12
-
}
13
-
14
-
impl TryFrom<u8> for SyscallNumber {
15
-
type Error = ();
16
-
17
-
fn try_from(value: u8) -> Result<Self, Self::Error> {
18
-
match value {
19
-
x if x == SyscallNumber::Misc as u8 => Ok(SyscallNumber::Misc),
20
-
x if x == SyscallNumber::Image as u8 => Ok(SyscallNumber::Image),
21
-
x if x == SyscallNumber::Input as u8 => Ok(SyscallNumber::Input),
22
-
x if x == SyscallNumber::Usb as u8 => Ok(SyscallNumber::Usb),
23
-
x if x == SyscallNumber::Exec as u8 => Ok(SyscallNumber::Exec),
24
-
x if x == SyscallNumber::CriticalSection as u8 => Ok(SyscallNumber::CriticalSection),
25
-
x if x == SyscallNumber::Flash as u8 => Ok(SyscallNumber::Flash),
26
-
_ => Err(()),
27
-
}
28
-
}
29
12
}
30
13
31
14
/// Perform a raw system call.
···
66
49
#[macro_export]
67
50
#[cfg(not(all(target_os = "none", target_arch = "arm")))]
68
51
macro_rules! syscall {
69
-
( $( $_foo:tt )* ) => { panic!("Cannot use eepyOS syscalls on non-eepyOS platforms") };
52
+
( $( $_foo:tt )* ) => { compile_error!("Cannot use eepyOS syscalls on non-eepyOS platforms") };
70
53
}
+1
-26
eepy-sys/src/usb.rs
+1
-26
eepy-sys/src/usb.rs
···
7
7
use crate::syscall::SyscallNumber;
8
8
9
9
#[repr(usize)]
10
-
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
10
+
#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
11
11
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
12
12
pub enum UsbSyscall {
13
13
UsbRet = 0,
···
24
24
SetStalled = 11,
25
25
IsStalled = 12,
26
26
Poll = 13,
27
-
}
28
-
29
-
impl TryFrom<usize> for UsbSyscall {
30
-
type Error = ();
31
-
32
-
fn try_from(value: usize) -> Result<Self, Self::Error> {
33
-
match value {
34
-
x if x == UsbSyscall::UsbRet as usize => Ok(UsbSyscall::UsbRet),
35
-
x if x == UsbSyscall::SetHandler as usize => Ok(UsbSyscall::SetHandler),
36
-
x if x == UsbSyscall::ClearHandler as usize => Ok(UsbSyscall::ClearHandler),
37
-
x if x == UsbSyscall::Init as usize => Ok(UsbSyscall::Init),
38
-
x if x == UsbSyscall::Uninit as usize => Ok(UsbSyscall::Uninit),
39
-
x if x == UsbSyscall::AllocEp as usize => Ok(UsbSyscall::AllocEp),
40
-
x if x == UsbSyscall::Enable as usize => Ok(UsbSyscall::Enable),
41
-
x if x == UsbSyscall::Reset as usize => Ok(UsbSyscall::Reset),
42
-
x if x == UsbSyscall::SetDeviceAddr as usize => Ok(UsbSyscall::SetDeviceAddr),
43
-
x if x == UsbSyscall::Write as usize => Ok(UsbSyscall::Write),
44
-
x if x == UsbSyscall::Read as usize => Ok(UsbSyscall::Read),
45
-
x if x == UsbSyscall::SetStalled as usize => Ok(UsbSyscall::SetStalled),
46
-
x if x == UsbSyscall::IsStalled as usize => Ok(UsbSyscall::IsStalled),
47
-
x if x == UsbSyscall::Poll as usize => Ok(UsbSyscall::Poll),
48
-
49
-
_ => Err(()),
50
-
}
51
-
}
52
27
}
53
28
54
29
pub fn set_handler(f: extern "C" fn()) {
+34
-34
eepy/src/syscall.rs
+34
-34
eepy/src/syscall.rs
···
26
26
27
27
trace!("syscall: sp={} imm={:x} {}", sp, syscall_num, stack_values);
28
28
29
-
match SyscallNumber::try_from(syscall_num) {
30
-
Ok(SyscallNumber::Misc) => misc::handle_misc(stack_values),
31
-
Ok(SyscallNumber::Image) => image::handle_image(stack_values),
32
-
Ok(SyscallNumber::Input) => input::handle_input(stack_values),
33
-
Ok(SyscallNumber::Usb) => crate::usb::handle_usb(stack_values),
34
-
Ok(SyscallNumber::Exec) => handle_exec(stack_values, using_psp),
35
-
Ok(SyscallNumber::CriticalSection) => cs::handle_cs(stack_values),
36
-
Ok(SyscallNumber::Flash) => flash::handle_flash(stack_values),
37
-
Err(_) => panic!("illegal syscall"),
29
+
match SyscallNumber::from_repr(syscall_num) {
30
+
Some(SyscallNumber::Misc) => misc::handle_misc(stack_values),
31
+
Some(SyscallNumber::Image) => image::handle_image(stack_values),
32
+
Some(SyscallNumber::Input) => input::handle_input(stack_values),
33
+
Some(SyscallNumber::Usb) => crate::usb::handle_usb(stack_values),
34
+
Some(SyscallNumber::Exec) => handle_exec(stack_values, using_psp),
35
+
Some(SyscallNumber::CriticalSection) => cs::handle_cs(stack_values),
36
+
Some(SyscallNumber::Flash) => flash::handle_flash(stack_values),
37
+
None => panic!("illegal syscall"),
38
38
}
39
39
}
40
40
···
97
97
use super::StackFrame;
98
98
99
99
pub(super) fn handle_misc(stack_values: &mut StackFrame) {
100
-
match MiscSyscall::try_from(stack_values.r0) {
101
-
Ok(MiscSyscall::GetSerial) => handle_get_serial(stack_values),
102
-
Ok(MiscSyscall::LogMessage) => handle_log_message(stack_values),
103
-
Err(_) => panic!("illegal syscall"),
100
+
match MiscSyscall::from_repr(stack_values.r0) {
101
+
Some(MiscSyscall::GetSerial) => handle_get_serial(stack_values),
102
+
Some(MiscSyscall::LogMessage) => handle_log_message(stack_values),
103
+
None => panic!("illegal syscall"),
104
104
}
105
105
}
106
106
···
112
112
}
113
113
114
114
fn handle_log_message(stack_values: &mut StackFrame) {
115
-
let log_level: LogLevel = stack_values.r1.try_into().expect("invalid log level");
115
+
let log_level = LogLevel::from_repr(stack_values.r1).expect("invalid log level");
116
116
let len = stack_values.r2;
117
117
let ptr = stack_values.r3 as *const u8;
118
118
let s = unsafe { core::str::from_utf8_unchecked(core::slice::from_raw_parts(ptr, len)) };
···
136
136
use super::StackFrame;
137
137
138
138
pub(super) fn handle_image(stack_values: &mut StackFrame) {
139
-
match ImageSyscall::try_from(stack_values.r0) {
140
-
Ok(ImageSyscall::WriteImage) => handle_write_image(stack_values),
141
-
Ok(ImageSyscall::Refresh) => handle_refresh(stack_values),
142
-
Err(_) => panic!("illegal syscall"),
139
+
match ImageSyscall::from_repr(stack_values.r0) {
140
+
Some(ImageSyscall::WriteImage) => handle_write_image(stack_values),
141
+
Some(ImageSyscall::Refresh) => handle_refresh(stack_values),
142
+
None => panic!("illegal syscall"),
143
143
}
144
144
}
145
145
···
150
150
151
151
fn handle_refresh(stack_values: &mut StackFrame) {
152
152
let fast_refresh = stack_values.r1 != 0;
153
-
let blocking_mode = RefreshBlockMode::try_from(stack_values.r2).expect("illegal refresh blocking mode");
153
+
let blocking_mode = RefreshBlockMode::from_repr(stack_values.r2).expect("illegal refresh blocking mode");
154
154
155
155
DO_REFRESH.store(true, Ordering::Relaxed);
156
156
FAST_REFRESH.store(fast_refresh, Ordering::Relaxed);
···
175
175
use super::StackFrame;
176
176
177
177
pub(super) fn handle_input(stack_values: &mut StackFrame) {
178
-
match InputSyscall::try_from(stack_values.r0) {
179
-
Ok(InputSyscall::NextEvent) => handle_next_event(stack_values),
180
-
Ok(InputSyscall::SetTouchEnabled) => handle_set_touch_enabled(stack_values),
181
-
Ok(InputSyscall::HasEvent) => handle_has_event(stack_values),
182
-
Err(_) => panic!("illegal syscall"),
178
+
match InputSyscall::from_repr(stack_values.r0) {
179
+
Some(InputSyscall::NextEvent) => handle_next_event(stack_values),
180
+
Some(InputSyscall::SetTouchEnabled) => handle_set_touch_enabled(stack_values),
181
+
Some(InputSyscall::HasEvent) => handle_has_event(stack_values),
182
+
None => panic!("illegal syscall"),
183
183
}
184
184
}
185
185
···
211
211
use crate::exception::StackFrame;
212
212
213
213
pub(super) fn handle_cs(stack_values: &mut StackFrame) {
214
-
match CsSyscall::try_from(stack_values.r0) {
215
-
Ok(CsSyscall::Acquire) => handle_acquire(stack_values),
216
-
Ok(CsSyscall::Release) => handle_release(stack_values),
217
-
Err(_) => panic!("illegal syscall"),
214
+
match CsSyscall::from_repr(stack_values.r0) {
215
+
Some(CsSyscall::Acquire) => handle_acquire(stack_values),
216
+
Some(CsSyscall::Release) => handle_release(stack_values),
217
+
None => panic!("illegal syscall"),
218
218
}
219
219
}
220
220
···
249
249
use crate::{FLASHING, FLASHING_ACK};
250
250
251
251
pub(super) fn handle_flash(stack_values: &mut StackFrame) {
252
-
match FlashSyscall::try_from(stack_values.r0) {
253
-
Ok(FlashSyscall::Erase) => handle_erase(stack_values),
254
-
Ok(FlashSyscall::Program) => handle_program(stack_values),
255
-
Ok(FlashSyscall::EraseAndProgram) => handle_erase_and_program(stack_values),
256
-
Ok(FlashSyscall::InvalidateCache) => handle_invalidate_cache(),
257
-
Err(_) => panic!("illegal syscall"),
252
+
match FlashSyscall::from_repr(stack_values.r0) {
253
+
Some(FlashSyscall::Erase) => handle_erase(stack_values),
254
+
Some(FlashSyscall::Program) => handle_program(stack_values),
255
+
Some(FlashSyscall::EraseAndProgram) => handle_erase_and_program(stack_values),
256
+
Some(FlashSyscall::InvalidateCache) => handle_invalidate_cache(),
257
+
None => panic!("illegal syscall"),
258
258
}
259
259
}
260
260
+16
-16
eepy/src/usb.rs
+16
-16
eepy/src/usb.rs
···
141
141
}
142
142
143
143
pub(crate) fn handle_usb(stack_values: &mut StackFrame) {
144
-
match UsbSyscall::try_from(stack_values.r0) {
145
-
Ok(UsbSyscall::UsbRet) => handle_usb_ret(stack_values),
146
-
Ok(UsbSyscall::SetHandler) => handle_set_handler(stack_values),
147
-
Ok(UsbSyscall::ClearHandler) => handle_clear_handler(),
148
-
Ok(UsbSyscall::Init) => handle_init(),
149
-
Ok(UsbSyscall::Uninit) => handle_uninit(),
150
-
Ok(UsbSyscall::AllocEp) => handle_alloc_ep(stack_values),
151
-
Ok(UsbSyscall::Enable) => handle_enable(),
152
-
Ok(UsbSyscall::Reset) => handle_reset(),
153
-
Ok(UsbSyscall::SetDeviceAddr) => handle_set_device_addr(stack_values),
154
-
Ok(UsbSyscall::Write) => handle_write(stack_values),
155
-
Ok(UsbSyscall::Read) => handle_read(stack_values),
156
-
Ok(UsbSyscall::SetStalled) => handle_set_stalled(stack_values),
157
-
Ok(UsbSyscall::IsStalled) => handle_is_stalled(stack_values),
158
-
Ok(UsbSyscall::Poll) => handle_poll(stack_values),
159
-
Err(_) => panic!("illegal syscall"),
144
+
match UsbSyscall::from_repr(stack_values.r0) {
145
+
Some(UsbSyscall::UsbRet) => handle_usb_ret(stack_values),
146
+
Some(UsbSyscall::SetHandler) => handle_set_handler(stack_values),
147
+
Some(UsbSyscall::ClearHandler) => handle_clear_handler(),
148
+
Some(UsbSyscall::Init) => handle_init(),
149
+
Some(UsbSyscall::Uninit) => handle_uninit(),
150
+
Some(UsbSyscall::AllocEp) => handle_alloc_ep(stack_values),
151
+
Some(UsbSyscall::Enable) => handle_enable(),
152
+
Some(UsbSyscall::Reset) => handle_reset(),
153
+
Some(UsbSyscall::SetDeviceAddr) => handle_set_device_addr(stack_values),
154
+
Some(UsbSyscall::Write) => handle_write(stack_values),
155
+
Some(UsbSyscall::Read) => handle_read(stack_values),
156
+
Some(UsbSyscall::SetStalled) => handle_set_stalled(stack_values),
157
+
Some(UsbSyscall::IsStalled) => handle_is_stalled(stack_values),
158
+
Some(UsbSyscall::Poll) => handle_poll(stack_values),
159
+
None => panic!("illegal syscall"),
160
160
}
161
161
}
162
162