Add HMB as an example of an optional api

ThadHouse · ThadHouse · commit c7c022c5894b · 2023-09-02T12:37:24.000-07:00
diff --git a/ni-fpga-sys/src/lib.rs b/ni-fpga-sys/src/lib.rs
@@ -46,19 +46,33 @@ pub type Offset = u32;
 pub type Session = u32;
 pub type Status = i32;
 
-use std::{ffi::c_char, fmt};
+use std::{
+    ffi::{c_char, c_void},
+    fmt,
+};
 
 use dlopen::{
     utils::platform_file_name,
-    wrapper::{Container, WrapperApi},
+    wrapper::{Container, WrapperApi, WrapperMultiApi},
 };
 
-use dlopen_derive::WrapperApi;
+use dlopen_derive::{WrapperApi, WrapperMultiApi};
 
 pub type NiFpgaApiContainer = Container<NiFpgaApi>;
 
 #[derive(WrapperApi)]
-pub struct NiFpgaApi {
+pub struct NiFpgaHmbApi {
+    NiFpgaDll_OpenHmb: extern "C" fn(
+        session: Session,
+        memory_name: *const c_char,
+        memory_size: *mut usize,
+        virual_address: *mut *mut c_void,
+    ) -> Status,
+    NiFpgaDll_CloseHmb: extern "C" fn(session: Session, memory_name: *const c_char) -> Status,
+}
+
+#[derive(WrapperApi)]
+pub struct NiFpgaBaseApi {
     NiFpgaDll_Open: extern "C" fn(
         bitfile: *const c_char,
         signature: *const c_char,
@@ -169,6 +183,12 @@ pub struct NiFpgaApi {
     ) -> Status,
 }
 
+#[derive(WrapperMultiApi)]
+pub struct NiFpgaApi {
+    pub base: NiFpgaBaseApi,
+    pub hmb: Option<NiFpgaHmbApi>,
+}
+
 impl NiFpgaApi {
     pub fn load() -> Result<NiFpgaApiContainer, DlOpenError> {
         match unsafe { Container::load(platform_file_name("NiFpga")) } {
diff --git a/ni-fpga/src/hmb.rs b/ni-fpga/src/hmb.rs
@@ -0,0 +1,61 @@
+use std::{
+    ffi::{c_void, CString},
+    mem::size_of,
+    ptr,
+};
+
+use ni_fpga_sys::{NiFpgaHmbApi, Session};
+
+pub struct Hmb<'a> {
+    api: &'a NiFpgaHmbApi,
+    session: Session,
+    memory_name: CString,
+    memory_size: usize,
+    virtual_address: *mut c_void,
+}
+
+impl<'a> Hmb<'a> {
+    pub fn new(
+        api: &'a NiFpgaHmbApi,
+        session: Session,
+        memory_name: CString,
+        memory_size: usize,
+        virtual_address: *mut c_void,
+    ) -> Hmb<'a> {
+        Self {
+            api,
+            session,
+            memory_name,
+            memory_size,
+            virtual_address,
+        }
+    }
+
+    pub fn read<T>(&self, offset: usize) -> T {
+        unsafe {
+            assert!(size_of::<T>() + offset <= self.memory_size);
+            let base: *const u8 = self.virtual_address as *const u8;
+            let address = base.add(offset);
+            let typed_address = address as *const T;
+            ptr::read_volatile(typed_address)
+        }
+    }
+
+    pub fn write<T>(&mut self, offset: usize, value: T) {
+        unsafe {
+            assert!(size_of::<T>() + offset <= self.memory_size);
+            let base: *mut u8 = self.virtual_address as *mut u8;
+            let address = base.add(offset);
+            let typed_address = address as *mut T;
+            ptr::write_volatile(typed_address, value);
+        }
+    }
+}
+
+impl<'a> Drop for Hmb<'a> {
+    fn drop(&mut self) {
+        // TODO figure out what to do here with the return value
+        self.api
+            .NiFpgaDll_CloseHmb(self.session, self.memory_name.as_ptr());
+    }
+}
diff --git a/ni-fpga/src/lib.rs b/ni-fpga/src/lib.rs
@@ -6,6 +6,7 @@ extern crate ni_fpga_sys as ffi;
 mod datatype;
 mod errors;
 pub mod fxp;
+pub mod hmb;
 mod nifpga;
 mod session;
 mod status;
diff --git a/ni-fpga/src/nifpga.rs b/ni-fpga/src/nifpga.rs
@@ -1,8 +1,11 @@
-use std::ffi::CString;
+use std::{
+    ffi::{c_void, CString},
+    ptr,
+};
 
 use ni_fpga_sys::{NiFpgaApi, NiFpgaApiContainer, Offset, Session};
 
-use crate::Error;
+use crate::{hmb::Hmb, Error, Status};
 
 trait StatusHelper {
     fn to_result(self) -> Result<(), Error>;
@@ -27,12 +30,14 @@ macro_rules! type_wrapper {
         $readarr_fun_name:ident, $readarr_ffi_name:ident, $writearr_fun_name:ident, $writearr_ffi_name:ident) => {
         pub fn $read_fun_name(&self, indicator: Offset, value: &mut $type) -> Result<(), Error> {
             self.api
+                .base
                 .$read_ffi_name(self.session, indicator, value as *mut $type)
                 .to_result()
         }
 
-        pub fn $write_fun_name(&self, indicator: Offset, value: $type) -> Result<(), Error> {
+        pub fn $write_fun_name(&mut self, indicator: Offset, value: $type) -> Result<(), Error> {
             self.api
+                .base
                 .$write_ffi_name(self.session, indicator, value)
                 .to_result()
         }
@@ -43,12 +48,18 @@ macro_rules! type_wrapper {
             value: &mut [$type],
         ) -> Result<(), Error> {
             self.api
+                .base
                 .$readarr_ffi_name(self.session, indicator, value.as_mut_ptr(), value.len())
                 .to_result()
         }
 
-        pub fn $writearr_fun_name(&self, indicator: Offset, value: &[$type]) -> Result<(), Error> {
+        pub fn $writearr_fun_name(
+            &mut self,
+            indicator: Offset,
+            value: &[$type],
+        ) -> Result<(), Error> {
             self.api
+                .base
                 .$writearr_ffi_name(self.session, indicator, value.as_ptr(), value.len())
                 .to_result()
         }
@@ -156,6 +167,34 @@ impl NiFpga {
         NiFpgaDll_WriteArrayI64
     );
 
+    pub fn open_hmb(&self, memory_name: &CString) -> Result<Hmb, Error> {
+        match &self.api.hmb {
+            Some(hmb) => {
+                let mut memory_size: usize = 0;
+                let mut virtual_address: *mut c_void = ptr::null_mut();
+                match hmb
+                    .NiFpgaDll_OpenHmb(
+                        self.session,
+                        memory_name.as_ptr(),
+                        &mut memory_size,
+                        &mut virtual_address,
+                    )
+                    .to_result()
+                {
+                    Ok(_) => Ok(Hmb::new(
+                        hmb,
+                        self.session,
+                        memory_name.clone(),
+                        memory_size,
+                        virtual_address,
+                    )),
+                    Err(err) => Err(err),
+                }
+            }
+            None => Err(Error::FPGA(Status::ResourceNotInitialized)),
+        }
+    }
+
     pub fn open(
         bitfile: &CString,
         signature: &CString,
@@ -167,14 +206,15 @@ impl NiFpga {
             Err(err) => return Err(Error::DlOpen(err)),
         };
 
-        let mut session: u32 = 0;
+        let mut session: Session = 0;
         match api
+            .base
             .NiFpgaDll_Open(
                 bitfile.as_ptr(),
                 signature.as_ptr(),
                 resource.as_ptr(),
                 attribute,
-                &mut session as *mut Session,
+                &mut session,
             )
             .to_result()
         {
@@ -185,6 +225,7 @@ impl NiFpga {
 
     pub fn close(self, attribute: u32) -> Result<(), Error> {
         self.api
+            .base
             .NiFpgaDll_Close(self.session, attribute)
             .to_result()
     }
@@ -194,6 +235,6 @@ impl Drop for NiFpga {
     fn drop(&mut self) {
         // TODO figure out what to do here with attribute
         // and the return value
-        self.api.NiFpgaDll_Close(self.session, 0);
+        self.api.base.NiFpgaDll_Close(self.session, 0);
     }
 }
diff --git a/ni-fpga/src/session.rs b/ni-fpga/src/session.rs
@@ -32,7 +32,7 @@ impl Session {
             Err(err) => Err(err),
         }
     }
-    pub fn write<T: Datatype>(&self, offset: Offset, data: &T) -> Result<(), Error>
+    pub fn write<T: Datatype>(&mut self, offset: Offset, data: &T) -> Result<(), Error>
     where
         [u8; (T::SIZE_IN_BITS - 1) / 8 + 1]: Sized,
     {

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ impl Session {`
`32`	`32`	`Err(err) => Err(err),`
`33`	`33`	`}`
`34`	`34`	`}`
`35`		`- pub fn write<T: Datatype>(&self, offset: Offset, data: &T) -> Result<(), Error>`
	`35`	`+ pub fn write<T: Datatype>(&mut self, offset: Offset, data: &T) -> Result<(), Error>`
`36`	`36`	`where`
`37`	`37`	`[u8; (T::SIZE_IN_BITS - 1) / 8 + 1]: Sized,`
`38`	`38`	`{`