Files
guac-rs/firmware/src/config.rs
T
ktims 44679cda2c
Build and Release Firmware / firmware (ak4490) (push) Successful in 50s
Build and Release Firmware / firmware (cs4398) (push) Successful in 44s
Build and Release Firmware / firmware (evk) (push) Successful in 43s
Build and Release Firmware / cli (aarch64-unknown-linux-musl) (push) Successful in 1m8s
Build and Release Firmware / cli (x86_64-pc-windows-gnu) (push) Successful in 1m32s
Build and Release Firmware / cli (x86_64-unknown-linux-musl) (push) Successful in 1m6s
Build and Release Firmware / release (push) Successful in 7s
config: add persistent flash-backed configuration with a HID command interface and CLI management
2026-11-11 18:09:07 -07:00

307 lines
8.1 KiB
Rust

use lpc55_hal as hal;
use hal::{FlashGordon, drivers::flash::GenericArray, raw as pac, traits::flash::WriteErase};
use shared::config::{
ConfigContainer, ConfigString, ConfigV1, ConfigVersion, DeviceConfig, TlvList,
};
use crate::{CONFIG_RESERVED, CONFIG_SLOT_COUNT, FLASH_PAGE_SIZE, SLOT_SIZE, config_base};
const SLOT_MAGIC: u32 = u32::from_le_bytes(*b"SLOT");
const FLASH_WORD_SIZE: usize = 16;
const READ_SINGLE_WORD: u32 = 0x3;
const READ_ECC_OFF: u32 = 1 << 2;
const COMMAND_TIMEOUT: u32 = 1_000_000;
static mut CONFIG_BUF: [u8; SLOT_SIZE] = [0u8; SLOT_SIZE];
#[cfg(feature = "hid")]
pub struct ConfigState {
pub running: DeviceConfig,
pub active_slot: u8,
}
#[cfg(feature = "hid")]
pub struct FlashState {
pub flash: FlashGordon,
}
#[derive(Clone, Copy, defmt::Format)]
enum FlashError {
IllegalCommand,
Failed,
Timeout,
}
fn halt() -> ! {
loop {
cortex_m::asm::wfi();
}
}
fn slot_page_address() -> usize {
config_base()
}
fn slot_address(index: usize) -> usize {
config_base() + CONFIG_RESERVED + index * SLOT_SIZE
}
fn config_buf() -> &'static mut [u8; SLOT_SIZE] {
// Safety: flash access is not reentrant and the buffer is only borrowed for one operation at a time.
unsafe { &mut *core::ptr::addr_of_mut!(CONFIG_BUF) }
}
fn read_word(
flash: &pac::flash::RegisterBlock,
address: usize,
) -> Result<[u8; FLASH_WORD_SIZE], FlashError> {
flash.int_clr_status.write(|w| {
w.done()
.set_bit()
.ecc_err()
.set_bit()
.err()
.set_bit()
.fail()
.set_bit()
});
flash
.starta
.write(|w| unsafe { w.starta().bits((address / FLASH_WORD_SIZE) as u32) });
flash.dataw[0].write(|w| unsafe { w.bits(READ_ECC_OFF) });
flash.cmd.write(|w| unsafe { w.bits(READ_SINGLE_WORD) });
let mut timeout = COMMAND_TIMEOUT;
while flash.int_status.read().done().bit_is_clear() {
timeout -= 1;
if timeout == 0 {
return Err(FlashError::Timeout);
}
}
let status = flash.int_status.read();
if status.err().bit_is_set() {
return Err(FlashError::IllegalCommand);
}
if status.fail().bit_is_set() {
return Err(FlashError::Failed);
}
let mut word = [0u8; FLASH_WORD_SIZE];
for (chunk, register) in word.chunks_mut(4).zip(flash.dataw.iter()) {
chunk.copy_from_slice(&register.read().bits().to_ne_bytes());
}
Ok(word)
}
fn read_flash(address: usize, buf: &mut [u8]) -> Result<(), FlashError> {
// Safety: the flash controller registers are only ever accessed here and in the HAL, never concurrently.
let flash = unsafe { &*pac::FLASH::ptr() };
for (index, chunk) in buf.chunks_mut(FLASH_WORD_SIZE).enumerate() {
let word = read_word(flash, address + index * FLASH_WORD_SIZE)?;
chunk.copy_from_slice(&word[..chunk.len()]);
}
Ok(())
}
fn read_active_slot() -> Option<usize> {
let mut page = [0u8; FLASH_PAGE_SIZE];
read_flash(slot_page_address(), &mut page).ok()?;
if u32::from_le_bytes([page[0], page[1], page[2], page[3]]) != SLOT_MAGIC {
return None;
}
let slots = &page[4..8];
let index = slots[0];
if slots.iter().any(|&slot| slot != index) || usize::from(index) >= CONFIG_SLOT_COUNT {
return None;
}
Some(usize::from(index))
}
fn load_slot(index: usize) -> Option<DeviceConfig> {
let buf = config_buf();
if let Err(error) = read_flash(slot_address(index), buf) {
defmt::error!("config: slot {} unreadable: {}", index, error);
return None;
}
match ConfigContainer::parse(&buf[..]) {
Ok((container, _)) => match DeviceConfig::try_from(&container.config) {
Ok(config) => Some(config),
Err(error) => {
defmt::warn!("config: slot {} invalid: {}", index, error);
None
}
},
Err(error) => {
defmt::debug!("config: slot {} skipped: {}", index, error);
None
}
}
}
fn device_serial() -> Option<ConfigString<32>> {
DeviceConfig::serial_from_uuid(&hal::uuid())
}
fn default_config() -> DeviceConfig {
match DeviceConfig::with_defaults(device_serial()) {
Ok(config) => config,
Err(_) => halt(),
}
}
fn write_slot(
flash: &mut FlashGordon,
index: usize,
container: &ConfigContainer,
) -> Result<(), ()> {
let buf = config_buf();
let len = container.encode(buf).map_err(|_| ())?;
let base = slot_address(index);
let pages = len.div_ceil(FLASH_PAGE_SIZE);
for page in 0..pages {
let address = base + page * FLASH_PAGE_SIZE;
flash
.erase_page(address / FLASH_PAGE_SIZE)
.map_err(|_| ())?;
}
for page in 0..pages {
let start = page * FLASH_PAGE_SIZE;
let end = (start + FLASH_PAGE_SIZE).min(len);
let mut page_buf = [0xffu8; FLASH_PAGE_SIZE];
page_buf[..end - start].copy_from_slice(&buf[start..end]);
flash
.write_native(base + start, GenericArray::from_slice(&page_buf))
.map_err(|_| ())?;
}
Ok(())
}
fn write_active_slot(flash: &mut FlashGordon, index: usize) -> Result<(), ()> {
let address = slot_page_address();
let mut page = [0xffu8; FLASH_PAGE_SIZE];
page[..4].copy_from_slice(&SLOT_MAGIC.to_le_bytes());
page[4..8].fill(index as u8);
flash
.erase_page(address / FLASH_PAGE_SIZE)
.map_err(|_| ())?;
flash
.write_native(address, GenericArray::from_slice(&page))
.map_err(|_| ())?;
Ok(())
}
fn slow_clock_for_flash() {
// Safety: the device resets after writing, so no peripheral depends on the core clock source.
let syscon = unsafe { &*pac::SYSCON::ptr() };
syscon.fmccr.modify(|_, w| w.flashtim().flashtim11());
syscon.mainclksela.modify(|_, w| w.sel().enum_0x3());
syscon.mainclkselb.modify(|_, w| w.sel().enum_0x0());
syscon.ahbclkdiv.modify(|_, w| unsafe { w.div().bits(0) });
}
fn persist_and_reset(
flash: &mut FlashGordon,
slot: usize,
container: &ConfigContainer,
) -> Result<(), ()> {
defmt::info!("config: persisting to slot {}", slot);
cortex_m::interrupt::free(|_| {
slow_clock_for_flash();
if write_slot(flash, slot, container).is_err() {
defmt::error!("config: slot write failed");
return;
}
if write_active_slot(flash, slot).is_err() {
defmt::error!("config: slot page write failed");
return;
}
cortex_m::peripheral::SCB::sys_reset();
});
Err(())
}
fn create_default(flash: &mut FlashGordon) -> DeviceConfig {
let config = default_config();
let Ok(tlvs) = config.to_tlvs() else {
return config;
};
defmt::info!("config: creating default");
let container = ConfigContainer::new(ConfigVersion::V1(ConfigV1 { tlvs }));
let _ = persist_and_reset(flash, 0, &container);
config
}
#[cfg(feature = "hid")]
fn commit_tlvs(state: &mut FlashState, config: &ConfigState, tlvs: TlvList) -> Result<(), ()> {
let next_slot = (usize::from(config.active_slot) + 1) % CONFIG_SLOT_COUNT;
let container = ConfigContainer::new(ConfigVersion::V1(ConfigV1 { tlvs }));
persist_and_reset(&mut state.flash, next_slot, &container)
}
#[cfg(feature = "hid")]
pub fn commit(state: &mut FlashState, config: &ConfigState) -> Result<(), ()> {
commit_tlvs(state, config, config.running.to_tlvs().map_err(|_| ())?)
}
#[cfg(feature = "hid")]
pub fn commit_defaults(state: &mut FlashState, config: &ConfigState) -> Result<(), ()> {
commit_tlvs(state, config, default_config().to_tlvs().map_err(|_| ())?)
}
pub fn load(flash: &mut FlashGordon) -> (DeviceConfig, u8) {
slow_clock_for_flash();
let active = read_active_slot();
if let Some(index) = active
&& let Some(config) = load_slot(index)
{
return (config, index as u8);
}
for index in (0..CONFIG_SLOT_COUNT).rev() {
if Some(index) == active {
continue;
}
if let Some(config) = load_slot(index) {
return (config, index as u8);
}
}
(create_default(flash), 0)
}