You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
137 lines
4.1 KiB
Rust
137 lines
4.1 KiB
Rust
// SPDX-License-Identifier: MIT
|
|
//
|
|
// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
|
|
|
|
// Rust embedded logo for `make doc`.
|
|
#![doc(html_logo_url = "https://git.io/JeGIp")]
|
|
|
|
//! The `kernel`
|
|
//!
|
|
//! The `kernel` is composed by glueing together code from
|
|
//!
|
|
//! - [Hardware-specific Board Support Packages] (`BSPs`).
|
|
//! - [Architecture-specific code].
|
|
//! - HW- and architecture-agnostic `kernel` code.
|
|
//!
|
|
//! using the [`kernel::interface`] traits.
|
|
//!
|
|
//! [Hardware-specific Board Support Packages]: bsp/index.html
|
|
//! [Architecture-specific code]: arch/index.html
|
|
//! [`kernel::interface`]: interface/index.html
|
|
|
|
#![allow(incomplete_features)]
|
|
#![feature(const_generics)]
|
|
#![feature(format_args_nl)]
|
|
#![feature(global_asm)]
|
|
#![feature(panic_info_message)]
|
|
#![feature(trait_alias)]
|
|
#![no_main]
|
|
#![no_std]
|
|
|
|
// Conditionally includes the selected `architecture` code, which provides the `_start()` function,
|
|
// the first function to run.
|
|
mod arch;
|
|
|
|
// `_start()` then calls `runtime_init::init()`, which on completion, jumps to `kernel_init()`.
|
|
mod runtime_init;
|
|
|
|
// Conditionally includes the selected `BSP` code.
|
|
mod bsp;
|
|
|
|
mod interface;
|
|
mod memory;
|
|
mod panic_wait;
|
|
mod print;
|
|
|
|
/// Early init code.
|
|
///
|
|
/// Concerned with with initializing `BSP` and `arch` parts.
|
|
///
|
|
/// # Safety
|
|
///
|
|
/// - Only a single core must be active and running this function.
|
|
/// - The init calls in this function must appear in the correct order:
|
|
/// - Virtual memory must be activated before the device drivers.
|
|
/// - Without it, any atomic operations, e.g. the yet-to-be-introduced spinlocks in the device
|
|
/// drivers (which currently employ NullLocks instead of spinlocks), will fail to work on
|
|
/// the RPi SoCs.
|
|
unsafe fn kernel_init() -> ! {
|
|
use interface::mm::MMU;
|
|
|
|
arch::enable_exception_handling();
|
|
|
|
if let Err(string) = arch::mmu().init() {
|
|
panic!("MMU: {}", string);
|
|
}
|
|
|
|
for i in bsp::device_drivers().iter() {
|
|
if let Err(()) = i.init() {
|
|
panic!("Error loading driver: {}", i.compatible())
|
|
}
|
|
}
|
|
bsp::post_driver_init();
|
|
// println! is usable from here on.
|
|
|
|
// Transition from unsafe to safe.
|
|
kernel_main()
|
|
}
|
|
|
|
/// The main function running after the early init.
|
|
fn kernel_main() -> ! {
|
|
use core::time::Duration;
|
|
use interface::{console::All, time::Timer};
|
|
|
|
info!("Booting on: {}", bsp::board_name());
|
|
|
|
info!("MMU online. Special regions:");
|
|
bsp::virt_mem_layout().print_layout();
|
|
|
|
info!(
|
|
"Current privilege level: {}",
|
|
arch::state::current_privilege_level()
|
|
);
|
|
info!("Exception handling state:");
|
|
arch::state::print_exception_state();
|
|
|
|
info!(
|
|
"Architectural timer resolution: {} ns",
|
|
arch::timer().resolution().as_nanos()
|
|
);
|
|
|
|
info!("Drivers loaded:");
|
|
for (i, driver) in bsp::device_drivers().iter().enumerate() {
|
|
info!(" {}. {}", i + 1, driver.compatible());
|
|
}
|
|
|
|
info!("Timer test, spinning for 1 second");
|
|
arch::timer().spin_for(Duration::from_secs(1));
|
|
|
|
// Cause an exception by accessing a virtual address for which no translation was set up. This
|
|
// code accesses the address 8 GiB, which is outside the mapped address space.
|
|
//
|
|
// For demo purposes, the exception handler will catch the faulting 8 GiB address and allow
|
|
// execution to continue.
|
|
info!("");
|
|
info!("Trying to write to address 8 GiB...");
|
|
let mut big_addr: u64 = 8 * 1024 * 1024 * 1024;
|
|
unsafe { core::ptr::read_volatile(big_addr as *mut u64) };
|
|
|
|
info!("************************************************");
|
|
info!("Whoa! We recovered from a synchronous exception!");
|
|
info!("************************************************");
|
|
info!("");
|
|
info!("Let's try again");
|
|
|
|
// Now use address 9 GiB. The exception handler won't forgive us this time.
|
|
info!("Trying to write to address 9 GiB...");
|
|
big_addr = 9 * 1024 * 1024 * 1024;
|
|
unsafe { core::ptr::read_volatile(big_addr as *mut u64) };
|
|
|
|
// Will never reach here in this tutorial.
|
|
info!("Echoing input now");
|
|
loop {
|
|
let c = bsp::console().read_char();
|
|
bsp::console().write_char(c);
|
|
}
|
|
}
|