pub mod diagnose;
pub mod inspect;
pub mod maintain;
pub mod write;
use std::time::Duration;
use embedded_hal_async::spi::SpiDevice;
use crate::cli::{Cli, Cmd};
use crate::device::{self, HostBus};
use crate::error::NorbertError;
use crate::flash::{self, BusAccess, Flasher};
use crate::ui::Ui;
pub type HostFlasher = Flasher<pico_de_gallo_hal::SpiDev, HostBus>;
pub fn build_flasher(cli: &Cli) -> anyhow::Result<HostFlasher> {
build_flasher_at(cli, cli.freq)
}
pub fn build_flasher_at(cli: &Cli, freq: u32) -> anyhow::Result<HostFlasher> {
let device::Connected { spi, bus } = device::connect(cli.serial.as_deref(), freq, cli.reset)?;
let max_chunk = pico_de_gallo_lib::MAX_TRANSFER_SIZE.min(flash::PAGE_SIZE);
Ok(Flasher::with_config(
spi,
bus,
max_chunk,
Duration::from_millis(2),
Duration::from_secs(120),
))
}
pub async fn with_bus<SPI, RST, T>(
f: &mut Flasher<SPI, RST>,
work: impl AsyncFnOnce(&mut Flasher<SPI, RST>) -> Result<T, NorbertError>,
) -> Result<T, NorbertError>
where
SPI: SpiDevice,
RST: BusAccess,
{
f.acquire_bus().await?;
let r = work(f).await;
let _ = f.release_bus();
r
}
pub async fn with_cancel<SPI, RST, T>(
f: &mut Flasher<SPI, RST>,
work: impl AsyncFnOnce(&mut Flasher<SPI, RST>) -> Result<T, NorbertError>,
) -> Result<T, NorbertError>
where
SPI: SpiDevice,
RST: BusAccess,
{
f.acquire_bus().await?;
let outcome = tokio::select! {
r = work(f) => Some(r),
_ = tokio::signal::ctrl_c() => None,
};
let _ = f.release_bus();
match outcome {
Some(r) => r,
None => Err(NorbertError::Cancelled),
}
}
pub async fn dispatch(cli: &Cli, ui: &mut Ui) -> Result<(), NorbertError> {
let Some(cmd) = &cli.cmd else {
return Ok(());
};
match cmd {
Cmd::Jedec => {
let mut f = build_flasher(cli)?;
inspect::jedec(&mut f, ui).await
}
Cmd::Info => {
let mut f = build_flasher(cli)?;
inspect::info(&mut f, ui).await
}
Cmd::Detect => {
let mut f = build_flasher(cli)?;
inspect::detect(&mut f, ui).await
}
Cmd::Sfdp => {
let mut f = build_flasher(cli)?;
inspect::sfdp(&mut f, ui).await
}
Cmd::List => {
inspect::list(ui);
Ok(())
}
Cmd::Program {
bitstream,
offset,
no_verify,
chip_erase,
unprotect,
} => {
let mut f = build_flasher(cli)?;
write::program(
&mut f,
ui,
bitstream,
*offset,
*no_verify,
*chip_erase,
*unprotect,
)
.await
}
Cmd::Erase {
offset,
length,
chip,
} => {
let mut f = build_flasher(cli)?;
write::erase(&mut f, ui, *offset, *length, *chip).await
}
Cmd::Read {
out,
length,
offset,
} => {
let mut f = build_flasher(cli)?;
write::read(&mut f, ui, out, *length, *offset).await
}
Cmd::Verify { bitstream, offset } => {
let mut f = build_flasher(cli)?;
write::verify(&mut f, ui, bitstream, *offset).await
}
Cmd::Protect => {
let mut f = build_flasher(cli)?;
maintain::protect(&mut f, ui).await
}
Cmd::Unprotect => {
let mut f = build_flasher(cli)?;
maintain::unprotect(&mut f, ui).await
}
Cmd::Reset => {
let mut f = build_flasher(cli)?;
maintain::reset(&mut f, ui).await
}
Cmd::Doctor => diagnose::doctor(cli, ui).await,
Cmd::Test { sector } => {
let mut f = build_flasher(cli)?;
diagnose::test(&mut f, ui, *sector).await
}
}
}