feat(aarch64): Add support for stdin

Signed-off-by: Jens Reidel <[email protected]>

Author: Gelbpunkt

.github/workflows/ci.yml

@@ -191,7 +191,7 @@ jobs:
       - run: cargo xtask ci rs --arch ${{ matrix.arch }} --profile ${{ matrix.profile }} --package hello_world --no-default-features qemu ${{ matrix.flags }} --microvm
         if: matrix.arch == 'x86_64'
       - run: cargo xtask ci rs --arch ${{ matrix.arch }} --profile ${{ matrix.profile }} --package stdin qemu
-        if: matrix.arch == 'x86_64'
+        if: matrix.arch != 'riscv64'
       - run: cargo xtask ci rs --arch ${{ matrix.arch }} --profile ${{ matrix.profile }} --package stdin --features hermit/console qemu --devices virtio-console-pci
         if: matrix.arch != 'riscv64'
       - run: cargo xtask ci rs --arch ${{ matrix.arch }} --profile ${{ matrix.profile }} --package stdin --features hermit/console --no-default-features qemu --devices virtio-console-mmio

Cargo.lock

@@ -173,6 +173,7 @@ memory_addresses = { version = "0.2.3", default-features = false, features = [
 
 [target.'cfg(target_arch = "aarch64")'.dependencies]
 aarch64 = { version = "0.0.14", default-features = false }
+arm-pl011-uart = { version = "0.3", default-features = false }
 arm-gic = { version = "0.6" }
 hermit-dtb = { version = "0.1" }
 semihosting = { version = "0.1", optional = true }

Cargo.toml

@@ -23,6 +23,7 @@ use crate::drivers::mmio::get_interrupt_handlers;
 #[cfg(feature = "pci")]
 use crate::drivers::pci::get_interrupt_handlers;
 use crate::drivers::{InterruptHandlerQueue, InterruptLine};
+use crate::kernel::serial::handle_uart_interrupt;
 use crate::mm::virtualmem::KERNEL_FREE_LIST;
 use crate::scheduler::{self, CoreId};
 use crate::{core_id, core_scheduler, env};
@@ -37,6 +38,8 @@ pub(crate) const SGI_RESCHED: u8 = 1;
 
 /// Number of the timer interrupt
 static mut TIMER_INTERRUPT: u32 = 0;
+/// Number of the UART interrupt
+static mut UART_INTERRUPT: u32 = 0;
 /// Possible interrupt handlers
 static INTERRUPT_HANDLERS: OnceCell<HashMap<u8, InterruptHandlerQueue, RandomState>> =
 	OnceCell::new();
@@ -110,6 +113,15 @@ pub(crate) fn install_handlers() {
 			queue.push_back(timer_handler);
 			handlers.insert(u8::try_from(TIMER_INTERRUPT).unwrap() + PPI_START, queue);
 		}
+
+		if let Some(queue) = handlers.get_mut(&(u8::try_from(UART_INTERRUPT).unwrap() + SPI_START))
+		{
+			queue.push_back(handle_uart_interrupt);
+		} else {
+			let mut queue = VecDeque::<fn()>::new();
+			queue.push_back(handle_uart_interrupt);
+			handlers.insert(u8::try_from(UART_INTERRUPT).unwrap() + SPI_START, queue);
+		}
 	}
 
 	INTERRUPT_HANDLERS.set(handlers).unwrap();
@@ -350,10 +362,12 @@ pub(crate) fn init() {
 
 	for node in dtb.enum_subnodes("/") {
 		let parts: Vec<_> = node.split('@').collect();
+		let Some(compatible) = dtb.get_property(parts.first().unwrap(), "compatible") else {
+			continue;
+		};
+		let compatible = core::str::from_utf8(compatible).unwrap();
 
-		if let Some(compatible) = dtb.get_property(parts.first().unwrap(), "compatible")
-			&& core::str::from_utf8(compatible).unwrap().contains("timer")
-		{
+		if compatible.contains("timer") {
 			let irq_slice = dtb
 				.get_property(parts.first().unwrap(), "interrupts")
 				.unwrap();
@@ -395,6 +409,47 @@ pub(crate) fn init() {
 				panic!("Invalid interrupt level!");
 			}
 			gic.enable_interrupt(timer_irqid, Some(cpu_id), true);
+		} else if compatible.contains("pl011") {
+			let irq_slice = dtb
+				.get_property(parts.first().unwrap(), "interrupts")
+				.unwrap();
+
+			let (irqtype, irq_slice) = irq_slice.split_at(4);
+			let (irq, irq_slice) = irq_slice.split_at(4);
+			let (irqflags, _) = irq_slice.split_at(4);
+
+			let irqtype = u32::from_be_bytes(irqtype.try_into().unwrap());
+			let irq = u32::from_be_bytes(irq.try_into().unwrap());
+			let irqflags = u32::from_be_bytes(irqflags.try_into().unwrap());
+
+			unsafe {
+				UART_INTERRUPT = irq;
+			}
+
+			debug!("UART interrupt: {irq}, type {irqtype}, flags {irqflags}");
+
+			let uart_irqid = if irqtype == 1 {
+				IntId::ppi(irq)
+			} else if irqtype == 0 {
+				IntId::spi(irq)
+			} else {
+				panic!("Invalid interrupt type");
+			};
+
+			gic.set_interrupt_priority(uart_irqid, Some(cpu_id), 0x00);
+			if (irqflags & 0xf) == 4 || (irqflags & 0xf) == 8 {
+				gic.set_trigger(uart_irqid, Some(cpu_id), Trigger::Level);
+			} else if (irqflags & 0xf) == 2 || (irqflags & 0xf) == 1 {
+				gic.set_trigger(uart_irqid, Some(cpu_id), Trigger::Edge);
+			} else {
+				panic!("Invalid interrupt level!");
+			}
+
+			gic.enable_interrupt(uart_irqid, Some(cpu_id), true);
+
+			IRQ_NAMES
+				.lock()
+				.insert(u8::try_from(irq).unwrap() + SPI_START, "UART");
 		}
 	}
 

src/arch/aarch64/kernel/interrupts.rs

@@ -1,52 +1,99 @@
-use core::arch::asm;
+use alloc::collections::vec_deque::VecDeque;
+use alloc::vec::Vec;
 use core::mem::MaybeUninit;
+use core::ptr::NonNull;
 
-pub(crate) struct SerialDevice {
-	pub addr: u32,
+use arm_pl011_uart::{DataBits, Interrupts, LineConfig, Parity, StopBits, Uart, UniqueMmioPointer};
+use hermit_sync::{InterruptTicketMutex, Lazy};
+
+static UART_DEVICE: Lazy<InterruptTicketMutex<UartDevice>> =
+	Lazy::new(|| InterruptTicketMutex::new(UartDevice::new()));
+
+pub(crate) struct UartDevice {
+	uart: Uart<'static>,
+	buffer: VecDeque<u8>,
 }
 
-impl SerialDevice {
+impl UartDevice {
 	pub fn new() -> Self {
 		let base = crate::env::boot_info()
 			.hardware_info
 			.serial_port_base
 			.map(|uartport| uartport.get())
 			.unwrap();
 
-		Self { addr: base as u32 }
+		let uart_pointer =
+			unsafe { UniqueMmioPointer::new(NonNull::new_unchecked(base as *mut _)) };
+
+		let mut uart = Uart::new(uart_pointer);
+
+		let line_config = LineConfig {
+			data_bits: DataBits::Bits8,
+			parity: Parity::None,
+			stop_bits: StopBits::One,
+		};
+		uart.enable(line_config, 115_200, 16_000_000).unwrap();
+
+		uart.set_interrupt_masks(Interrupts::RXI | Interrupts::RTI);
+		uart.clear_interrupts(Interrupts::all());
+
+		Self {
+			uart,
+			buffer: VecDeque::new(),
+		}
+	}
+}
+
+pub(crate) struct SerialDevice;
+
+impl SerialDevice {
+	pub fn new() -> Self {
+		Self
 	}
 
 	pub fn write(&self, buf: &[u8]) {
-		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.
-			if byte == b'\n' {
-				unsafe {
-					asm!(
-						"strb w8, [{port}]",
-						port = in(reg) port,
-						in("x8") b'\r',
-						options(nostack),
-					);
-				}
-			}
-
-			unsafe {
-				asm!(
-					"strb w8, [{port}]",
-					port = in(reg) port,
-					in("x8") byte,
-					options(nostack),
-				);
-			}
+		let mut guard = UART_DEVICE.lock();
+
+		for byte in buf {
+			guard.uart.write_word(*byte);
 		}
 	}
 
-	pub fn read(&self, _buf: &mut [MaybeUninit<u8>]) -> crate::io::Result<usize> {
-		Ok(0)
+	pub fn read(&self, buf: &mut [MaybeUninit<u8>]) -> crate::io::Result<usize> {
+		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());
+			Ok(min)
+		}
 	}
 
 	pub fn can_read(&self) -> bool {
-		false
+		!UART_DEVICE.lock().buffer.is_empty()
 	}
 }
+
+pub(crate) fn handle_uart_interrupt() {
+	let mut guard = UART_DEVICE.lock();
+
+	while let Ok(Some(mut byte)) = guard.uart.read_word() {
+		// Normalize CR to LF
+		if byte == b'\r' {
+			byte = b'\n';
+		}
+
+		guard.buffer.push_back(byte);
+	}
+
+	guard
+		.uart
+		.clear_interrupts(Interrupts::RXI | Interrupts::RTI);
+
+	drop(guard);
+
+	crate::console::CONSOLE_WAKER.lock().wake();
+}