kmwebnet/OpenSK
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Update third_party/libtock-drivers to support OpenSK.

Browse Source
This commit is contained in:
Guillaume Endignoux
2020-07-10 10:11:07 +02:00
parent 5f1fcaedf5
commit 467121c962
9 changed files with 414 additions and 857 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
third_party/libtock-drivers/Cargo.toml vendored
View File

@@ -1,67 +1,16 @@
[package]
name = "libtock"
version = "0.2.0"
authors = ["Tock Project Developers <tock-dev@googlegroups.com>"]
name = "libtock_drivers"
version = "0.1.0"
authors = [
"Tock Project Developers <tock-dev@googlegroups.com>"
"Guillaume Endignoux <guillaumee@google.com>",
]
license = "MIT/Apache-2.0"
edition = "2018"
[features]
alloc = ["libtock_core/alloc"]
custom_panic_handler = ["libtock_core/custom_panic_handler"]
custom_alloc_error_handler = ["libtock_core/custom_alloc_error_handler"]
__internal_disable_gpio_in_integration_test = []
[dependencies]
libtock_core = { path = "core" }
libtock_codegen = { path = "codegen" }
futures = { version = "0.3.1", default-features = false, features = ["unstable", "cfg-target-has-atomic"] }
libtock_core = { path = "../../third_party/libtock-rs/core" }
[dev-dependencies]
corepack = { version = "0.4.0", default-features = false, features = ["alloc"] }
# We pin the serde version because newer serde versions may not be compatible
# with the nightly toolchain used by libtock-rs.
serde = { version = "=1.0.84", default-features = false, features = ["derive"] }
[[example]]
name = "alloc_error"
path = "examples-features/alloc_error.rs"
required-features = ["alloc", "custom_alloc_error_handler"]
[[example]]
name = "ble_scanning"
path = "examples-features/ble_scanning.rs"
required-features = ["alloc"]
[[example]]
name = "libtock_test"
path = "examples-features/libtock_test.rs"
required-features = ["alloc"]
[[example]]
name = "panic"
path = "examples-features/panic.rs"
required-features = ["custom_panic_handler"]
[[example]]
name = "simple_ble"
path = "examples-features/simple_ble.rs"
required-features = ["alloc"]
[profile.dev]
panic = "abort"
lto = true
debug = true
[profile.release]
panic = "abort"
lto = true
debug = true
[workspace]
exclude = [ "tock" ]
members = [
"codegen",
"core",
"test_runner",
"tools/print_sizes",
]
[features]
debug_ctap = []
verbose_usb = ["debug_ctap"]

207
third_party/libtock-drivers/src/buttons.rs vendored
View File

