Merge pull request #1891 from hermit-os/embedded-io

refactor(io): use embedded-io traits

Author: mkroening

Cargo.lock

@@ -117,6 +117,7 @@ bitflags = "2"
 build-time = "0.1.3"
 cfg-if = "1"
 crossbeam-utils = { version = "0.8", default-features = false }
+embedded-io = "0.6"
 enum_dispatch = "0.3"
 fdt = { version = "0.1", features = ["pretty-printing"] }
 free-list = "0.3"

Cargo.toml

@@ -1,5 +1,8 @@
 use core::arch::asm;
-use core::mem::MaybeUninit;
+
+use embedded_io::{ErrorType, Read, ReadReady, Write};
+
+use crate::errno::Errno;
 
 pub(crate) struct SerialDevice {
 	pub addr: u32,
@@ -15,8 +18,27 @@ impl SerialDevice {
 
 		Self { addr: base as u32 }
 	}
+}
+
+impl ErrorType for SerialDevice {
+	type Error = Errno;
+}
+
+impl Read for SerialDevice {
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+		let _ = buf;
+		Ok(0)
+	}
+}
 
-	pub fn write(&self, buf: &[u8]) {
+impl ReadReady for SerialDevice {
+	fn read_ready(&mut self) -> Result<bool, Self::Error> {
+		Ok(false)
+	}
+}
+
+impl Write for SerialDevice {
+	fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
 		let port = core::ptr::with_exposed_provenance_mut::<u8>(self.addr as usize);
 		for &byte in buf {
 			// LF newline characters need to be extended to CRLF over a real serial port.
@@ -40,13 +62,11 @@ impl SerialDevice {
 				);
 			}
 		}
-	}
 
-	pub fn read(&self, _buf: &mut [MaybeUninit<u8>]) -> crate::io::Result<usize> {
-		Ok(0)
+		Ok(buf.len())
 	}
 
-	pub fn can_read(&self) -> bool {
-		false
+	fn flush(&mut self) -> Result<(), Self::Error> {
+		Ok(())
 	}
 }

src/arch/aarch64/kernel/serial.rs

@@ -1,23 +1,42 @@
-use core::mem::MaybeUninit;
+use embedded_io::{ErrorType, Read, ReadReady, Write};
+
+use crate::errno::Errno;
 
 pub(crate) struct SerialDevice;
 
 impl SerialDevice {
 	pub fn new() -> Self {
 		Self {}
 	}
+}
+
+impl ErrorType for SerialDevice {
+	type Error = Errno;
+}
 
-	pub fn write(&self, buf: &[u8]) {
+impl Read for SerialDevice {
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
+		let _ = buf;
+		Ok(0)
+	}
+}
+
+impl ReadReady for SerialDevice {
+	fn read_ready(&mut self) -> Result<bool, Self::Error> {
+		Ok(false)
+	}
+}
+
+impl Write for SerialDevice {
+	fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
 		for byte in buf {
 			sbi_rt::console_write_byte(*byte);
 		}
-	}
 
-	pub fn read(&self, _buf: &mut [MaybeUninit<u8>]) -> crate::io::Result<usize> {
-		Ok(0)
+		Ok(buf.len())
 	}
 
-	pub fn can_read(&self) -> bool {
-		false
+	fn flush(&mut self) -> Result<(), Self::Error> {
+		Ok(())
 	}
 }

src/arch/riscv64/kernel/serial.rs

@@ -1,13 +1,14 @@
 use alloc::collections::VecDeque;
 use alloc::vec::Vec;
-use core::mem::MaybeUninit;
 
+use embedded_io::{ErrorType, Read, ReadReady, Write};
 use hermit_sync::{InterruptTicketMutex, Lazy};
 
 #[cfg(feature = "pci")]
 use crate::arch::x86_64::kernel::interrupts;
 #[cfg(feature = "pci")]
 use crate::drivers::InterruptLine;
+use crate::errno::Errno;
 
 #[cfg(feature = "pci")]
 const SERIAL_IRQ: u8 = 4;
@@ -43,29 +44,46 @@ impl SerialDevice {
 	pub fn new() -> Self {
 		Self {}
 	}
+}
 
-	pub fn write(&self, buf: &[u8]) {
-		let mut guard = UART_DEVICE.lock();
-
-		for &data in buf {
-			guard.uart.send(data);
-		}
-	}
+impl ErrorType for SerialDevice {
+	type Error = Errno;
+}
 
-	pub fn read(&self, buf: &mut [MaybeUninit<u8>]) -> crate::io::Result<usize> {
+impl Read for SerialDevice {
+	fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
 		let mut guard = UART_DEVICE.lock();
 		if guard.buffer.is_empty() {
 			Ok(0)
 		} else {
 			let min = core::cmp::min(buf.len(), guard.buffer.len());
 			let drained = guard.buffer.drain(..min).collect::<Vec<_>>();
-			buf[..min].write_copy_of_slice(drained.as_slice());
+			buf[..min].copy_from_slice(drained.as_slice());
 			Ok(min)
 		}
 	}
+}
+
+impl ReadReady for SerialDevice {
+	fn read_ready(&mut self) -> Result<bool, Self::Error> {
+		let read_ready = !UART_DEVICE.lock().buffer.is_empty();
+		Ok(read_ready)
+	}
+}
+
+impl Write for SerialDevice {
+	fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
+		let mut guard = UART_DEVICE.lock();
+
+		for &data in buf {
+			guard.uart.send(data);
+		}
+
+		Ok(buf.len())
+	}
 
-	pub fn can_read(&self) -> bool {
-		!UART_DEVICE.lock().buffer.is_empty()
+	fn flush(&mut self) -> Result<(), Self::Error> {
+		Ok(())
 	}
 }