嵌入式 Rust：进阶篇

RTC 驱动程序

(返回练习)

main.rs:

  1. #![no_main]
  2. #![no_std]
  4. mod exceptions;
  5. mod logger;
  6. mod pl011;
  7. mod pl031;
  9. use crate::pl031::Rtc;
  10. use arm_gic::gicv3::{IntId, Trigger};
  11. use arm_gic::{irq_enable, wfi};
  12. use chrono::{TimeZone, Utc};
  13. use core::hint::spin_loop;
  14. use crate::pl011::Uart;
  15. use arm_gic::gicv3::GicV3;
  16. use core::panic::PanicInfo;
  17. use log::{error, info, trace, LevelFilter};
  18. use smccc::psci::system_off;
  19. use smccc::Hvc;
  21. /// Base addresses of the GICv3.
  22. const GICD_BASE_ADDRESS: *mut u64 = 0x800_0000 as _;
  23. const GICR_BASE_ADDRESS: *mut u64 = 0x80A_0000 as _;
  25. /// Base address of the primary PL011 UART.
  26. const PL011_BASE_ADDRESS: *mut u32 = 0x900_0000 as _;
  28. /// Base address of the PL031 RTC.
  29. const PL031_BASE_ADDRESS: *mut u32 = 0x901_0000 as _;
  30. /// The IRQ used by the PL031 RTC.
  31. const PL031_IRQ: IntId = IntId::spi(2);
  33. #[no_mangle]
  34. extern "C" fn main(x0: u64, x1: u64, x2: u64, x3: u64) {
  35.     // SAFETY: `PL011_BASE_ADDRESS` is the base address of a PL011 device, and
  36.     // nothing else accesses that address range.
  37.     let uart = unsafe { Uart::new(PL011_BASE_ADDRESS) };
  38.     logger::init(uart, LevelFilter::Trace).unwrap();
  40.     info!("main({:#x}, {:#x}, {:#x}, {:#x})", x0, x1, x2, x3);
  42.     // SAFETY: `GICD_BASE_ADDRESS` and `GICR_BASE_ADDRESS` are the base
  43.     // addresses of a GICv3 distributor and redistributor respectively, and
  44.     // nothing else accesses those address ranges.
  45.     let mut gic = unsafe { GicV3::new(GICD_BASE_ADDRESS, GICR_BASE_ADDRESS) };
  46.     gic.setup();
  48.     // SAFETY: `PL031_BASE_ADDRESS` is the base address of a PL031 device, and
  49.     // nothing else accesses that address range.
  50.     let mut rtc = unsafe { Rtc::new(PL031_BASE_ADDRESS) };
  51.     let timestamp = rtc.read();
  52.     let time = Utc.timestamp_opt(timestamp.into(), 0).unwrap();
  53.     info!("RTC: {time}");
  55.     GicV3::set_priority_mask(0xff);
  56.     gic.set_interrupt_priority(PL031_IRQ, 0x80);
  57.     gic.set_trigger(PL031_IRQ, Trigger::Level);
  58.     irq_enable();
  59.     gic.enable_interrupt(PL031_IRQ, true);
  61.     // Wait for 3 seconds, without interrupts.
  62.     let target = timestamp + 3;
  63.     rtc.set_match(target);
  64.     info!("Waiting for {}", Utc.timestamp_opt(target.into(), 0).unwrap());
  65.     trace!(
  66.         "matched={}, interrupt_pending={}",
  67.         rtc.matched(),
  68.         rtc.interrupt_pending()
  69.     );
  70.     while !rtc.matched() {
  71.         spin_loop();
  72.     }
  73.     trace!(
  74.         "matched={}, interrupt_pending={}",
  75.         rtc.matched(),
  76.         rtc.interrupt_pending()
  77.     );
  78.     info!("Finished waiting");
  80.     // Wait another 3 seconds for an interrupt.
  81.     let target = timestamp + 6;
  82.     info!("Waiting for {}", Utc.timestamp_opt(target.into(), 0).unwrap());
  83.     rtc.set_match(target);
  84.     rtc.clear_interrupt();
  85.     rtc.enable_interrupt(true);
  86.     trace!(
  87.         "matched={}, interrupt_pending={}",
  88.         rtc.matched(),
  89.         rtc.interrupt_pending()
  90.     );
  91.     while !rtc.interrupt_pending() {
  92.         wfi();
  93.     }
  94.     trace!(
  95.         "matched={}, interrupt_pending={}",
  96.         rtc.matched(),
  97.         rtc.interrupt_pending()
  98.     );
  99.     info!("Finished waiting");
  101.     system_off::<Hvc>().unwrap();
  102. }
  104. #[panic_handler]
  105. fn panic(info: &PanicInfo) -> ! {
  106.     error!("{info}");
  107.     system_off::<Hvc>().unwrap();
  108.     loop {}
  109. }

