This project is now a bootloader. It will send three breaks to request a kernel to relocate to. Use 'pusher' to send your kernel

Author: 0xmatia

Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 lto = true
 
 [features]
-default = []
+default = ["bsp_rpi3"]
 bsp_rpi3 = []
 bsp_rpi4 = []
 

Makefile

@@ -31,7 +31,7 @@ ifeq ($(BSP),rpi3)
     NM_BINARY         = aarch64-unknown-linux-gnu-nm
     READELF_BINARY    = aarch64-unknown-linux-gnu-readelf
     LINKER_FILE       = src/bsp/raspberrypi/link.ld
-    RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
+    RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53 
 else ifeq ($(BSP),rpi4)
     TARGET            = aarch64-unknown-none-softfloat
     KERNEL_BIN        = kernel8.img
@@ -56,7 +56,7 @@ KERNEL_ELF = target/$(TARGET)/release/kernel
 ## Command building blocks
 ##--------------------------------------------------------------------------------------------------
 RUSTFLAGS          = -C link-arg=-T$(LINKER_FILE) $(RUSTC_MISC_ARGS)
-RUSTFLAGS_PEDANTIC = $(RUSTFLAGS)  -D missing_docs  -D warnings
+RUSTFLAGS_PEDANTIC = $(RUSTFLAGS) -D missing_docs  -D warnings
 
 # for conditional compiling (rpi3, rpi4 etc...)
 FEATURES      = --features bsp_$(BSP) 
@@ -158,4 +158,4 @@ nm: $(KERNEL_ELF)
 ## Helper target for rust-analyzer
 ##------------------------------------------------------------------------------
 check:
-	@RUSTFLAGS="$(RUSTFLAGS)" $(CHECK_CMD) --message-format=json
+	@RUSTFLAGS="$(RUSTFLAGS)" $(CHECK_CMD) --message-format=json

src/_arch/aarch64/cpu/boot.s

@@ -28,6 +28,17 @@ https://sourceware.org/binutils/docs-2.36/as/AArch64_002dRelocations.html
 	add	\register, \register, #:lo12:\symbol
 .endm
 
+// Load the address of a symbol into a register, absolute.
+//
+// # Resources
+//
+// - https://sourceware.org/binutils/docs-2.36/as/AArch64_002dRelocations.html
+.macro ADR_ABS register, symbol
+	movz	\register, #:abs_g2:\symbol
+	movk	\register, #:abs_g1_nc:\symbol
+	movk	\register, #:abs_g0_nc:\symbol
+.endm
+
 .equ _core_id_mask, 0b11
 
 .section .text._start
@@ -45,28 +56,37 @@ _start:
     b.ne _park_core
 
     // the core executing these lines is the boot core
-    ADR_REL x0, __bss_start
-    ADR_REL x1, __bss_end_exclusive
+    ADR_ABS x0, __bss_start
+	ADR_ABS x1, __bss_end_exclusive
 
 _initialize_bss:
     cmp x0, x1
-    b.eq _prepare_rust // break the loop if we reached ens of bss
+    b.eq _relocate_bootloader // break the loop if we reached end of bss
     stp xzr, xzr, [x0], #16 // store two zero values (xzr=0) in the bss section
     b _initialize_bss
 
-_prepare_rust:
-    // setting up stack:
-    // sp start from pointing at the end of the bss section,
-    // and it grows downwards (0x7999 - 0x0000)
-    ADR_REL x0, __boot_core_stack_end_exclusive
-    mov sp, x0
-    // let's begin!
-    b _start_rust
+_relocate_bootloader:
+	ADR_REL x0, __binary_start // Where the binary was loaded (ex. 0x8000)
+	ADR_ABS x1, __binary_start // Where the binary was linked (ex. 0x2000000)
+	ADR_ABS x2, __binary_end_exclusive // End of the binary.
+
+_copy_loop:
+	ldr x3, [x0], #8 //  load to x3 whatever is in x0, advance x0 by 8
+	str x3, [x1], #8 //  store whatever is in x3 in the address of x3, advance by 8 x1
+	cmp x1, x2
+	b.lo _copy_loop
+
+// setting up stack:
+ADR_ABS x0, __boot_core_stack_end_exclusive
+mov sp, x0
+// let's begin!
+ADR_ABS x0, _start_rust
+br x0
 
 _park_core:
     wfe // wait for event
     b _park_core // jump to loop if event occured.
 
 .size _start, . - _start // tells the linker the size of _start, doesn't look important
 .type _start, function // start is a function
-.global _start // _start is an external symbol ready to link
+.global _start // _start is an external symbol ready to link

src/bsp/device_driver/bcm/bcm2xxx_gpio.rs

@@ -6,7 +6,7 @@
  */
 
 use crate::{
-    bsp::device_driver::common::MMIODerefWrapper, driver, synchronization::{interface::Mutex},
+    bsp::device_driver::common::MMIODerefWrapper, driver, synchronization::interface::Mutex,
     synchronization::NullLock,
 };
 

src/bsp/device_driver/bcm/bcm2xxx_pl011_uart.rs

@@ -9,7 +9,7 @@ use core::fmt;
 use core::fmt::Arguments;
 
 use crate::{
-    bsp::device_driver::common::MMIODerefWrapper, driver, synchronization::{interface::Mutex},
+    bsp::device_driver::common::MMIODerefWrapper, driver, synchronization::interface::Mutex,
     synchronization::NullLock, cpu, console,
 };
 
