mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-15 08:30:02 +00:00
add bio loader implementation
This commit is contained in:
parent
69c68db711
commit
d010f07dd7
1 changed files with 556 additions and 0 deletions
556
apps-dabao/dabao-console/src/cmds/bio.rs
Normal file
556
apps-dabao/dabao-console/src/cmds/bio.rs
Normal file
|
|
@ -0,0 +1,556 @@
|
|||
// bio.rs - REPL command that receives a BIO program over serial and runs it.
|
||||
//
|
||||
// The BIO program is stored in the "data slot" array in the keystore. This is
|
||||
// a stand-in solution because the Dabao does not have a permanent storage partition
|
||||
// by default, but the data array is big enough to hold BIO programs with room to spare.
|
||||
// By putting the programs there, we keep a fairly open slate for future options
|
||||
// for data storage using e.g. a dedicated chunk of RRAM while also improving utilization
|
||||
// of an otherwise under-utilized resource on the chip.
|
||||
|
||||
use core::fmt::Write;
|
||||
use std::time::Duration;
|
||||
|
||||
use bao1x_api::bio::*;
|
||||
use bao1x_api::bio_resources::*;
|
||||
use bao1x_api::dabao::{APP_BIO_CLK_INDEX, APP_BIO_CODE_INDICES, APP_BIO_CODE_VALID, APP_BIO_PINS_INDEX};
|
||||
use bao1x_hal::bio::{Bio, CoreCsr};
|
||||
use base64::{Engine as _, engine::general_purpose::STANDARD as B64};
|
||||
use keystore::Keystore;
|
||||
|
||||
use crate::{CommonEnv, ShellCmdApi};
|
||||
|
||||
// -- Constants ----------------------------------------------------------------
|
||||
|
||||
const CHUNK_DATA_SIZE: usize = 64;
|
||||
const CHUNK_INDEX_BYTES: usize = 2;
|
||||
const CHUNK_CRC_BYTES: usize = 4;
|
||||
/// Total decoded wire size per chunk.
|
||||
const CHUNK_WIRE_SIZE: usize = CHUNK_INDEX_BYTES + CHUNK_DATA_SIZE + CHUNK_CRC_BYTES; // 70
|
||||
/// Size of BIO memory in 32-bit words
|
||||
const BIO_MEM_BYTES: usize = 0xf00;
|
||||
const NUM_CHUNKS: usize = BIO_MEM_BYTES / CHUNK_DATA_SIZE;
|
||||
/// These pins avoid unconnected I/O, I/Os tied to other functions, and the console UART.
|
||||
const ALLOWED_PINS: [u8; 17] = [1, 2, 3, 4, 5, 11, 12, 16, 17, 18, 19, 23, 24, 26, 27, 28, 29];
|
||||
const VALID_CODE: [u8; 32] = {
|
||||
let mut b = [0u8; 32];
|
||||
b[0] = 1;
|
||||
b
|
||||
};
|
||||
|
||||
// -- Command state -------------------------------------------------------------
|
||||
fn check_pins(pins: &mut Vec<u8>) {
|
||||
pins.retain(|p| ALLOWED_PINS.contains(p));
|
||||
pins.sort();
|
||||
pins.dedup();
|
||||
}
|
||||
|
||||
pub struct BioLoader {
|
||||
/// Raw 64-byte payloads indexed by chunk number.
|
||||
/// `None` means that chunk has not yet been received.
|
||||
chunks: Vec<Option<[u8; CHUNK_DATA_SIZE]>>,
|
||||
|
||||
/// How many distinct chunk slots are currently filled.
|
||||
received_count: usize,
|
||||
|
||||
/// BIO clock config
|
||||
target_freq: u32,
|
||||
|
||||
/// Pins used by this BIO
|
||||
pin_spec: Vec<u8>,
|
||||
|
||||
/// Actual code
|
||||
code: Option<[u8; BIO_MEM_BYTES]>,
|
||||
|
||||
store: Keystore,
|
||||
|
||||
bio_ss: Bio,
|
||||
_fifo_handle: CoreHandle,
|
||||
fifo: CoreCsr,
|
||||
resource_grant: ResourceGrant,
|
||||
|
||||
core_init: bool,
|
||||
}
|
||||
|
||||
impl BioLoader {
|
||||
pub fn new() -> Self {
|
||||
let xns = xous_names::XousNames::new().unwrap();
|
||||
let keystore = Keystore::new(&xns);
|
||||
|
||||
// check if the CODE_VALID key has a valid number; if not, this is a factory new
|
||||
// part and the parameters need initialization
|
||||
let erase_check = keystore.read_app_key(APP_BIO_CODE_VALID).unwrap();
|
||||
if !(erase_check == [0u8; 32] || erase_check == VALID_CODE) {
|
||||
log::info!("Initializing BIO keys to valid initial state");
|
||||
// the key array is uninit, initialize it
|
||||
keystore.write_app_key(APP_BIO_PINS_INDEX, &[0u8; 32]).ok();
|
||||
keystore.write_app_key(APP_BIO_CLK_INDEX, &[0u8; 32]).ok();
|
||||
// instead of writing all 0's to the code space
|
||||
keystore.write_app_key(APP_BIO_CODE_VALID, &[0u8; 32]).ok();
|
||||
}
|
||||
|
||||
// this now happens fairly late in the init due to the gate above
|
||||
let mut bio_ss = Bio::new();
|
||||
// claim core resource and initialize it
|
||||
let resource_grant =
|
||||
bio_ss.claim_resources(&Self::resource_spec()).expect("Couldn't claim BIO resources");
|
||||
|
||||
log::info!("BIO loader reserving core: {:?}", resource_grant.cores[0]);
|
||||
|
||||
// safety: fifo is stored in this object so they aren't Drop'd before the object is
|
||||
// destroyed
|
||||
let fifo_handle = unsafe { bio_ss.get_core_handle(Fifo::Fifo0) }
|
||||
.expect("Didn't get FIFO0 handle")
|
||||
.expect("Didn't get FIFO0 handle");
|
||||
let fifo = CoreCsr::from_handle(&fifo_handle);
|
||||
|
||||
bio_ss
|
||||
.setup_fifo_event_triggers(FifoEventConfig {
|
||||
which: Fifo::Fifo0,
|
||||
trigger_slot: TriggerSlot::new_with_raw_value(1),
|
||||
level: FifoLevel::new_with_raw_value(1),
|
||||
trigger_less_than: false,
|
||||
trigger_greater_than: true,
|
||||
trigger_equal_to: true,
|
||||
})
|
||||
.expect("couldn't set FIFO trigger configuration");
|
||||
bio_ss
|
||||
.setup_fifo_event_triggers(FifoEventConfig {
|
||||
which: Fifo::Fifo0,
|
||||
trigger_slot: TriggerSlot::new_with_raw_value(0),
|
||||
level: FifoLevel::new_with_raw_value(0),
|
||||
trigger_less_than: false,
|
||||
trigger_greater_than: false,
|
||||
trigger_equal_to: true,
|
||||
})
|
||||
.expect("couldn't set FIFO trigger configuration");
|
||||
|
||||
let mut loader = BioLoader {
|
||||
chunks: vec![None; NUM_CHUNKS],
|
||||
received_count: 0,
|
||||
target_freq: 700_000_000,
|
||||
pin_spec: vec![],
|
||||
code: None,
|
||||
store: keystore,
|
||||
bio_ss,
|
||||
_fifo_handle: fifo_handle,
|
||||
fifo,
|
||||
resource_grant,
|
||||
core_init: false,
|
||||
};
|
||||
match loader.reload() {
|
||||
Err(s) => {
|
||||
log::error!("Couldn't setup BIO: {:?}", s)
|
||||
}
|
||||
_ => (),
|
||||
}
|
||||
|
||||
loader
|
||||
}
|
||||
|
||||
pub fn reload(&mut self) -> Result<(), String> {
|
||||
let config = {
|
||||
let mut clk_buf = [0u8; 4];
|
||||
let clk_slice = self
|
||||
.store
|
||||
.read_app_key(APP_BIO_CLK_INDEX)
|
||||
.map_err(|_| "Couldn't read keystore".to_string())?;
|
||||
clk_buf.copy_from_slice(&clk_slice[..4]);
|
||||
self.target_freq = 350_000_000;
|
||||
if clk_buf != [0u8; 4] {
|
||||
let target_freq = u32::from_le_bytes(clk_buf);
|
||||
if target_freq > 0 && target_freq <= 350_000_000 {
|
||||
log::info!("target_freq {}", target_freq);
|
||||
self.target_freq = target_freq;
|
||||
CoreConfig { clock_mode: bao1x_api::bio::ClockMode::TargetFreqInt(target_freq) }
|
||||
} else {
|
||||
CoreConfig { clock_mode: bao1x_api::bio::ClockMode::TargetFreqInt(350_000_000) }
|
||||
}
|
||||
} else {
|
||||
CoreConfig { clock_mode: bao1x_api::bio::ClockMode::TargetFreqInt(350_000_000) }
|
||||
}
|
||||
};
|
||||
// release any claimed pins
|
||||
let mut io_config = IoConfig::default();
|
||||
for pin in &self.pin_spec {
|
||||
self.bio_ss.release_dynamic_pin(*pin, &BioLoader::resource_spec().claimer).ok();
|
||||
io_config.mapped |= 1 << (*pin as u32);
|
||||
}
|
||||
if io_config.mapped != 0 {
|
||||
io_config.mode = IoConfigMode::ClearOnly;
|
||||
io_config.mapped = !io_config.mapped;
|
||||
self.bio_ss.setup_io_config(io_config).ok();
|
||||
}
|
||||
// now init a new set of pins
|
||||
let mut pin_spec = self
|
||||
.store
|
||||
.read_app_key(APP_BIO_PINS_INDEX)
|
||||
.map_err(|_| "Couldn't read keystore".to_string())?
|
||||
.to_vec();
|
||||
|
||||
let mut code_buf = [0u8; 0xf00];
|
||||
let code_found =
|
||||
self.store.read_app_key(APP_BIO_CODE_VALID).map_err(|_| "Couldn't read keystore".to_string())?[0]
|
||||
!= 0;
|
||||
for (fetch_index, chunk) in APP_BIO_CODE_INDICES.zip(code_buf.chunks_mut(32)) {
|
||||
chunk.copy_from_slice(
|
||||
&self
|
||||
.store
|
||||
.read_app_key(fetch_index as usize)
|
||||
.map_err(|_| "Couldn't read keystore".to_string())?,
|
||||
);
|
||||
}
|
||||
|
||||
if code_found && code_buf.iter().any(|&b| b != 0) {
|
||||
log::info!("code: {:x?}", &code_buf[..16]);
|
||||
if self.core_init {
|
||||
self.bio_ss.de_init_core(self.resource_grant.cores[0]).ok();
|
||||
self.core_init = false;
|
||||
}
|
||||
let actual_freq = self
|
||||
.bio_ss
|
||||
.init_core(self.resource_grant.cores[0], (&code_buf, None), config)
|
||||
.map_err(|e| format!("Couldn't init core: {:?}", e))?;
|
||||
if let Some(actual) = actual_freq {
|
||||
log::info!("Actual quantum frequency: {}Hz", actual);
|
||||
}
|
||||
self.core_init = true;
|
||||
} else {
|
||||
log::info!("No code to load");
|
||||
}
|
||||
self.code = Some(code_buf);
|
||||
|
||||
check_pins(&mut pin_spec);
|
||||
log::info!("Finalized pin spec {:?}", pin_spec);
|
||||
let mut io_config = IoConfig::default();
|
||||
for pin in &pin_spec {
|
||||
log::info!("Claiming pin {}", *pin);
|
||||
// claim pin resource - this only claims the resource, it does not configure it
|
||||
self.bio_ss
|
||||
.claim_dynamic_pin(*pin, &BioLoader::resource_spec().claimer)
|
||||
.map_err(|_| "can't claim pin".to_string())?;
|
||||
// now configure the claimed resource
|
||||
io_config.mapped |= 1 << (*pin as u32);
|
||||
}
|
||||
if io_config.mapped != 0 {
|
||||
io_config.mode = IoConfigMode::SetOnly;
|
||||
log::info!("Map pin mask {:x}", io_config.mapped);
|
||||
self.bio_ss.setup_io_config(io_config).ok();
|
||||
}
|
||||
self.pin_spec = pin_spec;
|
||||
|
||||
if code_found {
|
||||
log::info!("Set core to run {:?}", self.resource_grant);
|
||||
self.bio_ss.set_core_run_state(&self.resource_grant, true);
|
||||
} else {
|
||||
log::info!("Set core to halt {:?}", self.resource_grant);
|
||||
self.bio_ss.set_core_run_state(&self.resource_grant, false);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Return true when every chunk slot is filled.
|
||||
pub fn is_complete(&self) -> bool { self.received_count == NUM_CHUNKS }
|
||||
|
||||
/// Assemble all received chunks into a `[u8; 0xf00]` code chunk.
|
||||
/// Panics if `is_complete()` is false - caller should check first.
|
||||
pub fn to_code(&self) -> [u8; BIO_MEM_BYTES] {
|
||||
assert!(self.is_complete(), "code not yet complete");
|
||||
let mut code = [0u8; BIO_MEM_BYTES];
|
||||
for (chunk_idx, slot) in self.chunks.iter().enumerate() {
|
||||
let data = slot.as_ref().unwrap();
|
||||
let word_base = chunk_idx * CHUNK_DATA_SIZE;
|
||||
code[word_base..word_base + CHUNK_DATA_SIZE].copy_from_slice(data);
|
||||
}
|
||||
code
|
||||
}
|
||||
|
||||
/// Reset all state in the holding buffer (not to be confused with clearing the PDDB stored data)
|
||||
pub fn clear(&mut self) {
|
||||
for slot in self.chunks.iter_mut() {
|
||||
*slot = None;
|
||||
}
|
||||
self.received_count = 0;
|
||||
}
|
||||
|
||||
/// Persist the assembled code to PDDB, clear in-memory state, and signal
|
||||
/// a reload. Called both from the normal last-chunk path and from `pad`.
|
||||
fn commit(&mut self) -> &'static str {
|
||||
let code = self.to_code();
|
||||
for (i, chunk) in APP_BIO_CODE_INDICES.zip(code.chunks(32)) {
|
||||
self.store.write_app_key(i, chunk.try_into().unwrap()).unwrap();
|
||||
}
|
||||
self.store.write_app_key(APP_BIO_CODE_VALID, &VALID_CODE);
|
||||
self.clear(); // clears the holding buffer for incoming code
|
||||
"SUCCESS"
|
||||
}
|
||||
}
|
||||
|
||||
impl Resources for BioLoader {
|
||||
fn resource_spec() -> ResourceSpec {
|
||||
ResourceSpec {
|
||||
claimer: "BIO loader".to_string(),
|
||||
cores: vec![CoreRequirement::Any],
|
||||
fifos: vec![Fifo::Fifo0],
|
||||
static_pins: vec![],
|
||||
dynamic_pin_count: 17,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for BioLoader {
|
||||
fn drop(&mut self) {
|
||||
for &core in self.resource_grant.cores.iter() {
|
||||
self.bio_ss.de_init_core(core).unwrap();
|
||||
}
|
||||
self.core_init = false;
|
||||
let mut io_config = IoConfig::default();
|
||||
for pin in &self.pin_spec {
|
||||
self.bio_ss.release_dynamic_pin(*pin, &BioLoader::resource_spec().claimer).ok();
|
||||
io_config.mapped |= 1 << (*pin as u32);
|
||||
}
|
||||
if io_config.mapped != 0 {
|
||||
io_config.mode = IoConfigMode::ClearOnly;
|
||||
io_config.mapped = !io_config.mapped;
|
||||
self.bio_ss.setup_io_config(io_config).unwrap();
|
||||
}
|
||||
self.bio_ss.release_resources(self.resource_grant.grant_id).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
// -- ShellCmdApi implementation ------------------------------------------------
|
||||
|
||||
impl<'a> ShellCmdApi<'a> for BioLoader {
|
||||
cmd_api!(bio);
|
||||
|
||||
fn process(&mut self, args: String, _env: &mut CommonEnv) -> Result<Option<String>, xous::Error> {
|
||||
let mut ret = String::new();
|
||||
|
||||
if args == "ready" {
|
||||
write!(ret, "OK").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
if args == "clear" {
|
||||
self.clear();
|
||||
self.store.write_app_key(APP_BIO_PINS_INDEX, &[0u8; 32]).ok();
|
||||
self.store.write_app_key(APP_BIO_CLK_INDEX, &[0u8; 32]).ok();
|
||||
// instead of writing all 0's to the code space
|
||||
self.store.write_app_key(APP_BIO_CODE_VALID, &[0u8; 32]).ok();
|
||||
|
||||
for &core in self.resource_grant.cores.iter() {
|
||||
self.bio_ss.de_init_core(core).unwrap();
|
||||
}
|
||||
self.core_init = false;
|
||||
let mut io_config = IoConfig::default();
|
||||
for pin in &self.pin_spec {
|
||||
self.bio_ss.release_dynamic_pin(*pin, &BioLoader::resource_spec().claimer).ok();
|
||||
io_config.mapped |= 1 << (*pin as u32);
|
||||
}
|
||||
if io_config.mapped != 0 {
|
||||
io_config.mode = IoConfigMode::ClearOnly;
|
||||
io_config.mapped = !io_config.mapped;
|
||||
self.bio_ss.setup_io_config(io_config).unwrap();
|
||||
}
|
||||
self.pin_spec = vec![];
|
||||
// don't release this - we still "own" it just in case we get new code uploaded
|
||||
// self.bio_ss.release_resources(self.resource_grant.grant_id).unwrap();
|
||||
|
||||
write!(ret, "CLEAR").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
if args.starts_with("pin") {
|
||||
let arg_list: Vec<&str> = args.split_whitespace().collect();
|
||||
let mut pins = Vec::<u8>::new();
|
||||
if arg_list.len() >= 2 {
|
||||
for pin_str in &arg_list[1..] {
|
||||
if let Ok(pin) = u8::from_str_radix(pin_str, 10) {
|
||||
pins.push(pin);
|
||||
}
|
||||
}
|
||||
check_pins(&mut pins);
|
||||
let mut pin_list = [0u8; 32];
|
||||
for (i, p) in pins.iter().enumerate() {
|
||||
pin_list[i] = *p;
|
||||
}
|
||||
if let Err(e) = self.store.write_app_key(APP_BIO_PINS_INDEX, &pin_list) {
|
||||
write!(ret, "Write failure: {:?}", e).ok();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
log::info!("Set pin spec of {:x?}", pin_list);
|
||||
}
|
||||
write!(ret, "OK").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
if args.starts_with("clk") {
|
||||
let arg_list: Vec<&str> = args.split_whitespace().collect();
|
||||
if arg_list.len() >= 2 {
|
||||
if let Ok(clk) = u32::from_str_radix(arg_list[1], 10) {
|
||||
let mut clk_bytes = [0u8; 32];
|
||||
clk_bytes[..4].copy_from_slice(&clk.to_le_bytes());
|
||||
if let Err(e) = self.store.write_app_key(APP_BIO_CLK_INDEX, &clk_bytes) {
|
||||
write!(ret, "Write failure: {:?}", e).ok();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
}
|
||||
}
|
||||
write!(ret, "OK").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
if args.starts_with("reload") {
|
||||
match self.reload() {
|
||||
Ok(_) => {
|
||||
write!(ret, "BIO load successful").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
Err(e) => {
|
||||
write!(ret, "ERR {:?}", e).unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if args.starts_with("rx") {
|
||||
self.bio_ss.debug(self.resource_grant.cores[0]);
|
||||
let arg_list: Vec<&str> = args.split_whitespace().collect();
|
||||
let iters =
|
||||
if arg_list.len() >= 2 { usize::from_str_radix(arg_list[1], 10).unwrap_or(1) } else { 1 };
|
||||
let timeout = if arg_list.len() >= 3 {
|
||||
Duration::from_secs(u64::from_str_radix(arg_list[2], 10).unwrap_or(1))
|
||||
} else {
|
||||
Duration::from_secs(1)
|
||||
};
|
||||
for _ in 0..iters {
|
||||
let start = std::time::Instant::now();
|
||||
while self.fifo.csr.rf(utralib::utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0) == 0 {
|
||||
// wait for entry
|
||||
if std::time::Instant::now().duration_since(start) > timeout {
|
||||
log::info!("timeout");
|
||||
break;
|
||||
}
|
||||
}
|
||||
let dat = self.fifo.csr.r(utralib::utra::bio_bdma::SFR_RXF0);
|
||||
log::info!("{:x?}", dat);
|
||||
}
|
||||
write!(ret, "OK").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
if args.starts_with("tx") {
|
||||
let arg_list: Vec<&str> = args.split_whitespace().collect();
|
||||
if arg_list.len() >= 2 {
|
||||
let s = arg_list[1].trim();
|
||||
let val = if let Some(hex) = s.strip_prefix("0x").or_else(|| s.strip_prefix("0X")) {
|
||||
u32::from_str_radix(hex, 16).map_err(|e| e.to_string())
|
||||
} else {
|
||||
s.parse::<u32>().map_err(|e| e.to_string())
|
||||
};
|
||||
let iters =
|
||||
if arg_list.len() == 3 { usize::from_str_radix(arg_list[2], 10).unwrap_or(1) } else { 1 };
|
||||
let mut timeout = false;
|
||||
if let Ok(val) = val {
|
||||
for _ in 0..iters {
|
||||
let start = std::time::Instant::now();
|
||||
while self.fifo.csr.rf(utralib::utra::bio_bdma::SFR_FLEVEL_PCLK_REGFIFO_LEVEL0) > 7 {
|
||||
// don't overflow the fifo
|
||||
// wait for entry
|
||||
if std::time::Instant::now().duration_since(start) > Duration::from_secs(5) {
|
||||
log::info!("timeout");
|
||||
timeout = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if timeout {
|
||||
break;
|
||||
}
|
||||
self.fifo.csr.wo(utralib::utra::bio_bdma::SFR_TXF0, val);
|
||||
log::info!("{:x?}", val);
|
||||
}
|
||||
write!(ret, "OK").unwrap();
|
||||
} else {
|
||||
write!(ret, "ERR bad argument").unwrap();
|
||||
}
|
||||
} else {
|
||||
write!(ret, "ERR tx <val> [repeat]").unwrap();
|
||||
}
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
if args == "pad" {
|
||||
// Zero-fill every slot not yet received, then commit.
|
||||
// This allows the host to send only the chunks that carry real data
|
||||
// and let the device pad the remainder of the 0xf00-byte buffer.
|
||||
|
||||
for slot in self.chunks.iter_mut() {
|
||||
if slot.is_none() {
|
||||
*slot = Some([0u8; CHUNK_DATA_SIZE]);
|
||||
|
||||
self.received_count += 1;
|
||||
}
|
||||
}
|
||||
|
||||
write!(ret, "{}", self.commit()).unwrap();
|
||||
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
// -- Decode base64 argument --------------------------------------------
|
||||
let b64 = args.trim();
|
||||
if b64.is_empty() {
|
||||
write!(ret, "ERR").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
let decoded = match B64.decode(b64) {
|
||||
Ok(d) => d,
|
||||
Err(_) => {
|
||||
write!(ret, "ERR").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
};
|
||||
|
||||
if decoded.len() != CHUNK_WIRE_SIZE {
|
||||
write!(ret, "ERR").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
// -- Parse fields ------------------------------------------------------
|
||||
let index = u16::from_be_bytes([decoded[0], decoded[1]]) as usize;
|
||||
// data lives at decoded[2..66]
|
||||
let received_crc = u32::from_be_bytes([decoded[66], decoded[67], decoded[68], decoded[69]]);
|
||||
|
||||
// -- Verify CRC over (index bytes || data) -----------------------------
|
||||
let computed_crc = crc32fast::hash(&decoded[..CHUNK_INDEX_BYTES + CHUNK_DATA_SIZE]);
|
||||
if computed_crc != received_crc {
|
||||
write!(ret, "ERR").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
// -- Bounds-check index ------------------------------------------------
|
||||
if index >= NUM_CHUNKS {
|
||||
write!(ret, "ERR").unwrap();
|
||||
return Ok(Some(ret));
|
||||
}
|
||||
|
||||
// -- Store chunk (silent overwrite on duplicate) -----------------------
|
||||
let mut data_arr = [0u8; CHUNK_DATA_SIZE];
|
||||
data_arr.copy_from_slice(&decoded[CHUNK_INDEX_BYTES..CHUNK_INDEX_BYTES + CHUNK_DATA_SIZE]);
|
||||
|
||||
let was_empty = self.chunks[index].is_none();
|
||||
self.chunks[index] = Some(data_arr);
|
||||
if was_empty {
|
||||
self.received_count += 1;
|
||||
}
|
||||
|
||||
// -- Reply -------------------------------------------------------------
|
||||
if self.is_complete() {
|
||||
write!(ret, "{}", self.commit()).unwrap();
|
||||
} else {
|
||||
write!(ret, "OK").unwrap();
|
||||
}
|
||||
|
||||
Ok(Some(ret))
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue