refactor: 重命名 submit2 方法为 submit，并优化参数处理

Author: ZR233

src/gem.rs

@@ -8,12 +8,14 @@ use crate::{
 
 pub struct GemPool {
     pool: BTreeMap<u32, DVec<u8>>,
+    handle_counter: u32,
 }
 
 impl GemPool {
     pub const fn new() -> Self {
         GemPool {
             pool: BTreeMap::new(),
+            handle_counter: 1,
         }
     }
 
@@ -25,9 +27,14 @@ impl GemPool {
             Direction::Bidirectional,
         )
         .unwrap();
-        args.handle = data.bus_addr() as _;
+
+        let handle = self.handle_counter;
+        self.handle_counter = self.handle_counter.wrapping_add(1);
+
+        args.handle = handle;
         args.sram_size = data.len() as _;
         args.dma_addr = data.bus_addr();
+        args.obj_addr = data.as_ptr() as _;
         self.pool.insert(args.handle, data);
         Ok(())
     }

src/ioctrl.rs

@@ -1,4 +1,4 @@
-use crate::{Rknpu, RknpuError, SubmitBase, SubmitRef};
+use crate::{JobMode, Rknpu, RknpuError, RknpuTask, SubmitBase, SubmitRef};
 
 /// 子核心任务索引结构体
 ///
@@ -95,49 +95,45 @@ pub struct RknpuMemSync {
 }
 
 impl Rknpu {
-    pub fn submit_ioctrl(&self, args: &mut RknpuSubmit) -> Result<(), RknpuError> {
-        let mut n = 0;
-        let all = args.task_number as usize;
+    pub fn submit_ioctrl(&mut self, args: &mut RknpuSubmit) -> Result<(), RknpuError> {
+        let mut tasks = unsafe {
+            core::slice::from_raw_parts(
+                args.task_obj_addr as *const RknpuTask,
+                args.task_number as usize,
+            )
+        };
         let max_submit_number = self.data.max_submit_number as usize;
-        let mut task_start = args.task_start;
-        let mut int_mask = 0;
 
-        while n < all {
-            let task_number = core::cmp::min(all - n, max_submit_number);
-            task_start = args.task_start + n as u32;
-            let task_end = task_start + task_number as u32 - 1;
+        while !tasks.is_empty() {
+            let submit_tasks = if tasks.len() > max_submit_number {
+                &tasks[..max_submit_number]
+            } else {
+                tasks
+            };
 
             let job = SubmitRef {
                 base: SubmitBase {
-                    flags: todo!(),
-                    task_base_addr: todo!(),
-                    core_idx: todo!(),
-                    int_mask: todo!(),
-                    int_clear: todo!(),
-                    regcfg_amount: todo!(),
+                    flags: JobMode::from_bits_retain(args.flags),
+                    task_base_addr: args.task_base_addr as _,
+                    core_idx: args.core_mask.trailing_zeros() as usize,
+                    int_mask: submit_tasks.last().unwrap().int_mask,
+                    int_clear: submit_tasks.last().unwrap().int_clear,
+                    regcfg_amount: submit_tasks[0].regcfg_amount,
                 },
-                task_number,
-                regcmd_base_addr: todo!(),
+                task_number: submit_tasks.len(),
+                regcmd_base_addr: submit_tasks[0].regcmd_addr as _,
             };
             self.base[0].submit_pc(&self.data, &job).unwrap();
-            debug!(
-                "Submitted tasks from {} to {}",
-                task_start,
-                task_start + task_number as u32 - 1
-            );
+
+            // Wait for completion
             loop {
                 let status = self.base[0].handle_interrupt();
-                if status == int_mask {
+                if status == job.base.int_mask {
                     break;
                 }
             }
 
-            debug!(
-                "Completed tasks from {} to {}",
-                task_start,
-                task_start + task_number as u32 - 1
-            );
-            n += task_number;
+            tasks = &tasks[submit_tasks.len()..];
         }
 
         Ok(())

src/lib.rs

@@ -331,7 +331,7 @@ impl Rknpu {
     // }
 
     pub fn submit(&mut self, job: &mut Submit) -> Result<(), RknpuError> {
-        self.base[0].submit2(&self.data, job)
+        self.base[0].submit(&self.data, job)
     }
 
     pub fn handle_interrupt0(&mut self) -> u32 {

src/registers/mod.rs

@@ -165,90 +165,13 @@ impl RknpuCore {
         Ok(())
     }
 
-    pub fn submit2(&mut self, config: &RknpuData, args: &Submit) -> Result<(), RknpuError> {
+    pub fn submit(&mut self, config: &RknpuData, args: &Submit) -> Result<(), RknpuError> {
         if args.tasks.len() > config.max_submit_number as usize {
             todo!()
         }
-
         self.submit_pc(config, &args.as_ref())
     }
 
-    pub fn submit(
-        &mut self,
-        config: &RknpuData,
-        flags: JobMode,
-        tasks: &[RknpuTask],
-        task_base_addr: u32,
-        core_idx: usize,
-    ) -> Result<usize, RknpuError> {
-        if tasks.is_empty() {
-            return Ok(0);
-        }
-
-        let pc_data_amount_scale = config.pc_data_amount_scale;
-
-        self.pc().base_address.set(1);
-
-        let task_pp_en = if flags.contains(JobMode::PINGPONG) {
-            1
-        } else {
-            0
-        };
-        let pc_task_number_bits = config.pc_task_number_bits;
-
-        if config.irqs.get(core_idx).is_some() {
-            let val = 0xe + 0x10000000 * core_idx as u32;
-
-            debug!("Set PC S_POINTER to {:#x}", val);
-
-            self.cna().s_pointer.set(val);
-            self.core().s_pointer.set(val);
-        }
-
-        let submit_tasks = if tasks.len() > config.max_submit_number as usize {
-            &tasks[0..config.max_submit_number as usize]
-        } else {
-            tasks
-        };
-
-        let pc_base_addr = submit_tasks[0].regcmd_addr as u32;
-
-        debug!("Set PC BASE_ADDRESS to {:#x}", pc_base_addr);
-
-        self.pc().base_address.set(pc_base_addr);
-
-        let amount = (submit_tasks[0].regcfg_amount + RKNPU_PC_DATA_EXTRA_AMOUNT)
-            .div_ceil(pc_data_amount_scale)
-            - 1;
-
-        debug!("Set PC REGISTER_AMOUNTS to {:#x}", amount);
-
-        self.pc().register_amounts.set(amount);
-
-        self.pc()
-            .interrupt_mask
-            .set(submit_tasks.last().unwrap().int_mask);
-        self.pc()
-            .interrupt_clear
-            .set(submit_tasks.last().unwrap().int_clear);
-        let task_number = submit_tasks.len() as u32;
-
-        let task_control = ((0x6 | task_pp_en) << pc_task_number_bits) | task_number;
-        debug!("Set PC TASK_CONTROL to {:#x}", task_control);
-        self.pc().task_control.set(task_control);
-        debug!("Set PC TASK_DMA_BASE_ADDR to {:#x}", task_base_addr);
-        self.pc().task_dma_base_addr.set(task_base_addr);
-
-        self.pc().operation_enable.set(1);
-        self.pc().operation_enable.set(0);
-
-        for task in submit_tasks {
-            debug!("Submitted task: {:#x?}", task);
-        }
-
-        Ok(submit_tasks.len())
-    }
-
     pub fn handle_interrupt(&self) -> u32 {
         let int_status = self.pc().interrupt_status.get();
         self.pc().interrupt_clear.set(INT_CLEAR_ALL);