Bare Metal Rust: вторая половина дня

Драйвер RTC

(назад к упражнению)

main.rs:

// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#![no_main]
#![no_std]

mod exceptions;
mod logger;
mod pl031;

use crate::pl031::Rtc;
use arm_gic::{IntId, Trigger, irq_enable, wfi};
use chrono::{TimeZone, Utc};
use core::hint::spin_loop;
use aarch64_paging::descriptor::El1Attributes;
use aarch64_rt::{InitialPagetable, entry, initial_pagetable};
use arm_gic::gicv3::registers::{Gicd, GicrSgi};
use arm_gic::gicv3::{GicCpuInterface, GicV3};
use arm_pl011_uart::{PL011Registers, Uart};
use core::panic::PanicInfo;
use core::ptr::NonNull;
use log::{LevelFilter, error, info, trace};
use safe_mmio::UniqueMmioPointer;
use smccc::Hvc;
use smccc::psci::system_off;

/// Базовые адреса GICv3.
const GICD_BASE_ADDRESS: NonNull<Gicd> = NonNull::new(0x800_0000 as _).unwrap();
const GICR_BASE_ADDRESS: NonNull<GicrSgi> = NonNull::new(0x80A_0000 as _).unwrap();

/// Базовый адрес основного UART PL011.
const PL011_BASE_ADDRESS: NonNull<PL011Registers> =
    NonNull::new(0x900_0000 as _).unwrap();

/// Атрибуты, используемые для памяти устройств в начальном тождественном отображении.
const DEVICE_ATTRIBUTES: El1Attributes = El1Attributes::VALID
    .union(El1Attributes::ATTRIBUTE_INDEX_0)
    .union(El1Attributes::ACCESSED)
    .union(El1Attributes::UXN);

/// Атрибуты, используемые для обычной памяти в начальном тождественном отображении.
const MEMORY_ATTRIBUTES: El1Attributes = El1Attributes::VALID
    .union(El1Attributes::ATTRIBUTE_INDEX_1)
    .union(El1Attributes::INNER_SHAREABLE)
    .union(El1Attributes::ACCESSED)
    .union(El1Attributes::NON_GLOBAL);

initial_pagetable!({
    let mut idmap = [0; 512];
    // 1 GiB памяти устройств.
    idmap[0] = DEVICE_ATTRIBUTES.bits();
    // 1 GiB обычной памяти.
    idmap[1] = MEMORY_ATTRIBUTES.bits() | 0x40000000;
    // Ещё 1 GiB памяти устройств, начиная с 256 GiB.
    idmap[256] = DEVICE_ATTRIBUTES.bits() | 0x4000000000;
    InitialPagetable(idmap)
});

/// Базовый адрес PL031 RTC.
const PL031_BASE_ADDRESS: NonNull<pl031::Registers> =
    NonNull::new(0x901_0000 as _).unwrap();
/// Прерывание (IRQ), используемое PL031 RTC.
const PL031_IRQ: IntId = IntId::spi(2);

