From 35cdc0c0f523eb4c67a911037d17429c696d06a8 Mon Sep 17 00:00:00 2001 From: bunnie Date: Fri, 2 Jan 2026 11:25:37 +0800 Subject: [PATCH] resource tracking implementation --- libs/bao1x-hal/src/bio.rs | 129 ++++++++++++++++++++++++++++++++--- libs/bao1x-hal/src/bio_hw.rs | 2 +- 2 files changed, 121 insertions(+), 10 deletions(-) diff --git a/libs/bao1x-hal/src/bio.rs b/libs/bao1x-hal/src/bio.rs index fe4ea09e0..3f982dd4b 100644 --- a/libs/bao1x-hal/src/bio.rs +++ b/libs/bao1x-hal/src/bio.rs @@ -1,6 +1,5 @@ -use std::marker::PhantomData; - use bao1x_api::bio::*; +use bao1x_api::bio_resources::*; use num_traits::*; use rkyv::option::ArchivedOption; use utralib::*; @@ -19,15 +18,14 @@ impl Bio { } } -pub struct CoreCsr<'a> { +pub struct CoreCsr { pub csr: CSR, - _lifetime: PhantomData<&'a ()>, } -impl<'a> CoreCsr<'a> { - pub fn from_handle(handle: CoreHandle<'a>) -> Self { - let (pointer, lifetime) = unsafe { handle.handle() }; +impl CoreCsr { + pub fn from_handle(handle: &CoreHandle) -> Self { + let pointer = unsafe { handle.handle() }; // safety: this structure tracks the lifetime of the handle, and is therefore safe. - Self { csr: CSR::new(pointer as *mut u32), _lifetime: lifetime } + Self { csr: CSR::new(pointer as *mut u32) } } } @@ -81,7 +79,7 @@ impl<'a> BioApi<'a> for Bio { Ok(()) } - unsafe fn get_core_handle(&'a self, fifo: Fifo) -> Result>, BioError> { + unsafe fn get_core_handle(&self, fifo: Fifo) -> Result, BioError> { match send_message( self.conn, Message::new_blocking_scalar(BioOp::GetCoreHandle.to_usize().unwrap(), fifo as usize, 0, 0, 0), @@ -221,3 +219,116 @@ impl<'a> BioApi<'a> for Bio { Ok(()) } } + +#[cfg(feature = "std")] +impl BioResources for Bio { + fn claim_resources(&self, spec: &ResourceSpec) -> Result { + let request = ClaimResourcesRequest { spec: spec.clone(), grant: None, error: ResourceError::None }; + let mut buf = Buffer::into_buf(request).unwrap(); + buf.lend_mut(self.conn, BioOp::ClaimResources.to_u32().unwrap()) + .map_err(|_| ResourceError::InternalError)?; + let response = buf.to_original::().unwrap(); + match response.error { + ResourceError::None => response.grant.ok_or(ResourceError::InternalError), + e => Err(e), + } + } + + fn release_resources(&self, grant_id: u32) -> Result<(), ResourceError> { + match send_message( + self.conn, + Message::new_blocking_scalar( + BioOp::ReleaseResources.to_usize().unwrap(), + grant_id as usize, + 0, + 0, + 0, + ), + ) { + Ok(xous::Result::Scalar5(_, result, _, _, _)) => { + if result == 0 { + Ok(()) + } else { + Err(ResourceError::InvalidGrantId(grant_id)) + } + } + _ => Err(ResourceError::InternalError), + } + } + + fn resource_availability(&self) -> Result { + let response = ResourceAvailabilityResponse { availability: ResourceAvailability::default() }; + let mut buf = Buffer::into_buf(response).unwrap(); + buf.lend_mut(self.conn, BioOp::ResourceAvailability.to_u32().unwrap()) + .map_err(|e| >::into(e))?; + let response = buf.to_original::().unwrap(); + Ok(response.availability) + } + + fn check_resources(&self, spec: &ResourceSpec) -> Result<(), ResourceError> { + let request = ClaimResourcesRequest { spec: spec.clone(), grant: None, error: ResourceError::None }; + let mut buf = Buffer::into_buf(request).unwrap(); + buf.lend_mut(self.conn, BioOp::CheckResources.to_u32().unwrap()) + .map_err(|_| ResourceError::InternalError)?; + let response = buf.to_original::().unwrap(); + match response.error { + ResourceError::None => Ok(()), + e => Err(e), + } + } + + fn check_resources_batch(&self, specs: &[ResourceSpec]) -> Result<(), ResourceError> { + let request = CheckResourcesBatchRequest { specs: specs.to_vec(), error: ResourceError::None }; + let mut buf = Buffer::into_buf(request).unwrap(); + buf.lend_mut(self.conn, BioOp::CheckResourcesBatch.to_u32().unwrap()) + .map_err(|_| ResourceError::InternalError)?; + let response = buf.to_original::().unwrap(); + match response.error { + ResourceError::None => Ok(()), + e => Err(e), + } + } + + fn claim_dynamic_pin(&self, pin: u8, claimer: &str) -> Result<(), ResourceError> { + let request = DynamicPinRequest { pin, claimer: claimer.to_string(), error: ResourceError::None }; + let mut buf = Buffer::into_buf(request).unwrap(); + buf.lend_mut(self.conn, BioOp::ClaimDynamicPin.to_u32().unwrap()) + .map_err(|_| ResourceError::InternalError)?; + let response = buf.to_original::().unwrap(); + match response.error { + ResourceError::None => Ok(()), + e => Err(e), + } + } + + fn release_dynamic_pin(&self, pin: u8, claimer: &str) -> Result<(), ResourceError> { + let request = DynamicPinRequest { pin, claimer: claimer.to_string(), error: ResourceError::None }; + let mut buf = Buffer::into_buf(request).unwrap(); + buf.lend_mut(self.conn, BioOp::ReleaseDynamicPin.to_u32().unwrap()) + .map_err(|_| ResourceError::InternalError)?; + let response = buf.to_original::().unwrap(); + match response.error { + ResourceError::None => Ok(()), + e => Err(e), + } + } + + fn set_core_run_state(&self, grant: &ResourceGrant, start: bool) { + let mut run_states = [CoreRunSetting::Unchanged; 4]; + for core in grant.cores.iter() { + run_states[*core as usize] = if start { CoreRunSetting::Start } else { CoreRunSetting::Stop }; + } + + send_message( + self.conn, + Message::new_blocking_scalar( + BioOp::CoreState.to_usize().unwrap(), + run_states[0] as usize, + run_states[1] as usize, + run_states[2] as usize, + run_states[3] as usize, + ), + ) + .unwrap(); + } +} diff --git a/libs/bao1x-hal/src/bio_hw.rs b/libs/bao1x-hal/src/bio_hw.rs index 8519b5a5c..9a3d5ba78 100644 --- a/libs/bao1x-hal/src/bio_hw.rs +++ b/libs/bao1x-hal/src/bio_hw.rs @@ -453,7 +453,7 @@ impl<'a> BioApi<'a> for BioSharedState { prev_freq } - unsafe fn get_core_handle(&'a self, _fifo: Fifo) -> Result>, BioError> { + unsafe fn get_core_handle(&self, _fifo: Fifo) -> Result, BioError> { unimplemented!("This is managed by the main loop server, not the hardware interface"); }