Remove more static mut referencing.

Also add the Default that clippy wanted.

Author: thejpster

src/console.rs

@@ -304,6 +304,12 @@ impl TextConsole {
 	}
 }
 
+impl Default for TextConsole {
+	fn default() -> Self {
+		Self::new()
+	}
+}
+
 unsafe impl Sync for TextConsole {}
 
 impl core::fmt::Write for &TextConsole {

src/main.rs

@@ -62,6 +62,7 @@ mod vga;
 use core::{
 	convert::{TryFrom, TryInto},
 	fmt::Write,
+	ptr::{addr_of, addr_of_mut},
 	sync::atomic::{AtomicBool, AtomicU32, Ordering},
 };
 
@@ -333,10 +334,10 @@ static API_CALLS: common::Api = common::Api {
 const SECONDS_BETWEEN_UNIX_AND_NEOTRON_EPOCH: i64 = 946684800;
 
 extern "C" {
-	static mut _flash_os_start: u32;
-	static mut _flash_os_len: u32;
-	static mut _ram_os_start: u32;
-	static mut _ram_os_len: u32;
+	static _flash_os_start: u32;
+	static _flash_os_len: u32;
+	static _ram_os_start: u32;
+	static _ram_os_len: u32;
 }
 
 /// What we paint Core 0's stack with
@@ -710,11 +711,10 @@ fn paint_stacks() {
 		static mut _stack_start: usize;
 	}
 	unsafe {
-		let stack_len =
-			(&_stack_start as *const usize as usize) - (&__sheap as *const usize as usize);
+		let stack_len = (addr_of!(_stack_start) as usize) - (addr_of!(__sheap) as usize);
 		// But not the top 64 words, because we're using the stack right now!
 		let stack = core::slice::from_raw_parts_mut(
-			&mut __sheap as *mut usize,
+			addr_of_mut!(__sheap),
 			(stack_len / core::mem::size_of::<usize>()) - 256,
 		);
 		info!("Painting Core 1 stack: {:?}", stack.as_ptr_range());
@@ -744,10 +744,9 @@ fn check_stacks() {
 		static mut __sheap: usize;
 		static mut _stack_start: usize;
 	}
-	let stack_len =
-		unsafe { (&_stack_start as *const usize as usize) - (&__sheap as *const usize as usize) };
+	let stack_len = unsafe { (addr_of!(_stack_start) as usize) - (addr_of!(__sheap) as usize) };
 	check_stack(
-		unsafe { &__sheap as *const usize },
+		unsafe { addr_of!(__sheap) },
 		stack_len,
 		CORE0_STACK_PAINT_WORD,
 	);
@@ -1896,8 +1895,8 @@ pub extern "C" fn memory_get_region(region: u8) -> FfiOption<common::MemoryRegio
 		0 => {
 			// Application Region
 			FfiOption::Some(MemoryRegion {
-				start: unsafe { &mut _ram_os_start as *mut u32 } as *mut u8,
-				length: unsafe { &mut _ram_os_len as *const u32 } as usize,
+				start: unsafe { addr_of!(_ram_os_start) } as *mut u8,
+				length: unsafe { addr_of!(_ram_os_len) } as usize,
 				kind: common::MemoryKind::Ram.into(),
 			})
 		}

src/multicore.rs

@@ -65,7 +65,8 @@ static CORE1_ENTRY_FUNCTION: [u16; 2] = [
 /// Starts core 1 running the given function, with the given stack.
 pub fn launch_core1_with_stack(
 	main_func: unsafe extern "C" fn() -> u32,
-	stack: &mut [usize],
+	stack: *mut usize,
+	stack_len: usize,
 	ppb: &mut crate::pac::PPB,
 	fifo: &mut rp_pico::hal::sio::SioFifo,
 	psm: &mut crate::pac::PSM,
@@ -80,25 +81,30 @@ pub fn launch_core1_with_stack(
 
 	defmt::debug!("Setting up stack...");
 
-	// Gets popped into `r0` by CORE1_ENTRY_FUNCTION. This is the `main`
-	// function we want to run. It appears in the call to `core1_wrapper` as
-	// the first argument.
-	stack[stack.len() - 3] = main_func as *const () as usize;
-	// Gets popped into `r1` by CORE1_ENTRY_FUNCTION. This is the top of stack
-	// for Core 1. It appears in the call to `core1_wrapper` as the second
-	// argument.
-	stack[stack.len() - 2] = stack.as_ptr() as *const _ as usize;
-	// Gets popped into `pc` by CORE1_ENTRY_FUNCTION. This is the function
-	// `CORE1_ENTRY_FUNCTION` will jump to, passing the above two values as
-	// arguments.
-	stack[stack.len() - 1] = core1_wrapper as *const () as usize;
-	// Point into the top of the stack (so there are three values pushed onto
-	// it, i.e. at/above it)
-	let stack_ptr = unsafe { stack.as_mut_ptr().add(stack.len() - 3) };
+	let stack_ptr = unsafe {
+		// Gets popped into `r0` by CORE1_ENTRY_FUNCTION. This is the `main`
+		// function we want to run. It appears in the call to `core1_wrapper` as
+		// the first argument.
+		stack
+			.add(stack_len - 3)
+			.write_volatile(main_func as *const () as usize);
+		// Gets popped into `r1` by CORE1_ENTRY_FUNCTION. This is the top of stack
+		// for Core 1. It appears in the call to `core1_wrapper` as the second
+		// argument.
+		stack.add(stack_len - 2).write_volatile(stack as usize);
+		// Gets popped into `pc` by CORE1_ENTRY_FUNCTION. This is the function
+		// `CORE1_ENTRY_FUNCTION` will jump to, passing the above two values as
+		// arguments.
+		stack
+			.add(stack_len - 1)
+			.write_volatile(core1_wrapper as *const () as usize);
+		// Point into the top of the stack (so there are three values pushed onto
+		// it, i.e. at/above it)
+		stack.add(stack_len - 3)
+	};
 
 	defmt::debug!("Stack ptr is 0x{:x}", stack_ptr);
-	defmt::debug!("Stack bottom is 0x{:x}", stack.as_ptr());
-	defmt::debug!("Stack top is 0x{:x}", &stack[stack.len() - 4..stack.len()]);
+	defmt::debug!("Stack bottom is 0x{:x}", stack);
 
 	// This is the launch sequence we send to core1, to get it to leave the
 	// boot ROM and run our code.

src/vga/mod.rs

@@ -42,6 +42,7 @@ mod rgb;
 
 use core::{
 	cell::{RefCell, UnsafeCell},
+	ptr::addr_of_mut,
 	sync::atomic::{AtomicBool, AtomicU16, AtomicU32, Ordering},
 };
 use defmt::{debug, trace};
@@ -1935,13 +1936,16 @@ pub fn init(
 	// No-one else is looking at this right now.
 	TEXT_COLOUR_LOOKUP.init(&VIDEO_PALETTE);
 
-	crate::multicore::launch_core1_with_stack(
-		core1_main,
-		unsafe { &mut super::CORE1_STACK },
-		ppb,
-		fifo,
-		psm,
-	);
+	unsafe {
+		crate::multicore::launch_core1_with_stack(
+			core1_main,
+			addr_of_mut!(super::CORE1_STACK) as *mut usize,
+			super::CORE1_STACK.len(),
+			ppb,
+			fifo,
+			psm,
+		);
+	}
 
 	debug!("Core 1 running");
 }