use crate::event::{Signal, Timeout};
use core::cell::UnsafeCell;
pub const PIPE_CAPACITY: usize = 256;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PipeError {
Timeout,
Closed,
}
impl From<Timeout> for PipeError {
fn from(_: Timeout) -> Self {
PipeError::Timeout
}
}
impl core::fmt::Display for PipeError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
PipeError::Timeout => write!(f, "stream timed out"),
PipeError::Closed => write!(f, "stream closed"),
}
}
}
pub struct Pipe {
buf: UnsafeCell<[u8; PIPE_CAPACITY]>,
head: UnsafeCell<usize>,
tail: UnsafeCell<usize>,
data: Signal,
space: Signal,
}
unsafe impl Sync for Pipe {}
impl Default for Pipe {
fn default() -> Self {
Self::new()
}
}
impl Pipe {
pub const fn new() -> Self {
Pipe {
buf: UnsafeCell::new([0; PIPE_CAPACITY]),
head: UnsafeCell::new(0),
tail: UnsafeCell::new(0),
data: Signal::new(),
space: Signal::new(),
}
}
pub fn len(&self) -> usize {
let _g = crate::critical::enter();
let (h, t) = unsafe { (*self.head.get(), *self.tail.get()) };
drop(_g);
h.wrapping_sub(t)
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn room(&self) -> usize {
PIPE_CAPACITY - self.len()
}
pub fn push_from_isr(&self, b: u8) -> bool {
let ok = {
let _g = crate::critical::enter();
let (h, t) = unsafe { (*self.head.get(), *self.tail.get()) };
if h.wrapping_sub(t) >= PIPE_CAPACITY {
false
} else {
let idx = h & (PIPE_CAPACITY - 1);
unsafe {
(*self.buf.get())[idx] = b;
*self.head.get() = h.wrapping_add(1);
}
true
}
};
if ok {
self.data.set();
}
ok
}
pub fn pop_into(&self, out: &mut [u8]) -> usize {
let n = {
let _g = crate::critical::enter();
let (h, t) = unsafe { (*self.head.get(), *self.tail.get()) };
let avail = h.wrapping_sub(t).min(out.len());
for (i, slot) in out.iter_mut().take(avail).enumerate() {
*slot = unsafe { (*self.buf.get())[t.wrapping_add(i) & (PIPE_CAPACITY - 1)] };
}
unsafe { *self.tail.get() = t.wrapping_add(avail) };
avail
};
if n > 0 {
self.space.set();
}
n
}
pub fn write_from_isr(&self, data: &[u8]) -> usize {
let n = {
let _g = crate::critical::enter();
let (h, t) = unsafe { (*self.head.get(), *self.tail.get()) };
let room = PIPE_CAPACITY - h.wrapping_sub(t);
let n = room.min(data.len());
for (i, b) in data.iter().take(n).enumerate() {
unsafe {
(*self.buf.get())[h.wrapping_add(i) & (PIPE_CAPACITY - 1)] = *b;
}
}
unsafe { *self.head.get() = h.wrapping_add(n) };
n
};
if n > 0 {
self.data.set();
}
n
}
pub fn data_signal(&self) -> &Signal {
&self.data
}
pub fn space_signal(&self) -> &Signal {
&self.space
}
pub fn read_blocking(&self, out: &mut [u8], deadline: Option<u64>) -> Result<usize, PipeError> {
loop {
let n = self.pop_into(out);
if n > 0 {
return Ok(n);
}
self.data.wait(deadline)?;
}
}
pub fn write_blocking(&self, data: &[u8], deadline: Option<u64>) -> Result<usize, PipeError> {
let mut written = 0;
while written < data.len() {
written += self.write_from_isr(&data[written..]);
if written == data.len() {
break;
}
self.space.wait(deadline)?;
}
Ok(written)
}
}
pub const DEFAULT_IO_TIMEOUT_MS: u64 = 1000;
fn default_deadline() -> u64 {
crate::scheduler::deadline_after_ticks(crate::time::ticks_for(
core::time::Duration::from_millis(DEFAULT_IO_TIMEOUT_MS),
))
}
mod blocking_io {
use super::*;
impl embedded_io::Error for PipeError {
fn kind(&self) -> embedded_io::ErrorKind {
match self {
PipeError::Timeout => embedded_io::ErrorKind::TimedOut,
PipeError::Closed => embedded_io::ErrorKind::BrokenPipe,
}
}
}
impl core::error::Error for PipeError {}
impl embedded_io::ErrorType for Pipe {
type Error = PipeError;
}
impl embedded_io::Read for Pipe {
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
self.read_blocking(buf, Some(default_deadline()))
}
}
impl embedded_io::Write for Pipe {
fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
self.write_blocking(buf, Some(default_deadline()))
}
fn flush(&mut self) -> Result<(), Self::Error> {
Ok(())
}
}
}
mod async_io {
use super::*;
impl embedded_io_async::Read for Pipe {
async fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
loop {
let n = self.pop_into(buf);
if n > 0 {
return Ok(n);
}
crate::exec::SignalWait::new(self.data_signal(), default_deadline()).await?;
}
}
}
impl embedded_io_async::Write for Pipe {
async fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
loop {
let n = self.write_from_isr(buf);
if n > 0 {
return Ok(n);
}
crate::exec::SignalWait::new(self.space_signal(), default_deadline()).await?;
}
}
async fn flush(&mut self) -> Result<(), Self::Error> {
Ok(())
}
}
}