pl031.rs：

  1. #![allow(unused)]
  2. fn main() {
  3. use core::ptr::{addr_of, addr_of_mut};
  5. #[repr(C, align(4))]
  6. struct Registers {
  7.     /// Data register
  8.     dr: u32,
  9.     /// Match register
  10.     mr: u32,
  11.     /// Load register
  12.     lr: u32,
  13.     /// Control register
  14.     cr: u8,
  15.     _reserved0: [u8; 3],
  16.     /// Interrupt Mask Set or Clear register
  17.     imsc: u8,
  18.     _reserved1: [u8; 3],
  19.     /// Raw Interrupt Status
  20.     ris: u8,
  21.     _reserved2: [u8; 3],
  22.     /// Masked Interrupt Status
  23.     mis: u8,
  24.     _reserved3: [u8; 3],
  25.     /// Interrupt Clear Register
  26.     icr: u8,
  27.     _reserved4: [u8; 3],
  28. }
  30. /// Driver for a PL031 real-time clock.
  31. #[derive(Debug)]
  32. pub struct Rtc {
  33.     registers: *mut Registers,
  34. }
  36. impl Rtc {
  37.     /// Constructs a new instance of the RTC driver for a PL031 device at the
  38.     /// given base address.
  39.     ///
  40.     /// # Safety
  41.     ///
  42.     /// The given base address must point to the MMIO control registers of a
  43.     /// PL031 device, which must be mapped into the address space of the process
  44.     /// as device memory and not have any other aliases.
  45.     pub unsafe fn new(base_address: *mut u32) -> Self {
  46.         Self { registers: base_address as *mut Registers }
  47.     }
  49.     /// Reads the current RTC value.
  50.     pub fn read(&self) -> u32 {
  51.         // SAFETY: We know that self.registers points to the control registers
  52.         // of a PL031 device which is appropriately mapped.
  53.         unsafe { addr_of!((*self.registers).dr).read_volatile() }
  54.     }
  56.     /// Writes a match value. When the RTC value matches this then an interrupt
  57.     /// will be generated (if it is enabled).
  58.     pub fn set_match(&mut self, value: u32) {
  59.         // SAFETY: We know that self.registers points to the control registers
  60.         // of a PL031 device which is appropriately mapped.
  61.         unsafe { addr_of_mut!((*self.registers).mr).write_volatile(value) }
  62.     }
  64.     /// Returns whether the match register matches the RTC value, whether or not
  65.     /// the interrupt is enabled.
  66.     pub fn matched(&self) -> bool {
  67.         // SAFETY: We know that self.registers points to the control registers
  68.         // of a PL031 device which is appropriately mapped.
  69.         let ris = unsafe { addr_of!((*self.registers).ris).read_volatile() };
  70.         (ris & 0x01) != 0
  71.     }
  73.     /// Returns whether there is currently an interrupt pending.
  74.     ///
  75.     /// This should be true if and only if `matched` returns true and the
  76.     /// interrupt is masked.
  77.     pub fn interrupt_pending(&self) -> bool {
  78.         // SAFETY: We know that self.registers points to the control registers
  79.         // of a PL031 device which is appropriately mapped.
  80.         let ris = unsafe { addr_of!((*self.registers).mis).read_volatile() };
  81.         (ris & 0x01) != 0
  82.     }
  84.     /// Sets or clears the interrupt mask.
  85.     ///
  86.     /// When the mask is true the interrupt is enabled; when it is false the
  87.     /// interrupt is disabled.
  88.     pub fn enable_interrupt(&mut self, mask: bool) {
  89.         let imsc = if mask { 0x01 } else { 0x00 };
  90.         // SAFETY: We know that self.registers points to the control registers
  91.         // of a PL031 device which is appropriately mapped.
  92.         unsafe { addr_of_mut!((*self.registers).imsc).write_volatile(imsc) }
  93.     }
  95.     /// Clears a pending interrupt, if any.
  96.     pub fn clear_interrupt(&mut self) {
  97.         // SAFETY: We know that self.registers points to the control registers
  98.         // of a PL031 device which is appropriately mapped.
  99.         unsafe { addr_of_mut!((*self.registers).icr).write_volatile(0x01) }
  100.     }
  101. }
  103. // SAFETY: `Rtc` just contains a pointer to device memory, which can be
  104. // accessed from any context.
  105. unsafe impl Send for Rtc {}
  106. }