firmware for my Touchscreen E-Paper Input Module for Framework Laptop 16
1use core::mem::MaybeUninit;
2use crate::{syscall, SafeResult};
3use crate::syscall::SyscallNumber;
4
5#[repr(usize)]
6#[derive(Copy, Clone, Debug, Eq, PartialEq, strum::FromRepr)]
7#[cfg_attr(feature = "defmt", derive(defmt::Format))]
8pub enum KvStoreSyscall {
9 ReadKey = 0,
10 AppendKey = 1,
11 PutKey = 2,
12 InvalidateKey = 3,
13 ZeroiseKey = 4,
14}
15
16#[repr(C)]
17pub struct ReadKeyArgs {
18 pub key_len: usize,
19 pub key_ptr: *const u8,
20 pub buf_len: usize,
21 pub buf_ptr: *mut u8,
22}
23
24#[repr(C)]
25pub struct WriteKeyArgs {
26 pub key_len: usize,
27 pub key_ptr: *const u8,
28 pub value_len: usize,
29 pub value_ptr: *const u8,
30}
31
32#[repr(usize)]
33#[derive(Copy, Clone, Debug, Eq, PartialEq)]
34pub enum ReadKeyError {
35 FlashCorrupt,
36 InvalidChecksum,
37 NotFound,
38 BufferTooSmall(usize),
39}
40
41#[cfg(feature = "tickv")]
42impl TryFrom<tickv::ErrorCode> for ReadKeyError {
43 type Error = tickv::ErrorCode;
44
45 fn try_from(value: tickv::ErrorCode) -> Result<Self, Self::Error> {
46 use tickv::ErrorCode as E;
47
48 match value {
49 E::CorruptData => Ok(Self::FlashCorrupt),
50 E::InvalidCheckSum => Ok(Self::InvalidChecksum),
51 E::KeyNotFound => Ok(Self::NotFound),
52 E::BufferTooSmall(size) => Ok(Self::BufferTooSmall(size)),
53 _ => Err(value),
54 }
55 }
56}
57
58#[repr(usize)]
59#[derive(Copy, Clone, Debug, Eq, PartialEq)]
60pub enum AppendKeyError {
61 FlashCorrupt,
62 AlreadyExists,
63 RegionFull,
64 FlashFull,
65}
66
67#[cfg(feature = "tickv")]
68impl TryFrom<tickv::ErrorCode> for AppendKeyError {
69 type Error = tickv::ErrorCode;
70
71 fn try_from(value: tickv::ErrorCode) -> Result<Self, Self::Error> {
72 use tickv::ErrorCode as E;
73
74 match value {
75 E::CorruptData => Ok(Self::FlashCorrupt),
76 E::KeyAlreadyExists => Ok(Self::AlreadyExists),
77 E::RegionFull => Ok(Self::RegionFull),
78 E::FlashFull => Ok(Self::FlashFull),
79 _ => Err(value),
80 }
81 }
82}
83
84#[repr(usize)]
85#[derive(Copy, Clone, Debug, Eq, PartialEq)]
86pub enum PutKeyError {
87 FlashCorrupt,
88 RegionFull,
89 FlashFull,
90}
91
92#[cfg(feature = "tickv")]
93impl TryFrom<tickv::ErrorCode> for PutKeyError {
94 type Error = tickv::ErrorCode;
95
96 fn try_from(value: tickv::ErrorCode) -> Result<Self, Self::Error> {
97 use tickv::ErrorCode as E;
98
99 match value {
100 E::CorruptData => Ok(Self::FlashCorrupt),
101 E::RegionFull => Ok(Self::RegionFull),
102 E::FlashFull => Ok(Self::FlashFull),
103 _ => Err(value),
104 }
105 }
106}
107
108#[repr(usize)]
109#[derive(Copy, Clone, Debug, Eq, PartialEq)]
110pub enum DeleteKeyError {
111 FlashCorrupt,
112 NotFound,
113}
114
115#[cfg(feature = "tickv")]
116impl TryFrom<tickv::ErrorCode> for DeleteKeyError {
117 type Error = tickv::ErrorCode;
118
119 fn try_from(value: tickv::ErrorCode) -> Result<Self, Self::Error> {
120 use tickv::ErrorCode as E;
121
122 match value {
123 E::CorruptData => Ok(Self::FlashCorrupt),
124 E::KeyNotFound => Ok(Self::NotFound),
125 _ => Err(value),
126 }
127 }
128}
129
130pub fn get(key: &[u8], buf: &mut [u8]) -> Result<usize, ReadKeyError> {
131 let args = ReadKeyArgs {
132 key_len: key.len(),
133 key_ptr: key.as_ptr(),
134 buf_len: buf.len(),
135 buf_ptr: buf.as_mut_ptr(),
136 };
137 let mut res: MaybeUninit<SafeResult<usize, ReadKeyError>> = MaybeUninit::uninit();
138
139 unsafe {
140 syscall!(
141 SyscallNumber::KvStore,
142 in KvStoreSyscall::ReadKey,
143 in &raw const args,
144 in res.as_mut_ptr(),
145 );
146
147 res.assume_init().into()
148 }
149}
150
151pub fn append(key: &[u8], value: &[u8]) -> Result<(), AppendKeyError> {
152 let args = WriteKeyArgs {
153 key_len: key.len(),
154 key_ptr: key.as_ptr(),
155 value_len: value.len(),
156 value_ptr: value.as_ptr(),
157 };
158 let mut res: MaybeUninit<SafeResult<(), AppendKeyError>> = MaybeUninit::uninit();
159
160 unsafe {
161 syscall!(
162 SyscallNumber::KvStore,
163 in KvStoreSyscall::AppendKey,
164 in &raw const args,
165 in res.as_mut_ptr(),
166 );
167
168 res.assume_init().into()
169 }
170}
171
172pub fn put(key: &[u8], value: &[u8]) -> Result<(), PutKeyError> {
173 let args = WriteKeyArgs {
174 key_len: key.len(),
175 key_ptr: key.as_ptr(),
176 value_len: value.len(),
177 value_ptr: value.as_ptr(),
178 };
179 let mut res: MaybeUninit<SafeResult<(), PutKeyError>> = MaybeUninit::uninit();
180
181 unsafe {
182 syscall!(
183 SyscallNumber::KvStore,
184 in KvStoreSyscall::PutKey,
185 in &raw const args,
186 in res.as_mut_ptr(),
187 );
188
189 res.assume_init().into()
190 }
191}
192
193pub fn invalidate(key: &[u8]) -> Result<(), DeleteKeyError> {
194 let mut res: MaybeUninit<SafeResult<(), DeleteKeyError>> = MaybeUninit::uninit();
195
196 unsafe {
197 syscall!(
198 SyscallNumber::KvStore,
199 in KvStoreSyscall::InvalidateKey,
200 in key.as_ptr(),
201 in key.len(),
202 in res.as_mut_ptr(),
203 );
204
205 res.assume_init().into()
206 }
207}
208
209pub fn zeroise(key: &[u8]) -> Result<(), DeleteKeyError> {
210 let mut res: MaybeUninit<SafeResult<(), DeleteKeyError>> = MaybeUninit::uninit();
211
212 unsafe {
213 syscall!(
214 SyscallNumber::KvStore,
215 in KvStoreSyscall::ZeroiseKey,
216 in key.as_ptr(),
217 in key.len(),
218 in res.as_mut_ptr(),
219 );
220
221 res.assume_init().into()
222 }
223}