@@ -1,10 +1,7 @@
use crate::callback::CallbackSubscription;
use crate::callback::Consumer;
use crate::result::OtherError;
use crate::result::OutOfRangeError;
use crate::result::TockResult;
use crate::syscalls;
use crate::result::{OtherError, TockResult};
use core::marker::PhantomData;
use libtock_core::callback::{CallbackSubscription, Consumer};
use libtock_core::syscalls;
const DRIVER_NUMBER: usize = 0x00003;
@@ -19,87 +16,98 @@ mod subscribe_nr {
pub const SUBSCRIBE_CALLBACK: usize = 0;
}
#[non_exhaustive]
pub struct ButtonsDriverFactory;
pub fn with_callback<CB>(callback: CB) -> WithCallback<CB> {
WithCallback { callback }
}
impl ButtonsDriverFactory {
pub fn init_driver(&mut self) -> TockResult<ButtonsDriver> {
let buttons_driver = ButtonsDriver {
num_buttons: syscalls::command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)?,
lifetime: PhantomData,
};
Ok(buttons_driver)
pub struct WithCallback<CB> {
callback: CB,
}
struct ButtonConsumer;
impl<CB: FnMut(usize, ButtonState)> Consumer<WithCallback<CB>> for ButtonConsumer {
fn consume(data: &mut WithCallback<CB>, button_num: usize, state: usize, _: usize) {
(data.callback)(button_num, state.into());
}
}
pub struct ButtonsDriver<'a> {
num_buttons: usize,
lifetime: PhantomData<&'a ()>,
}
impl<CB: FnMut(usize, ButtonState)> WithCallback<CB> {
pub fn init(&mut self) -> TockResult<Buttons> {
let count = syscalls::command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)?;
impl<'a> ButtonsDriver<'a> {
pub fn num_buttons(&self) -> usize {
self.num_buttons
}
/// Returns the button at 0-based index `button_num`
pub fn get(&self, button_num: usize) -> Result<Button, OutOfRangeError> {
if button_num < self.num_buttons {
Ok(Button {
button_num,
lifetime: PhantomData,
})
} else {
Err(OutOfRangeError)
}
}
pub fn buttons(&self) -> Buttons {
Buttons {
num_buttons: self.num_buttons,
curr_button: 0,
lifetime: PhantomData,
}
}
pub fn subscribe<CB: Fn(usize, ButtonState)>(
&self,
callback: &'a mut CB,
) -> TockResult<CallbackSubscription> {
syscalls::subscribe::<ButtonsEventConsumer, _>(
let subscription = syscalls::subscribe::<ButtonConsumer, _>(
DRIVER_NUMBER,
subscribe_nr::SUBSCRIBE_CALLBACK,
callback,
)
.map_err(Into::into)
}
}
self,
)?;
struct ButtonsEventConsumer;
impl<CB: Fn(usize, ButtonState)> Consumer<CB> for ButtonsEventConsumer {
fn consume(callback: &mut CB, button_num: usize, button_state: usize, _: usize) {
let button_state = match button_state {
0 => ButtonState::Released,
1 => ButtonState::Pressed,
_ => return,
};
callback(button_num, button_state);
Ok(Buttons {
count: count as usize,
subscription,
})
}
}
pub struct Buttons<'a> {
num_buttons: usize,
count: usize,
#[allow(dead_code)] // Used in drop
subscription: CallbackSubscription<'a>,
}
#[derive(Copy, Clone, Debug)]
pub enum ButtonsError {
NotSupported,
SubscriptionFailed,
}
impl<'a> Buttons<'a> {
pub fn iter_mut(&mut self) -> ButtonIter {
ButtonIter {
curr_button: 0,
button_count: self.count,
lifetime: PhantomData,
}
}
}
#[derive(Copy, Clone, Debug)]
pub enum ButtonState {
Pressed,
Released,
}
impl From<usize> for ButtonState {
fn from(state: usize) -> ButtonState {
match state {
0 => ButtonState::Released,
1 => ButtonState::Pressed,
_ => unreachable!(),
}
}
}
impl<'a, 'b> IntoIterator for &'b mut Buttons<'a> {
type Item = ButtonHandle<'b>;
type IntoIter = ButtonIter<'b>;
fn into_iter(self) -> Self::IntoIter {
self.iter_mut()
}
}
pub struct ButtonIter<'a> {
curr_button: usize,
button_count: usize,
lifetime: PhantomData<&'a ()>,
}
impl<'a> Iterator for Buttons<'a> {
type Item = Button<'a>;
impl<'a> Iterator for ButtonIter<'a> {
type Item = ButtonHandle<'a>;
fn next(&mut self) -> Option<Self::Item> {
if self.curr_button < self.num_buttons {
let item = Button {
if self.curr_button < self.button_count {
let item = ButtonHandle {
button_num: self.curr_button,
lifetime: PhantomData,
};
@@ -111,57 +119,52 @@ impl<'a> Iterator for Buttons<'a> {
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum ButtonState {
Pressed,
Released,
}
impl From<ButtonState> for bool {
fn from(button_state: ButtonState) -> Self {
match button_state {
ButtonState::Released => false,
ButtonState::Pressed => true,
}
}
}
pub struct Button<'a> {
pub struct ButtonHandle<'a> {
button_num: usize,
lifetime: PhantomData<&'a ()>,
}
impl<'a> Button<'a> {
pub fn button_num(&self) -> usize {
self.button_num
}
pub fn read(&self) -> TockResult<ButtonState> {
let button_state = syscalls::command(DRIVER_NUMBER, command_nr::READ, self.button_num, 0)?;
match button_state {
0 => Ok(ButtonState::Released),
1 => Ok(ButtonState::Pressed),
_ => Err(OtherError::ButtonsDriverInvalidState.into()),
}
}
pub fn enable_interrupt(&self) -> TockResult<()> {
impl<'a> ButtonHandle<'a> {
pub fn enable(&mut self) -> TockResult<Button> {
syscalls::command(
DRIVER_NUMBER,
command_nr::ENABLE_INTERRUPT,
self.button_num,
0,
)?;
Ok(())
Ok(Button { handle: self })
}
pub fn disable_interrupt(&self) -> TockResult<()> {
pub fn disable(&mut self) -> TockResult<()> {
syscalls::command(
DRIVER_NUMBER,
command_nr::DISABLE_INTERRUPT,
self.button_num,
0,
)?;
Ok(())
}
}
pub struct Button<'a> {
handle: &'a ButtonHandle<'a>,
}
#[derive(Copy, Clone, Debug)]
pub enum ButtonError {
ActivationFailed,
}
impl<'a> Button<'a> {
pub fn read(&self) -> TockResult<ButtonState> {
let button_state =
syscalls::command(DRIVER_NUMBER, command_nr::READ, self.handle.button_num, 0)?;
match button_state {
0 => Ok(ButtonState::Released),
1 => Ok(ButtonState::Pressed),
_ => Err(OtherError::ButtonsDriverInvalidState.into()),
}
}
}

109
third_party/libtock-drivers/src/console.rs vendored
View File

@@ -1,11 +1,7 @@
use crate::callback::Identity0Consumer;
use crate::executor;
use crate::futures;
use crate::result::TockResult;
use crate::syscalls;
use crate::util;
use core::cell::Cell;
use core::fmt;
use core::mem;
use libtock_core::{callback, syscalls};
const DRIVER_NUMBER: usize = 1;
@@ -21,62 +17,97 @@ mod allow_nr {
pub const SHARE_BUFFER: usize = 1;
}
#[non_exhaustive]
pub struct ConsoleDriver;
impl ConsoleDriver {
pub fn create_console(self) -> Console {
Console {
allow_buffer: [0; 64],
}
}
}
const BUFFER_SIZE: usize = 1024;
pub struct Console {
allow_buffer: [u8; 64],
allow_buffer: [u8; BUFFER_SIZE],
count_pending: usize,
}
impl Console {
pub fn write<S: AsRef<[u8]>>(&mut self, text: S) -> TockResult<()> {
let mut not_written_yet = text.as_ref();
while !not_written_yet.is_empty() {
let num_bytes_to_print = self.allow_buffer.len().min(not_written_yet.len());
self.allow_buffer[..num_bytes_to_print]
.copy_from_slice(&not_written_yet[..num_bytes_to_print]);
self.flush(num_bytes_to_print)?;
not_written_yet = &not_written_yet[num_bytes_to_print..];
pub fn new() -> Console {
Console {
allow_buffer: [0; BUFFER_SIZE],
count_pending: 0,
}
Ok(())
}
fn flush(&mut self, num_bytes_to_print: usize) -> TockResult<()> {
let shared_memory = syscalls::allow(
fn is_empty(&self) -> bool {
self.count_pending == 0
}
fn is_full(&self) -> bool {
self.allow_buffer.len() == self.count_pending
}
fn available_len(&self) -> usize {
self.allow_buffer.len() - self.count_pending
}
pub fn write<S: AsRef<[u8]>>(&mut self, text: S) {
let mut not_written_yet = text.as_ref();
while !not_written_yet.is_empty() {
let num_bytes_to_print = self.available_len().min(not_written_yet.len());
self.allow_buffer[self.count_pending..(self.count_pending + num_bytes_to_print)]
.copy_from_slice(&not_written_yet[..num_bytes_to_print]);
self.count_pending += num_bytes_to_print;
if self.is_full() {
self.flush();
}
not_written_yet = &not_written_yet[num_bytes_to_print..];
}
}
pub fn flush(&mut self) {
if self.is_empty() {
// Don't trigger any syscall if the buffer is empty.
return;
}
let count = self.count_pending;
// Clear the buffer even in case of error, to avoid an infinite loop.
self.count_pending = 0;
let result = syscalls::allow(
DRIVER_NUMBER,
allow_nr::SHARE_BUFFER,
&mut self.allow_buffer[..num_bytes_to_print],
)?;
&mut self.allow_buffer[..count],
);
if result.is_err() {
return;
}
let is_written = Cell::new(false);
let mut is_written_alarm = || is_written.set(true);
let subscription = syscalls::subscribe::<Identity0Consumer, _>(
let subscription = syscalls::subscribe::<callback::Identity0Consumer, _>(
DRIVER_NUMBER,
subscribe_nr::SET_ALARM,
&mut is_written_alarm,
)?;
);
if subscription.is_err() {
return;
}
syscalls::command(DRIVER_NUMBER, command_nr::WRITE, num_bytes_to_print, 0)?;
let result_code = syscalls::command(DRIVER_NUMBER, command_nr::WRITE, count, 0);
if result_code.is_err() {
return;
}
unsafe { executor::block_on(futures::wait_until(|| is_written.get())) };
util::yieldk_for(|| is_written.get());
}
}
mem::drop(subscription);
mem::drop(shared_memory);
Ok(())
impl Drop for Console {
fn drop(&mut self) {
self.flush();
}
}
impl fmt::Write for Console {
fn write_str(&mut self, string: &str) -> Result<(), fmt::Error> {
self.write(string).map_err(|_| fmt::Error)
self.write(string);
Ok(())
}
}

173
third_party/libtock-drivers/src/led.rs vendored
View File

@@ -1,7 +1,5 @@
use crate::result::OutOfRangeError;
use crate::result::TockResult;
use crate::syscalls::command;
use core::marker::PhantomData;
use crate::result::{OtherError, TockError, TockResult};
use libtock_core::syscalls;
const DRIVER_NUMBER: usize = 0x00002;
@@ -12,64 +10,70 @@ mod command_nr {
pub const TOGGLE: usize = 3;
}
#[non_exhaustive]
pub struct LedsDriverFactory;
pub struct Led {
led_num: usize,
}
impl LedsDriverFactory {
pub fn init_driver(&mut self) -> TockResult<LedsDriver> {
let driver = LedsDriver {
num_leds: command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)?,
lifetime: PhantomData,
};
Ok(driver)
pub fn count() -> TockResult<usize> {
let count = syscalls::command(DRIVER_NUMBER, command_nr::COUNT, 0, 0)?;
Ok(count)
}
pub fn get(led_num: usize) -> TockResult<Led> {
let led_count = count()?;
if led_num < led_count {
Ok(Led { led_num })
} else {
Err(TockError::Other(OtherError::OutOfRange))
}
}
pub struct LedsDriver<'a> {
num_leds: usize,
lifetime: PhantomData<&'a ()>,
pub fn all() -> TockResult<LedIter> {
let led_count = count()?;
Ok(LedIter {
curr_led: 0,
led_count,
})
}
impl<'a> LedsDriver<'a> {
pub fn num_leds(&self) -> usize {
self.num_leds
}
pub fn leds(&self) -> Leds {
Leds {
num_leds: self.num_leds,
curr_led: 0,
lifetime: PhantomData,
}
}
/// Returns the led at 0-based index `led_num`
pub fn get(&self, led_num: usize) -> Result<Led, OutOfRangeError> {
if led_num < self.num_leds {
Ok(Led {
led_num,
lifetime: PhantomData,
})
impl Led {
pub fn set_state(&self, state: bool) -> TockResult<()> {
if state {
self.on()
} else {
Err(OutOfRangeError)
self.off()
}
}
pub fn on(&self) -> TockResult<()> {
syscalls::command(DRIVER_NUMBER, command_nr::ON, self.led_num, 0)?;
Ok(())
}
pub fn off(&self) -> TockResult<()> {
syscalls::command(DRIVER_NUMBER, command_nr::OFF, self.led_num, 0)?;
Ok(())
}
pub fn toggle(&self) -> TockResult<()> {
syscalls::command(DRIVER_NUMBER, command_nr::TOGGLE, self.led_num, 0)?;
Ok(())
}
}
pub struct Leds<'a> {
num_leds: usize,
#[derive(Copy, Clone)]
pub struct LedIter {
curr_led: usize,
lifetime: PhantomData<&'a ()>,
led_count: usize,
}
impl<'a> Iterator for Leds<'a> {
type Item = Led<'a>;
impl Iterator for LedIter {
type Item = Led;
fn next(&mut self) -> Option<Self::Item> {
if self.curr_led < self.num_leds {
if self.curr_led < self.led_count {
let item = Led {
led_num: self.curr_led,
lifetime: PhantomData,
};
self.curr_led += 1;
Some(item)
@@ -78,84 +82,3 @@ impl<'a> Iterator for Leds<'a> {
}
}
}
pub struct Led<'a> {
led_num: usize,
lifetime: PhantomData<&'a ()>,
}
impl<'a> Led<'a> {
pub fn led_num(&self) -> usize {
self.led_num
}
pub fn set(&self, state: impl Into<LedState>) -> TockResult<()> {
match state.into() {
LedState::On => self.on(),
LedState::Off => self.off(),
}
}
pub fn on(&self) -> TockResult<()> {
command(DRIVER_NUMBER, command_nr::ON, self.led_num, 0)?;
Ok(())
}
pub fn off(&self) -> TockResult<()> {
command(DRIVER_NUMBER, command_nr::OFF, self.led_num, 0)?;
Ok(())
}
pub fn toggle(&self) -> TockResult<()> {
command(DRIVER_NUMBER, command_nr::TOGGLE, self.led_num, 0)?;
Ok(())
}
}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
pub enum LedState {
On,
Off,
}
impl From<bool> for LedState {
fn from(from_value: bool) -> Self {
if from_value {
LedState::On
} else {
LedState::Off
}
}
}
#[cfg(test)]
mod test {
use super::command_nr;
use super::DRIVER_NUMBER;
use crate::result::TockResult;
use crate::syscalls;
use crate::syscalls::raw::Event;
#[test]
pub fn single_led_can_be_enabled() {
let events = syscalls::raw::run_recording_events::<TockResult<()>, _>(|next_return| {
let mut drivers = unsafe { crate::drivers::retrieve_drivers_unsafe() };
next_return.set(1);
let leds_driver = drivers.leds.init_driver()?;
next_return.set(0);
let led = leds_driver.get(0)?;
led.on()?;
Ok(())
});
assert_eq!(
events,
vec![
Event::Command(DRIVER_NUMBER, command_nr::COUNT, 0, 0),
Event::Command(DRIVER_NUMBER, command_nr::ON, 0, 0),
]
);
}
}

23
third_party/libtock-drivers/src/lib.rs vendored
View File

@@ -1,25 +1,10 @@
#![cfg_attr(not(test), no_std)]
#![no_std]
pub mod adc;
pub mod ble_composer;
pub mod ble_parser;
pub mod buttons;
pub mod console;
pub mod debug;
pub mod drivers;
pub mod electronics;
pub mod executor;
pub mod futures;
pub mod gpio;
pub mod hmac;
pub mod leds;
pub mod led;
pub mod result;
pub mod rng;
pub mod sensors;
pub mod simple_ble;
pub mod temperature;
pub mod timer;
pub use drivers::retrieve_drivers;
pub use libtock_codegen::main;
pub use libtock_core::*;
pub mod usb_ctap_hid;
pub mod util;

68
third_party/libtock-drivers/src/result.rs vendored
View File

@@ -4,6 +4,32 @@ pub use libtock_core::result::*;
pub type TockResult<T> = Result<T, TockError>;
// We sometimes need to handle errors in a `TockResult` by calling `unwrap`. However,
// `Result::unwrap` requires that the error type implements `core::fmt::Debug`. Under the hood,
// this requires dynamic dispatch, which has non-negligible overhead on code size. Therefore errors
// don't derive from `Debug` in libtock-rs.
//
// Instead one can call `.ok().unwrap()` which relies on `Option::unwrap` and doesn't require any
// debugging of the error type.
//
// This trait allows to flexibly use `Result::unwrap` or `Option::unwrap` and is configured to do
// so depending on the `debug_ctap` feature.
pub trait FlexUnwrap<T> {
fn flex_unwrap(self) -> T;
}
impl<T> FlexUnwrap<T> for TockResult<T> {
#[cfg(feature = "debug_ctap")]
fn flex_unwrap(self) -> T {
self.unwrap()
}
#[cfg(not(feature = "debug_ctap"))]
fn flex_unwrap(self) -> T {
self.ok().unwrap()
}
}
#[derive(Copy, Clone)]
pub enum TockError {
Subscribe(SubscribeError),
@@ -13,10 +39,47 @@ pub enum TockError {
Other(OtherError),
}
#[cfg(not(any(target_arch = "arm", target_arch = "riscv32")))]
#[cfg(feature = "debug_ctap")]
impl core::fmt::Debug for TockError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
writeln!(f, "impl Debug only for test builds")
match self {
TockError::Subscribe(SubscribeError {
driver_number,
subscribe_number,
return_code,
}) => f
.debug_struct("SubscribeError")
.field("driver", driver_number)
.field("subscribe", subscribe_number)
.field("return_code", return_code)
.finish(),
TockError::Command(CommandError {
driver_number,
command_number,
arg1,
arg2,
return_code,
}) => f
.debug_struct("CommandError")
.field("driver", driver_number)
.field("command", command_number)
.field("arg1", arg1)
.field("arg2", arg2)
.field("return_code", return_code)
.finish(),
TockError::Allow(AllowError {
driver_number,
allow_number,
return_code,
}) => f
.debug_struct("AllowError")
.field("driver", driver_number)
.field("allow", allow_number)
.field("return_code", return_code)
.finish(),
TockError::Format => f.write_str("TockError::Format"),
TockError::Other(e) => e.fmt(f),
}
}
}
@@ -45,6 +108,7 @@ impl From<fmt::Error> for TockError {
}
#[derive(Copy, Clone)]
#[cfg_attr(feature = "debug_ctap", derive(Debug))]
pub enum OtherError {
ButtonsDriverInvalidState,
GpioDriverInvalidState,

49
third_party/libtock-drivers/src/rng.rs vendored
View File

@@ -1,9 +1,6 @@
use crate::callback::Identity0Consumer;
use crate::futures;
use crate::result::TockResult;
use crate::syscalls;
use crate::util;
use core::cell::Cell;
use core::mem;
use libtock_core::{callback, syscalls};
const DRIVER_NUMBER: usize = 0x40001;
@@ -19,24 +16,30 @@ mod allow_nr {
pub const SHARE_BUFFER: usize = 0;
}
#[non_exhaustive]
pub struct RngDriver;
pub fn fill_buffer(buf: &mut [u8]) -> bool {
let buf_len = buf.len();
impl RngDriver {
pub async fn fill_buffer(&mut self, buf: &mut [u8]) -> TockResult<()> {
let buf_len = buf.len();
let shared_memory = syscalls::allow(DRIVER_NUMBER, allow_nr::SHARE_BUFFER, buf)?;
let is_filled = Cell::new(false);
let mut is_filled_alarm = || is_filled.set(true);
let subscription = syscalls::subscribe::<Identity0Consumer, _>(
DRIVER_NUMBER,
subscribe_nr::BUFFER_FILLED,
&mut is_filled_alarm,
)?;
syscalls::command(DRIVER_NUMBER, command_nr::REQUEST_RNG, buf_len, 0)?;
futures::wait_until(|| is_filled.get()).await;
mem::drop(subscription);
mem::drop(shared_memory);
Ok(())
let result = syscalls::allow(DRIVER_NUMBER, allow_nr::SHARE_BUFFER, buf);
if result.is_err() {
return false;
}
let is_filled = Cell::new(false);
let mut is_filled_alarm = || is_filled.set(true);
let subscription = syscalls::subscribe::<callback::Identity0Consumer, _>(
DRIVER_NUMBER,
subscribe_nr::BUFFER_FILLED,
&mut is_filled_alarm,
);
if subscription.is_err() {
return false;
}
let result_code = syscalls::command(DRIVER_NUMBER, command_nr::REQUEST_RNG, buf_len, 0);
if result_code.is_err() {
return false;
}
util::yieldk_for(|| is_filled.get());
return true;
}

562
third_party/libtock-drivers/src/timer.rs vendored
View File

@@ -1,17 +1,12 @@
//! Async timer driver. Can be used for (non-busy) sleeping.
use crate::callback::CallbackSubscription;
use crate::callback::Consumer;
use crate::futures;
use crate::result::OtherError;
use crate::result::TockError;
use crate::result::TockResult;
use crate::result::EALREADY;
use crate::syscalls;
use crate::result::{FlexUnwrap, OtherError, TockError, TockResult};
use crate::util;
use core::cell::Cell;
use core::isize;
use core::marker::PhantomData;
use core::ops::{Add, AddAssign, Sub};
use libtock_core::callback::{CallbackSubscription, Consumer};
use libtock_core::result::{CommandError, EALREADY};
use libtock_core::syscalls;
const DRIVER_NUMBER: usize = 0x00000;
@@ -27,6 +22,33 @@ mod subscribe_nr {
pub const SUBSCRIBE_CALLBACK: usize = 0;
}
pub fn sleep(duration: Duration<isize>) -> TockResult<()> {
let expired = Cell::new(false);
let mut with_callback = with_callback(|_, _| expired.set(true));
let mut timer = with_callback.init().flex_unwrap();
let timer_alarm = timer.set_alarm(duration).flex_unwrap();
util::yieldk_for(|| expired.get());
match timer.stop_alarm(timer_alarm) {
Ok(())
| Err(TockError::Command(CommandError {
return_code: EALREADY,
..
})) => Ok(()),
Err(e) => Err(e),
}
}
pub fn with_callback<CB>(callback: CB) -> WithCallback<'static, CB> {
WithCallback {
callback,
clock_frequency: ClockFrequency { hz: 0 },
phantom: PhantomData,
}
}
pub struct WithCallback<'a, CB> {
callback: CB,
clock_frequency: ClockFrequency,
@@ -136,13 +158,13 @@ impl<'a> Timer<'a> {
}
}
#[derive(Copy, Clone, Debug)]
#[derive(Copy, Clone, Debug, PartialEq)]
pub struct ClockFrequency {
hz: usize,
}
impl ClockFrequency {
pub fn hz(self) -> usize {
pub fn hz(&self) -> usize {
self.hz
}
}
@@ -154,21 +176,53 @@ pub struct ClockValue {
}
impl ClockValue {
pub fn num_ticks(self) -> isize {
self.num_ticks
}
pub fn ms(self) -> isize {
if self.num_ticks.abs() < isize::MAX / 1000 {
(1000 * self.num_ticks) / self.clock_frequency.hz() as isize
} else {
1000 * (self.num_ticks / self.clock_frequency.hz() as isize)
pub const fn new(num_ticks: isize, clock_hz: usize) -> ClockValue {
ClockValue {
num_ticks,
clock_frequency: ClockFrequency { hz: clock_hz },
}
}
pub fn ms_f64(self) -> f64 {
pub fn num_ticks(&self) -> isize {
self.num_ticks
}
// Computes (value * factor) / divisor, even when value * factor >= isize::MAX.
fn scale_int(value: isize, factor: isize, divisor: isize) -> isize {
// As long as isize is not i64, this should be fine. If not, this is an alternative:
// factor * (value / divisor) + ((value % divisor) * factor) / divisor
((value as i64 * factor as i64) / divisor as i64) as isize
}
pub fn ms(&self) -> isize {
ClockValue::scale_int(self.num_ticks, 1000, self.clock_frequency.hz() as isize)
}
pub fn ms_f64(&self) -> f64 {
1000.0 * (self.num_ticks as f64) / (self.clock_frequency.hz() as f64)
}
pub fn wrapping_add(self, duration: Duration<isize>) -> ClockValue {
// This is a precision preserving formula for scaling an isize.
let duration_ticks =
ClockValue::scale_int(duration.ms, self.clock_frequency.hz() as isize, 1000);
ClockValue {
num_ticks: self.num_ticks.wrapping_add(duration_ticks),
clock_frequency: self.clock_frequency,
}
}
pub fn wrapping_sub(self, other: ClockValue) -> Option<Duration<isize>> {
if self.clock_frequency == other.clock_frequency {
let clock_duration = ClockValue {
num_ticks: self.num_ticks - other.num_ticks,
clock_frequency: self.clock_frequency,
};
Some(Duration::from_ms(clock_duration.ms()))
} else {
None
}
}
}
pub struct Alarm {
@@ -278,467 +332,3 @@ where
self.ms += duration.ms();
}
}
#[derive(Copy, Clone, Default, PartialEq, Eq)]
pub(crate) struct ActiveTimer {
instant: u32,
set_at: u32,
}
/// Context for the time driver.
/// You can create a context as follows:
/// ```no_run
/// # use libtock::result::TockResult;
/// # async fn doc() -> TockResult<()> {
/// let mut drivers = libtock::retrieve_drivers()?;
/// let mut timer_context = drivers.timer;
/// # Ok(())
/// # }
/// ```
#[non_exhaustive]
pub struct DriverContext {
pub(crate) active_timer: Cell<Option<ActiveTimer>>,
}
impl DriverContext {
/// Create a driver timer from a context.
pub fn create_timer_driver(&mut self) -> TimerDriver {
TimerDriver {
callback: Callback,
context: self,
}
}
pub fn with_callback<CB>(&mut self, callback: CB) -> WithCallback<CB> {
WithCallback {
callback,
clock_frequency: ClockFrequency { hz: 0 },
phantom: PhantomData,
}
}
}
/// Timer driver instance. You can create a TimerDriver from a DriverContext as follows:
/// ```no_run
/// # use libtock::result::TockResult;
/// # async fn doc() -> TockResult<()> {
/// # let mut drivers = libtock::retrieve_drivers()?;
/// # let mut timer_context = drivers.timer;
/// let mut timer_driver = timer_context.create_timer_driver();
/// let timer_driver = timer_driver.activate()?;
/// # Ok(())
/// # }
/// ```
pub struct TimerDriver<'a> {
callback: Callback,
context: &'a DriverContext,
}
struct Callback;
struct ParallelTimerConsumer;
impl<'a> Consumer<Callback> for ParallelTimerConsumer {
fn consume(_: &mut Callback, _: usize, _: usize, _: usize) {}
}
/// Activated time driver. Updates current time in the context and manages
/// active alarms.
/// Example usage (sleep for 1 second):
/// ```no_run
/// # use libtock::result::TockResult;
/// # use libtock::timer::Duration;
/// # async fn doc() -> TockResult<()> {
/// # let mut drivers = libtock::retrieve_drivers()?;
/// # let mut timer_driver = drivers.timer.create_timer_driver();
/// let timer_driver = timer_driver.activate()?;
/// timer_driver.sleep(Duration::from_ms(1000)).await?;
/// # Ok(())
/// # }
/// ```
pub struct ParallelSleepDriver<'a> {
_callback_subscription: CallbackSubscription<'a>,
context: &'a DriverContext,
}
impl<'a> TimerDriver<'a> {
/// Activate the timer driver, will return a ParallelSleepDriver which
/// can used to sleep.
pub fn activate(&'a mut self) -> TockResult<ParallelSleepDriver<'a>> {
let subscription = syscalls::subscribe::<ParallelTimerConsumer, _>(
DRIVER_NUMBER,
subscribe_nr::SUBSCRIBE_CALLBACK,
&mut self.callback,
)?;
let driver = ParallelSleepDriver {
_callback_subscription: subscription,
context: &self.context,
};
Ok(driver)
}
}
impl<'a> ParallelSleepDriver<'a> {
/// Sleep for the given duration
pub async fn sleep(&self, duration: Duration<usize>) -> TockResult<()> {
let now = get_current_ticks()?;
let freq = get_clock_frequency()?;
let alarm_instant = Self::compute_alarm_instant(duration.ms, now, freq)?;
let this_alarm = ActiveTimer {
instant: alarm_instant as u32,
set_at: now as u32,
};
let suspended_timer: Cell<Option<ActiveTimer>> = Cell::new(None);
futures::wait_until(|| {
self.activate_current_timer(this_alarm, &suspended_timer)
.unwrap_or(false)
})
.await;
Ok(())
}
fn activate_timer(&self, timer: ActiveTimer) -> TockResult<()> {
set_alarm_at(timer.instant as usize)?;
let now = get_current_ticks()?;
if !is_over(timer, now as u32) {
self.context.active_timer.set(Some(timer));
} else {
self.wakeup_soon()?;
}
Ok(())
}
fn wakeup_soon(&self) -> TockResult<()> {
self.context.active_timer.set(None);
for i in 0.. {
let now = get_current_ticks()?;
let next_timer = ActiveTimer {
instant: now as u32 + i,
set_at: now as u32,
};
set_alarm_at(next_timer.instant as usize)?;
let now = get_current_ticks()?;
if !is_over(next_timer, now as u32) {
break;
} else {
stop_alarm_at(next_timer.instant as usize)?;
}
}
Ok(())
}
fn compute_alarm_instant(
duration_ms: usize,
num_ticks: usize,
freq: usize,
) -> TockResult<usize> {
let ticks = match duration_ms.checked_mul(freq) {
Some(x) => x / 1000,
None => {
// Divide the largest of the two operands by 1000, to improve precision of the
// result.
if duration_ms > freq {
match (duration_ms / 1000).checked_mul(freq) {
Some(y) => y,
None => {
return Err(TockError::Other(OtherError::TimerDriverDurationOutOfRange))
}
}
} else {
match (freq / 1000).checked_mul(duration_ms) {
Some(y) => y,
None => {
return Err(TockError::Other(OtherError::TimerDriverDurationOutOfRange))
}
}
}
}
};
let alarm_instant = num_ticks + ticks;
Ok(alarm_instant)
}
fn activate_current_timer(
&self,
this_alarm: ActiveTimer,
suspended_timer: &Cell<Option<ActiveTimer>>,
) -> TockResult<bool> {
let now = get_current_ticks()?;
if let Some(active) = self.context.active_timer.get() {
if left_is_later(active, this_alarm) {
suspended_timer.set(Some(active));
self.activate_timer(this_alarm)?;
}
} else {
self.activate_timer(this_alarm)?;
}
if is_over(this_alarm, now as u32) {
if let Some(paused) = suspended_timer.get() {
self.activate_timer(paused)?;
} else {
self.context.active_timer.set(None);
}
Ok(true)
} else {
Ok(false)
}
}
}
fn get_current_ticks() -> TockResult<usize> {
syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_VALUE, 0, 0).map_err(|err| err.into())
}
fn set_alarm_at(instant: usize) -> TockResult<()> {
syscalls::command(DRIVER_NUMBER, command_nr::SET_ALARM, instant, 0)
.map(|_| ())
.map_err(|err| err.into())
}
fn stop_alarm_at(instant: usize) -> TockResult<()> {
match syscalls::command(DRIVER_NUMBER, command_nr::STOP_ALARM, instant, 0) {
Ok(_) => Ok(()),
Err(error) => match error.return_code {
EALREADY => Ok(()),
_ => Err(TockError::Command(error)),
},
}
}
fn get_clock_frequency() -> TockResult<usize> {
syscalls::command(DRIVER_NUMBER, command_nr::GET_CLOCK_FREQUENCY, 0, 0)
.map_err(|err| err.into())
}
fn is_over(timer: ActiveTimer, now: u32) -> bool {
now.wrapping_sub(timer.set_at) >= timer.instant.wrapping_sub(timer.set_at)
}
fn left_is_later(alarm_1: ActiveTimer, alarm_2: ActiveTimer) -> bool {
if alarm_1.set_at <= alarm_1.instant && alarm_2.set_at <= alarm_2.instant {
return alarm_1.instant > alarm_2.instant;
}
if alarm_1.set_at <= alarm_1.instant && alarm_2.set_at >= alarm_2.instant {
return false;
}
if alarm_1.set_at >= alarm_1.instant && alarm_2.set_at <= alarm_2.instant {
return true;
}
if alarm_1.set_at >= alarm_1.instant && alarm_2.set_at >= alarm_2.instant {
return alarm_1.instant > alarm_2.instant;
}
false
}
#[cfg(test)]
mod test {
use super::*;
#[test]
pub fn duration_bigger_than_frequency() {
let x = ParallelSleepDriver::compute_alarm_instant(10000, 0, 1000)
.ok()
.unwrap();
assert_eq!(x, 10000);
}
#[test]
pub fn frequency_bigger_than_duration() {
let x = ParallelSleepDriver::compute_alarm_instant(1000, 0, 10000)
.ok()
.unwrap();
assert_eq!(x, 10000);
}
#[test]
pub fn fails_if_duration_is_too_large() {
let x =
ParallelSleepDriver::compute_alarm_instant(core::usize::MAX, 0, core::usize::MAX - 1);
assert!(x.is_err());
}
#[test]
pub fn fails_if_frequency_is_too_large() {
let x =
ParallelSleepDriver::compute_alarm_instant(core::usize::MAX - 1, 0, core::usize::MAX);
assert!(x.is_err());
}
#[test]
pub fn alarm_before_systick_wrap_expired() {
assert_eq!(
super::is_over(
super::ActiveTimer {
instant: 2u32,
set_at: 1u32
},
3u32
),
true
);
}
#[test]
pub fn alarm_before_systick_wrap_not_expired() {
assert_eq!(
super::is_over(
super::ActiveTimer {
instant: 3u32,
set_at: 1u32
},
2u32
),
false
);
}
#[test]
pub fn alarm_after_systick_wrap_expired() {
assert_eq!(
super::is_over(
super::ActiveTimer {
instant: 1u32,
set_at: 3u32
},
2u32
),
true
);
}
#[test]
pub fn alarm_after_systick_wrap_time_before_systick_wrap_not_expired() {
assert_eq!(
super::is_over(
super::ActiveTimer {
instant: 1u32,
set_at: 3u32
},
4u32
),
false
);
}
#[test]
pub fn alarm_after_systick_wrap_time_after_systick_wrap_not_expired() {
assert_eq!(
super::is_over(
super::ActiveTimer {
instant: 1u32,
set_at: 3u32
},
0u32
),
false
);
}
#[test]
pub fn left_later_than_the_other_both_not_wrapped() {
let later = super::ActiveTimer {
instant: 3u32,
set_at: 1u32,
};
let earlier = super::ActiveTimer {
instant: 2u32,
set_at: 1u32,
};
assert_eq!(super::left_is_later(later, earlier), true);
}
#[test]
pub fn right_later_than_the_other_both_not_wrapped() {
let later = super::ActiveTimer {
instant: 2u32,
set_at: 1u32,
};
let earlier = super::ActiveTimer {
instant: 3u32,
set_at: 1u32,
};
assert_eq!(super::left_is_later(later, earlier), false);
}
#[test]
pub fn left_later_left_wrapped() {
let later = super::ActiveTimer {
instant: 1u32,
set_at: 3u32,
};
let earlier = super::ActiveTimer {
instant: 2u32,
set_at: 1u32,
};
assert_eq!(super::left_is_later(later, earlier), true);
}
#[test]
pub fn right_later_right_wrapped() {
let later = super::ActiveTimer {
instant: 3u32,
set_at: 1u32,
};
let earlier = super::ActiveTimer {
instant: 1u32,
set_at: 3u32,
};
assert_eq!(super::left_is_later(later, earlier), false);
}
#[test]
pub fn left_later_both_wrapped() {
let later = super::ActiveTimer {
instant: 2u32,
set_at: 3u32,
};
let earlier = super::ActiveTimer {
instant: 1u32,
set_at: 3u32,
};
assert_eq!(super::left_is_later(later, earlier), true);
}
#[test]
pub fn right_later_both_wrapped() {
let later = super::ActiveTimer {
instant: 1u32,
set_at: 3u32,
};
let earlier = super::ActiveTimer {
instant: 2u32,
set_at: 3u32,
};
assert_eq!(super::left_is_later(later, earlier), false);
}
#[test]
pub fn inequality_is_strict() {
let later = super::ActiveTimer {
instant: 2u32,
set_at: 1u32,
};
let earlier = super::ActiveTimer {
instant: 2u32,
set_at: 1u32,
};
assert_eq!(super::left_is_later(later, earlier), false);
}
#[test]
pub fn inequality_is_strict_wrapped() {
let later = super::ActiveTimer {
instant: 1u32,
set_at: 2u32,
};
let earlier = super::ActiveTimer {
instant: 1u32,
set_at: 2u32,
};
assert_eq!(super::left_is_later(later, earlier), false);
}
}

9
third_party/libtock-drivers/src/util.rs vendored Normal file
View File

@@ -0,0 +1,9 @@
use libtock_core::syscalls;
pub fn yieldk_for<F: Fn() -> bool>(cond: F) {
while !cond() {
unsafe {
syscalls::raw::yieldk();
}
}
}