Files save on baremetal RPI

rpi/Cargo.toml

@@ -12,6 +12,7 @@ magenboy_common = {path = "../common"}
 log = "0.4"
 cfg-if = "1"
 bitfield-struct = "0.5"
+arrayvec = {version = "0.7", default-features = false}
 libc = {version = "0.2", optional = true}
 nix = {version = "0.24", optional = true}
 crossbeam-channel = {version = "0.5", optional = true}

rpi/src/bin/baremetal/link.ld

@@ -1,7 +1,7 @@
 /* Place _start procedure at the entry address for RPI */
 __rpi_32_phys_binary_load_addr = 0x8000;
 __isr_table_addr = 0;
-__stack_size = 0x100000; /* 1MB stack */
+__stack_size = 0x200000; /* 2MB stack */
 ENTRY(__rpi_32_phys_binary_load_addr)   /* enry point */
 
 SECTIONS

rpi/src/bin/baremetal/main.rs

@@ -29,6 +29,8 @@ pub extern "C" fn main()->!{
     let mut power_manager = unsafe{PERIPHERALS.take_power()};
 
     let mut fs = Fat32::new();
+    let mut content = b"alon hagever".clone();
+    fs.write_file("TEST    TXT", &mut content);
     let mut gfx = Ili9341GfxDevice::new(RESET_PIN_BCM, LED_PIN_BCM, TURBO, FRAME_LIMITER);
     let mut pause_menu_gfx = gfx.clone();
     let mut joypad_provider = GpioJoypadProvider::new(button_to_bcm_pin);
@@ -80,26 +82,27 @@ fn read_menu_options(fs: &mut Fat32, menu_options: &mut [MenuOption<FileEntry, S
     let mut menu_options_size = 0;
     let mut root_dir_offset = 0;
     const FILES_PER_LIST:usize = 20;
-    'search_dir_loop: loop{
+    loop{
         let dir_entries = fs.root_dir_list::<FILES_PER_LIST>(root_dir_offset);
-        for entry in dir_entries{
-            let Some(entry) = entry else {break 'search_dir_loop};
+        for entry in &dir_entries{
             let extension = entry.get_extension();
             if extension.eq_ignore_ascii_case("gb") || extension.eq_ignore_ascii_case("gbc"){
                 menu_options[menu_options_size] = MenuOption{ value: entry.clone(), prompt: StackString::from(entry.get_name()) };
                 menu_options_size += 1;
                 log::debug!("Detected ROM: {}", entry.get_name());
             }
         }
+        if dir_entries.remaining_capacity() != 0{
+            break;
+        }
         root_dir_offset += FILES_PER_LIST;
     }
     return menu_options_size;
 }
 
 #[panic_handler]
 fn panic(info:&PanicInfo)->!{
-    log::error!("An error has occoured!");
-    log::error!("{}", info);
+    log::error!("An error has occoured!: \r\n{}", info);
 
     unsafe{boot::hang_led()};
 }

rpi/src/drivers/disk.rs

@@ -57,21 +57,33 @@ impl Disk{
     /// Returns the number of blocks the read operation fetched
     /// The user knows how much of the buffer is filled
     pub fn read(&mut self, block_index:u32, buffer:&mut [u8]) -> u32 {
-        let block_size = self.emmc.get_block_size();
-        let buffer_size = buffer.len();
-        if buffer_size  % block_size as usize != 0{
-            core::panic!("buffer size must be a division of block size: {}", block_size);
-        }
-        self.emmc.seek((block_index * block_size) as u64);
+        self.prepare_for_disk_operation(block_index, buffer);
         if !self.emmc.read(buffer){
-            core::panic!("Error while reading object of size: {}", buffer_size);
+            core::panic!("Error while reading object of size: {}", buffer.len());
+        }
+        return  buffer.len() as u32 / self.get_block_size();
+    }
+
+    /// Returns the number of blocks the write operation modified
+    pub fn write(&mut self, block_index:u32, buffer:&mut [u8])->u32{
+        self.prepare_for_disk_operation(block_index, buffer);
+        if !self.emmc.write(buffer){
+            core::panic!("Error while writing object of size: {}", buffer.len());
         }
-        return  buffer_size as u32 / block_size;
+        return buffer.len() as u32 / self.get_block_size();
     }
 
     pub fn get_partition_first_sector_index(&self, partition_index:u8)->u32{
         self.mbr.partitions[partition_index as usize].first_sector_index
     }
 
     pub fn get_block_size(&self)->u32{self.emmc.get_block_size()}
+
+    fn prepare_for_disk_operation(&mut self, block_index:u32, buffer:&[u8]){
+        let block_size = self.get_block_size();
+        if buffer.len() % block_size as usize != 0{
+            core::panic!("buffer size must be a division of block size: {}, actual buffer_size: {}", block_size, buffer.len());
+        }
+        self.emmc.seek((block_index * block_size) as u64);
+    }
 }