entry!(main);
fn main(x0: u64, x1: u64, x2: u64, x3: u64) -> ! {
    // SAFETY: `PL011_BASE_ADDRESS` --- базовый адрес устройства PL011, и
    // никто другой не обращается к этому диапазону адресов.
    let uart = unsafe { Uart::new(UniqueMmioPointer::new(PL011_BASE_ADDRESS)) };
    logger::init(uart, LevelFilter::Trace).unwrap();

    info!("main({:#x}, {:#x}, {:#x}, {:#x})", x0, x1, x2, x3);

    // SAFETY: `GICD_BASE_ADDRESS` и `GICR_BASE_ADDRESS` --- базовые адреса
    // распределителя и перераспределителя GICv3 соответственно, и
    // никто другой не обращается к этим диапазонам адресов.
    let mut gic = unsafe {
        GicV3::new(UniqueMmioPointer::new(GICD_BASE_ADDRESS), GICR_BASE_ADDRESS, 1)
    }
    .unwrap();
    gic.setup(0);

    // SAFETY: `PL031_BASE_ADDRESS` --- базовый адрес устройства PL031, и
    // никто другой не обращается к этому диапазону адресов.
    let mut rtc = unsafe { Rtc::new(UniqueMmioPointer::new(PL031_BASE_ADDRESS)) };
    let timestamp = rtc.read();
    let time = Utc.timestamp_opt(timestamp.into(), 0).unwrap();
    info!("RTC: {time}");

    GicCpuInterface::set_priority_mask(0xff);
    gic.set_interrupt_priority(PL031_IRQ, None, 0x80).unwrap();
    gic.set_trigger(PL031_IRQ, None, Trigger::Level).unwrap();
    irq_enable();
    gic.enable_interrupt(PL031_IRQ, None, true).unwrap();

    // Ждём 3 секунды без прерываний.
    let target = timestamp + 3;
    rtc.set_match(target);
    info!("Waiting for {}", 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!("Finished waiting");

    // Ждём ещё 3 секунды прерывания.
    let target = timestamp + 6;
    info!("Waiting for {}", 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!("Finished waiting");

    system_off::<Hvc>().unwrap();
    panic!("system_off returned");
}

#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
    error!("{info}");
    system_off::<Hvc>().unwrap();
    loop {}
}

pl031.rs:

#![allow(unused)]
fn main() {
// Copyright 2023 Google LLC
// SPDX-License-Identifier: Apache-2.0

#[repr(C, align(4))]
pub struct Registers {
    /// Регистр данных
    dr: ReadPure<u32>,
    /// Регистр сравнения (match)
    mr: ReadPureWrite<u32>,
    /// Регистр загрузки (load)
    lr: ReadPureWrite<u32>,
    /// Регистр управления
    cr: ReadPureWrite<u8>,
    _reserved0: [u8; 3],
    /// Регистр установки или сброса маски прерываний
    imsc: ReadPureWrite<u8>,
    _reserved1: [u8; 3],
    /// Сырой статус прерываний
    ris: ReadPure<u8>,
    _reserved2: [u8; 3],
    /// Маскированный статус прерываний
    mis: ReadPure<u8>,
    _reserved3: [u8; 3],
    /// Регистр сброса прерываний
    icr: WriteOnly<u8>,
    _reserved4: [u8; 3],
}

/// Драйвер часов реального времени PL031.
#[derive(Debug)]
pub struct Rtc<'a> {
    registers: UniqueMmioPointer<'a, Registers>,
}

impl<'a> Rtc<'a> {
    /// Создаёт новый экземпляр драйвера RTC для устройства PL031 с
    /// заданным набором регистров.
    pub fn new(registers: UniqueMmioPointer<'a, Registers>) -> Self {
        Self { registers }
    }

    /// Читает текущее значение RTC.
    pub fn read(&self) -> u32 {
        field_shared!(self.registers, dr).read()
    }

    /// Записывает значение сравнения. Когда значение RTC совпадёт с ним, будет
    /// сгенерировано прерывание (если оно включено).
    pub fn set_match(&mut self, value: u32) {
        field!(self.registers, mr).write(value);
    }

    /// Возвращает, совпадает ли регистр сравнения со значением RTC, независимо от того,
    /// включено ли прерывание.
    pub fn matched(&self) -> bool {
        let ris = field_shared!(self.registers, ris).read();
        (ris & 0x01) != 0
    }

    /// Возвращает, есть ли в данный момент ожидающее прерывание.
    ///
    /// Это должно быть истинно тогда и только тогда, когда `matched` возвращает истину и
    /// прерывание замаскировано.
    pub fn interrupt_pending(&self) -> bool {
        let mis = field_shared!(self.registers, mis).read();
        (mis & 0x01) != 0
    }

    /// Устанавливает или сбрасывает маску прерываний.
    ///
    /// Когда маска истинна, прерывание включено; когда ложна, прерывание выключено.
    pub fn enable_interrupt(&mut self, mask: bool) {
        let imsc = if mask { 0x01 } else { 0x00 };
        field!(self.registers, imsc).write(imsc);
    }

    /// Сбрасывает ожидающее прерывание, если оно есть.
    pub fn clear_interrupt(&mut self) {
        field!(self.registers, icr).write(0x01);
    }
}
}