Bare Metal Rust Tarde
Driver RTC
main.rs:
#![no_main] #![no_std] mod exceptions; mod logger; mod pl011; mod pl031; use crate::pl031::Rtc; use arm_gic::gicv3::{IntId, Trigger}; use arm_gic::{irq_enable, wfi}; use chrono::{TimeZone, Utc}; use core::hint::spin_loop; use crate::pl011::Uart; use arm_gic::gicv3::GicV3; use core::panic::PanicInfo; use log::{error, info, trace, LevelFilter}; use smccc::psci::system_off; use smccc::Hvc; /// Endereços base do GICv3. const GICD_BASE_ADDRESS: *mut u64 = 0x800_0000 as _; const GICR_BASE_ADDRESS: *mut u64 = 0x80A_0000 as _; /// Endereço base do UART PL011 primário. const PL011_BASE_ADDRESS: *mut u32 = 0x900_0000 as _; /// Endereço base do RTC PL031. const PL031_BASE_ADDRESS: *mut u32 = 0x901_0000 as _; /// O IRQ usado pelo RTC PL031. const PL031_IRQ: IntId = IntId::spi(2); #[no_mangle] extern "C" fn main(x0: u64, x1: u64, x2: u64, x3: u64) { // SEGURANÇA: `PL011_BASE_ADDRESS` é o endereço base de um dispositivo PL011, // e mais nada acessa esse intervalo de endereços. let uart = unsafe { Uart::new(PL011_BASE_ADDRESS) }; logger::init(uart, LevelFilter::Trace).unwrap(); info!("main({:#x}, {:#x}, {:#x}, {:#x})", x0, x1, x2, x3); // SEGURANÇA: `GICD_BASE_ADDRESS` e `GICR_BASE_ADDRESS` são os endereços // base de um distribuidor e redistribuidor GICv3, respectivamente, e mais // nada acessa esses intervalos de endereços. let mut gic = unsafe { GicV3::new(GICD_BASE_ADDRESS, GICR_BASE_ADDRESS) }; gic.setup(); // SEGURANÇA: `PL031_BASE_ADDRESS` é o endereço base de um dispositivo PL031, // e nada mais acessa esse intervalo de endereços. let mut rtc = unsafe { Rtc::new(PL031_BASE_ADDRESS) }; let timestamp = rtc.read(); let time = Utc.timestamp_opt(timestamp.into(), 0).unwrap(); info!("RTC: {time}"); GicV3::set_priority_mask(0xff); gic.set_interrupt_priority(PL031_IRQ, 0x80); gic.set_trigger(PL031_IRQ, Trigger::Level); irq_enable(); gic.enable_interrupt(PL031_IRQ, true); // Espere por 3 segundos, sem interrupções. let target = timestamp + 3; rtc.set_match(target); info!("Esperando por {}", Utc.timestamp_opt(target.into(), 0).unwrap()); trace!( "matched={}, interrupt_pending={}", rtc.matched(), rtc.interrupt_pending() ); while !rtc.matched() { spin_loop(); } trace!( "matched={}, interrupt_pending={}", rtc.matched(), rtc.interrupt_pending() ); info!("Espera finalizada"); // Espere mais 3 segundos por uma interrupção. let target = timestamp + 6; info!("Esperando por {}", Utc.timestamp_opt(target.into(), 0).unwrap()); rtc.set_match(target); rtc.clear_interrupt(); rtc.enable_interrupt(true); trace!( "matched={}, interrupt_pending={}", rtc.matched(), rtc.interrupt_pending() ); while !rtc.interrupt_pending() { wfi(); } trace!( "matched={}, interrupt_pending={}", rtc.matched(), rtc.interrupt_pending() ); info!("Espera finalizada"); system_off::<Hvc>().unwrap(); } #[panic_handler] fn panic(info: &PanicInfo) -> ! { error!("{info}"); system_off::<Hvc>().unwrap(); loop {} }
pl031.rs:
#![allow(unused)] fn main() { use core::ptr::{addr_of, addr_of_mut}; #[repr(C, align(4))] struct Registers { /// Registrador de dados dr: u32, /// Registrador de comparação mr: u32, /// Registrador de carga lr: u32, /// Registrador de controle cr: u8, _reserved0: [u8; 3], /// Registrador de máscara de interrupção ou registrador de limpeza imsc: u8, _reserved1: [u8; 3], /// Status de interrupção bruto ris: u8, _reserved2: [u8; 3], /// Status de interrupção mascarado mis: u8, _reserved3: [u8; 3], /// Registrador de limpeza de interrupção icr: u8, _reserved4: [u8; 3], } /// Driver para um relógio de tempo real PL031. #[derive(Debug)] pub struct Rtc { registers: *mut Registers, } impl Rtc { /// Constrói uma nova instância do driver RTC para um dispositivo PL031 no endereço /// base fornecido. /// /// # Segurança /// /// O endereço base fornecido deve apontar para os registradores de controle MMIO de um /// dispositivo PL031, que deve ser mapeado no espaço de endereços do processo /// como memória de dispositivo e não ter nenhum outro alias. pub unsafe fn new(base_address: *mut u32) -> Self { Self { registers: base_address as *mut Registers } } /// Lê o valor atual do RTC. pub fn read(&self) -> u32 { // SEGURANÇA: Sabemos que self.registers aponta para os registradores de controle // de um dispositivo PL031 que está mapeado adequadamente. unsafe { addr_of!((*self.registers).dr).read_volatile() } } /// Escreve um valor de comparação. Quando o valor do RTC corresponde a este, então uma interrupção /// será gerada (se estiver habilitada). pub fn set_match(&mut self, value: u32) { // SEGURANÇA: Sabemos que self.registers aponta para os registradores de controle // de um dispositivo PL031 que está mapeado adequadamente. unsafe { addr_of_mut!((*self.registers).mr).write_volatile(value) } } /// Retorna se o registrador de comparação corresponde ao valor do RTC, habilitada ou não /// a interrupção. pub fn matched(&self) -> bool { // SEGURANÇA: Sabemos que self.registers aponta para os registradores de controle // de um dispositivo PL031 que está mapeado adequadamente. let ris = unsafe { addr_of!((*self.registers).ris).read_volatile() }; (ris & 0x01) != 0 } /// Retorna se há uma interrupção pendente no momento. /// /// Isso deve ser verdadeiro se e somente se `matched` retornar verdadeiro e a /// interrupção está mascarada. pub fn interrupt_pending(&self) -> bool { // SEGURANÇA: Sabemos que self.registers aponta para os registradores de controle // de um dispositivo PL031 que está mapeado adequadamente. let ris = unsafe { addr_of!((*self.registers).mis).read_volatile() }; (ris & 0x01) != 0 } /// Define ou limpa a máscara de interrupção. /// /// Quando a máscara é verdadeira, a interrupção é habilitada; quando é falsa /// a interrupção é desabilitada. pub fn enable_interrupt(&mut self, mask: bool) { let imsc = if mask { 0x01 } else { 0x00 }; // SEGURANÇA: Sabemos que self.registers aponta para os registradores de controle // de um dispositivo PL031 que está mapeado adequadamente. unsafe { addr_of_mut!((*self.registers).imsc).write_volatile(imsc) } } /// Limpa uma interrupção pendente, se houver. pub fn clear_interrupt(&mut self) { // SEGURANÇA: Sabemos que self.registers aponta para os registradores de controle // de um dispositivo PL031 que está mapeado adequadamente. unsafe { addr_of_mut!((*self.registers).icr).write_volatile(0x01) } } } // SEGURANÇA: `Rtc` contém apenas um ponteiro para memória de dispositivo, que pode ser // acessado de qualquer contexto. unsafe impl Send for Rtc {} }