@@ -228,8 +228,8 @@ impl PL011UartInner {
         self.registers.ICR.write(ICR::ALL::CLEAR);
 
         // set IBRD + FBRD and enable FIFO and 8N1
-        self.registers.IBRD.write(IBRD::IBRD_DIVINT.val(3));
-        self.registers.FBRD.write(FBRD::FBRD_DIVFRAC.val(16));
+        self.registers.IBRD.write(IBRD::IBRD_DIVINT.val(26));
+        self.registers.FBRD.write(FBRD::FBRD_DIVFRAC.val(3));
         self.registers
             .LCR_H.write(LCR_H::WLEN::EightBits + LCR_H::FEN::Enabled);
 
@@ -275,14 +275,9 @@ impl PL011UartInner {
         }
 
         // read char
-        let mut ret = self.registers.DR.get() as u8 as char;
-
-        if ret == '\r' {
-            ret = '\n';
-        }
+        let ret = self.registers.DR.get() as u8 as char;
 
         self.chars_read += 1;
-
         Some(ret)
     }
 }

src/bsp/raspberrypi/link.ld

@@ -28,7 +28,7 @@ PHDRS
 
 SECTIONS
 {
-    . = 0;
+    . = 0x2000000; /* link address. The bootloader with relocate here before loading the kernel */
 
     /*
     This is the "start" of the stack section for the boot core.
@@ -40,10 +40,8 @@ SECTIONS
         __boot_core_stack_end_exclusive = .;
     } :segment_boot_core_stack
 
-    /*
-    Code section. the first instruction is in kernel_addr_in_memory
-    create a section called text where code will live
-    */
+    /* Code section. */
+	__binary_start = .;
     .text :
     {
         KEEP(*(.text._start)) /* found in boot.s */
@@ -52,15 +50,16 @@ SECTIONS
         *(.text*) /* the rest */
     } :segment_code
 
-    .rodata : ALIGN(8)
-    { 
-        *(.rodata*)
-    } :segment_code
+    .rodata : ALIGN(8) { *(.rodata*) } :segment_code
 
     .got : ALIGN(8) { *(.got) } :segment_code
 
     .data : { *(.data*) } :segment_data
 
+	. = ALIGN(8);
+
+	__binary_end_exclusive = .;
+	
     /* bsses */
     .bss (NOLOAD) : ALIGN(16)
     {

src/bsp/raspberrypi/memory.rs

@@ -11,6 +11,8 @@
 // that need to be mapped physically.
 
 pub mod map {
+    pub const BOARD_DEFAULT_LOAD_ADDRESS: usize =        0x8_0000;
+
     pub const GPIO_OFFSET:         usize = 0x0020_0000;
     pub const UART_OFFSET:         usize = 0x0020_1000;
 
@@ -33,4 +35,9 @@ pub mod map {
         pub const GPIO_START:       usize = START + GPIO_OFFSET;
         pub const PL011_UART_START: usize = START + UART_OFFSET;
     }
-}
+}
+
+#[inline(always)]
+pub fn board_default_load_address() -> *const u64 {
+    map::BOARD_DEFAULT_LOAD_ADDRESS as _
+}

src/main.rs

@@ -2,7 +2,6 @@
 
 //! Enter point of, well, everything
 //! Well, not really, more general metadata, module definitions etc...
-#![feature(const_fn_fn_ptr_basics)]
 #![feature(format_args_nl)]
 #![feature(panic_info_message)]
 #![feature(trait_alias)]
@@ -36,26 +35,52 @@ unsafe fn kernel_init() -> ! {
     kernel_main();
 }
 
+const LOADER_LOGO: &str = r#"
+.____                     .___            
+|    |    _________     __| _/___________ 
+|    |   /  _ \__  \   / __ |/ __ \_  __ \
+|    |__(  <_> ) __ \_/ /_/ \  ___/|  | \/
+|_______ \____(____  /\____ |\___  >__|   
+        \/         \/      \/    \/
+"#;
+
 fn kernel_main() -> ! {
     use bsp::console::console;
     use console::interface::All;
-    use driver::interface::DeviceManager;
 
-    println!("RpiOS is booting...");
-    println!("Communicating through PL011 UART");
+    println!("{}", LOADER_LOGO);
+    println!("Running on: {}", bsp::board_name());
+    println!();
+    println!("Requesting binary!");
+    console().flush();
+
+    console().clear_rx();
 
-    println!("[1] Booting on: {}", bsp::board_name());
-    println!("[2] Drivers loaded:");
-    for (i, driver) in bsp::driver::driver_manager().all_device_drivers().iter().enumerate(){
-        println!("{}. {}", i+1, driver.compatible());
+    // send three times '3' through UART to notify the pusher to send the kernel / binary
+    for _ in 0..3 {
+        console().write_char(3 as char);
     }
 
-    println!("[3] Chars written: {}", bsp::console::console().chars_written());
+    // Read the binary's size.
+    let mut size: u32 = u32::from(console().read_char() as u8);
+    size |= u32::from(console().read_char() as u8) << 8;
+    size |= u32::from(console().read_char() as u8) << 16;
+    size |= u32::from(console().read_char() as u8) << 24;
 
-    println!("[4] Entering echo mode");
-    console().clear_rx();
-    loop {
-        let c = bsp::console::console().read_char();
-        bsp::console::console().write_char(c);
-    } 
-}
+    console().write_char('O');
+    console().write_char('K');
+
+    let kernel_addr = bsp::memory::board_default_load_address() as *mut u8;
+
+    unsafe {
+        for i in 0..size {
+            core::ptr::write_volatile(kernel_addr.offset(i as isize), console().read_char() as u8);
+        }
+    }
+
+    println!("Received kernel, executing now!");
+    console().flush();
+
+    let kernel: fn() -> ! = unsafe { core::mem::transmute(kernel_addr) };
+    kernel();
+}