metta-systems
/
vesper
1
1
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

chore: ♻️ Fix rustfmt and clippy complaints

This commit is contained in:
Berkus Decker 2023-07-28 22:42:38 +03:00 committed by Berkus Decker
parent 7de1af043e
commit ebb73e5cb0
7 changed files with 53 additions and 50 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
bin/chainboot/src/main.rs
View File

@ -10,11 +10,7 @@
use {
aarch64_cpu::asm::barrier,
core::hash::Hasher,
machine::{
devices::SerialOps,
platform::rpi3::{gpio::GPIO, pl011_uart::PL011Uart, BcmHost},
print, println, CONSOLE,
},
machine::{console::console, platform::rpi3::BcmHost, print, println},
seahash::SeaHasher,
};
@ -30,13 +26,12 @@ unsafe fn kernel_init(max_kernel_size: u64) -> ! {
#[cfg(feature = "jtag")]
machine::arch::jtag::wait_debugger();
let gpio = GPIO::default();
let uart = PL011Uart::default();
let uart = uart.prepare(&gpio).expect("What could go wrong?");
CONSOLE.lock(|c| {
// Move uart into the global CONSOLE.
c.replace_with(uart.into());
});
if let Err(x) = machine::platform::drivers::init() {
panic!("Error initializing platform drivers: {}", x);
}
// Initialize all device drivers.
machine::drivers::driver_manager().init_drivers();
// println! is usable from here on.
@ -53,17 +48,15 @@ const LOGO: &str = r#"
"#;
fn read_u64() -> u64 {
CONSOLE.lock(|c| {
let mut val: u64 = u64::from(c.read_byte());
val |= u64::from(c.read_byte()) << 8;
val |= u64::from(c.read_byte()) << 16;
val |= u64::from(c.read_byte()) << 24;
val |= u64::from(c.read_byte()) << 32;
val |= u64::from(c.read_byte()) << 40;
val |= u64::from(c.read_byte()) << 48;
val |= u64::from(c.read_byte()) << 56;
val
})
let mut val: u64 = u64::from(console().read_byte());
val |= u64::from(console().read_byte()) << 8;
val |= u64::from(console().read_byte()) << 16;
val |= u64::from(console().read_byte()) << 24;
val |= u64::from(console().read_byte()) << 32;
val |= u64::from(console().read_byte()) << 40;
val |= u64::from(console().read_byte()) << 48;
val |= u64::from(console().read_byte()) << 56;
val
}
/// The main function running after the early init.
@ -79,14 +72,14 @@ fn kernel_main(max_kernel_size: u64) -> ! {
let kernel_addr: *mut u8 = BcmHost::kernel_load_address() as *mut u8;
loop {
CONSOLE.lock(|c| c.flush());
console().flush();
// Discard any spurious received characters before starting with the loader protocol.
CONSOLE.lock(|c| c.clear_rx());
console().clear_rx();
// Notify `chainofcommand` to send the binary.
for _ in 0..3 {
CONSOLE.lock(|c| c.write_byte(3u8));
console().write_byte(3u8);
}
// Read the binary's size.
@ -108,7 +101,7 @@ fn kernel_main(max_kernel_size: u64) -> ! {
// Read the kernel byte by byte.
for i in 0..size {
let val = CONSOLE.lock(|c| c.read_byte());
let val = console().read_byte();
unsafe {
core::ptr::write_volatile(kernel_addr.offset(i as isize), val);
}
@ -133,7 +126,7 @@ fn kernel_main(max_kernel_size: u64) -> ! {
"⏪ Loaded! Executing the payload now from {:p}\n",
kernel_addr
);
CONSOLE.lock(|c| c.flush());
console().flush();
// Use black magic to create a function pointer.
let kernel: fn() -> ! = unsafe { core::mem::transmute(kernel_addr) };

22
bin/chainofcommand/src/main.rs
View File

@ -84,9 +84,10 @@ where
let kernel_size: u64 = kernel_file.metadata()?.len();
to_console2
.send(Ok(Message::Text(
format!("⏩ .. {} ({} bytes)\n", kernel, kernel_size).into(),
)))
.send(Ok(Message::Text(format!(
"⏩ .. {} ({} bytes)\n",
kernel, kernel_size
))))
.await?;
Ok((kernel_file, kernel_size))
@ -135,9 +136,10 @@ async fn send_kernel<P: ThePath>(
let hashed_value: u64 = hasher.finish();
to_console2
.send(Ok(Message::Text(
format!("⏩ Sending image checksum {:x}\n", hashed_value).into(),
)))
.send(Ok(Message::Text(format!(
"⏩ Sending image checksum {:x}\n",
hashed_value
))))
.await?;
to_serial
@ -383,7 +385,7 @@ fn handle_key_event(key_event: KeyEvent) -> Option<Bytes> {
KeyCode::Char(ch) => {
if key_event.modifiers & KeyModifiers::CONTROL == KeyModifiers::CONTROL {
buf[0] = ch as u8;
if ('a'..='z').contains(&ch) || (ch == ' ') {
if ch.is_ascii_lowercase() || (ch == ' ') {
buf[0] &= 0x1f;
Some(&buf[0..1])
} else if ('4'..='7').contains(&ch) {
@ -527,10 +529,8 @@ async fn main() -> Result<()> {
let cont = matches!(e.downcast_ref::<std::io::Error>(),
Some(e) if e.kind() == std::io::ErrorKind::NotFound || e.kind() == std::io::ErrorKind::PermissionDenied)
|| matches!(e.downcast_ref::<tokio_serial::Error>(), Some(e) if e.kind == tokio_serial::ErrorKind::NoDevice)
|| matches!(
e.downcast_ref::<tokio::sync::mpsc::error::SendError<Vec<u8>>>(),
Some(_)
);
|| e.downcast_ref::<tokio::sync::mpsc::error::SendError<Vec<u8>>>()
.is_some();
if !cont {
break;

2
machine/src/arch/aarch64/memory/mmu.rs
View File

@ -19,11 +19,11 @@ use {
},
platform, println,
},
core::intrinsics::unlikely,
aarch64_cpu::{
asm::barrier,
registers::{ID_AA64MMFR0_EL1, SCTLR_EL1, TCR_EL1, TTBR0_EL1},
},
core::intrinsics::unlikely,
tock_registers::interfaces::{ReadWriteable, Readable, Writeable},
};

13
machine/src/platform/rpi3/device_driver/mini_uart.rs
View File

@ -231,6 +231,7 @@ impl MiniUartInner {
impl MiniUartInner {
/// Set baud rate and characteristics (115200 8N1) and map to GPIO
pub fn prepare(&self) -> Result<(), &'static str> {
use tock_registers::interfaces::Writeable;
// initialize UART
self.registers
.AUX_ENABLES
@ -269,6 +270,7 @@ impl Drop for MiniUartInner {
impl SerialOps for MiniUartInner {
/// Receive a byte without console translation
fn read_byte(&self) -> u8 {
use tock_registers::interfaces::Readable;
// wait until something is in the buffer
crate::arch::loop_until(|| {
self.registers
@ -281,6 +283,7 @@ impl SerialOps for MiniUartInner {
}
fn write_byte(&self, b: u8) {
use tock_registers::interfaces::{Readable, Writeable};
// wait until we can send
crate::arch::loop_until(|| {
self.registers
@ -295,12 +298,14 @@ impl SerialOps for MiniUartInner {
/// Wait until the TX FIFO is empty, aka all characters have been put on the
/// line.
fn flush(&self) {
use tock_registers::interfaces::Readable;
crate::arch::loop_until(|| self.registers.AUX_MU_STAT.is_set(AUX_MU_STAT::TX_DONE));
}
/// Consume input until RX FIFO is empty, aka all pending characters have been
/// consumed.
fn clear_rx(&self) {
use tock_registers::interfaces::Readable;
crate::arch::loop_while(|| {
let pending = self
.registers
@ -317,10 +322,10 @@ impl SerialOps for MiniUartInner {
impl interface::ConsoleOps for MiniUartInner {
/// Send a character
fn write_char(&self, c: char) {
let mut b = [0u8; 4];
let _ = c.encode_utf8(&mut b);
for x in 0..c.len_utf8() {
self.write_byte(b[x]);
let mut bytes = [0u8; 4];
let _ = c.encode_utf8(&mut bytes);
for &b in bytes.iter().take(c.len_utf8()) {
self.write_byte(b);
}
}

8
machine/src/platform/rpi3/device_driver/pl011_uart.rs
View File

@ -406,10 +406,10 @@ impl SerialOps for PreparedPL011Uart {
impl ConsoleOps for PreparedPL011Uart {
/// Send a character
fn write_char(&self, c: char) {
let mut b = [0u8; 4];
let _ = c.encode_utf8(&mut b);
for x in 0..c.len_utf8() {
self.write_byte(b[x]);
let mut bytes = [0u8; 4];
let _ = c.encode_utf8(&mut bytes);
for &b in bytes.iter().take(c.len_utf8()) {
self.write_byte(b);
}
}

4
machine/src/platform/rpi3/mailbox.rs
View File

@ -547,11 +547,11 @@ impl<const N_SLOTS: usize, Storage: MailboxStorage + MailboxStorageRef> Mailbox<
/// when passing memory addresses as the data part of a mailbox message,
/// the addresses should be **bus addresses as seen from the VC.**
pub fn do_write(&self, channel: u32) -> Result<()> {
let buf_ptr = self.buffer.as_ptr() as *const u32 as u32;
let buf_ptr = self.buffer.as_ptr();
let buf_ptr = if channel != channel::PropertyTagsArmToVc {
BcmHost::phys2bus(buf_ptr as usize) as u32
} else {
buf_ptr
buf_ptr as u32
};
let mut count: u32 = 0;

5
nucleus/src/main.rs
View File

@ -53,6 +53,11 @@ entry!(kernel_init);
/// Kernel entry point.
/// `arch` crate is responsible for calling it.
///
/// # Safety
///
/// - Only a single core must be active and running this function.
/// - The init calls in this function must appear in the correct order.
pub unsafe fn kernel_init() -> ! {
#[cfg(feature = "jtag")]
machine::arch::jtag::wait_debugger();