sylveos

bootload.rs (3250B)

---

 use std::path::Path;
 
 use crc_fast::{CrcAlgorithm::Crc32IsoHdlc, checksum};
 use indicatif::ProgressStyle;
 use tokio::{
     fs::File,
     io::{AsyncReadExt, AsyncWriteExt},
 };
 use tokio_serial::SerialStream;
 use tracing::{debug, instrument, trace};
 use tracing_indicatif::span_ext::IndicatifSpanExt;
 
 #[repr(u32)]
 #[derive(Debug)]
 pub enum Message {
     GetProgInfo = 0x11112222,
     PutProgInfo = 0x33334444,
 
     GetCode = 0x55556666,
     PutCode = 0x77778888,
 
     BootSuccess = 0x9999AAAA,
     BadCodeAddr = 0xDEADBEEF,
     BadCodeChecksum = 0xFEEDFACE,
 }
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error("invalid boot address")]
     BadAddress,
     #[error("checksum did not match")]
     BadChecksum,
     #[error("io: {0}")]
     Io(#[from] std::io::Error),
 }
 
 #[instrument(skip_all, fields(indicatif.pb_show))]
 pub async fn boot(port: &mut SerialStream, bin: &Path, base_address: u32) -> Result<(), Error> {
     let current = tracing::Span::current();
 
     let mut code = Vec::new();
 
     File::open(bin).await?.read_to_end(&mut code).await?;
 
     let checksum = checksum(Crc32IsoHdlc, &code) as u32;
 
     debug!("boot parameters: crc32={checksum:x}, file={bin:?}, base_address=0x{base_address:X}");
 
     current.pb_set_style(&ProgressStyle::default_spinner());
     current.pb_set_message("waiting for GetProgInfo");
 
     loop {
         match port.read_u32_le().await? {
             v if v == (Message::GetProgInfo as u32) => break,
             v => {
                 trace!("got invalid GetProgInfo: {v:X}");
                 // Read 1 to offset
                 port.read_u8().await?;
                 continue;
             }
         }
     }
 
     port.write_u32_le(Message::PutProgInfo as u32).await?;
     port.write_u32_le(base_address).await?;
     port.write_u32_le(code.len() as u32).await?;
     port.write_u32_le(checksum).await?;
     port.flush().await?;
 
     loop {
         match port.read_u32_le().await? {
             v if v == (Message::GetCode as u32) => break,
             v if v == (Message::BadCodeAddr as u32) => return Err(Error::BadAddress),
             v => {
                 trace!("got invalid GetCode: {v:X}");
                 continue;
             }
         }
     }
 
     let checksum_ret = port.read_u32_le().await?;
 
     if checksum != checksum_ret {
         return Err(Error::BadChecksum);
     }
 
     port.write_u32_le(Message::PutCode as u32).await?;
 
     current.pb_set_style(
         &ProgressStyle::with_template(
             "[{elapsed}] [{wide_bar}] {binary_bytes}/{binary_total_bytes} (eta: {eta})",
         )
         .unwrap()
         .progress_chars("=> "),
     );
     current.pb_set_length(code.len() as u64);
 
     for b in code.iter() {
         port.write_u8(*b).await?;
         current.pb_inc(1);
     }
     port.flush().await?;
 
     current.pb_set_style(&ProgressStyle::default_spinner());
     current.pb_set_message("waiting for BootSuccess");
 
     loop {
         match port.read_u32_le().await? {
             v if v == (Message::BootSuccess as u32) => break,
             v if v == (Message::BadCodeChecksum as u32) => return Err(Error::BadAddress),
             v => {
                 debug!("got invalid BootSuccess: {v}");
                 continue;
             }
         }
     }
 
     Ok(())
 }