fatfs working

src/Cargo.lock

@@ -93,6 +93,18 @@ dependencies = [
  "void",
 ]
 
+[[package]]
+name = "fatfs"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6d1df9e4503954f60504a5ee4fc435cd65cc42e98b2081f7f421be5f2e68e7d"
+dependencies = [
+ "bitflags",
+ "byteorder",
+ "core_io",
+ "log",
+]
+
 [[package]]
 name = "futures"
 version = "0.3.5"
@@ -353,6 +365,7 @@ dependencies = [
  "core_io",
  "cslice",
  "dyld",
+ "fatfs",
  "futures",
  "libasync",
  "libboard_zynq",

src/runtime/Cargo.toml

@@ -14,7 +14,7 @@ num-traits = { version = "0.2", default-features = false }
 num-derive = "0.3"
 cslice = "0.3"
 log = "0.4"
-core_io = { version = "0.1", features = ["alloc", "collections"] }
+core_io = { version = "0.1", features = ["collections"] }
 byteorder = { version = "1.3", default-features = false }
 void = { version = "1", default-features = false }
 futures = { version = "0.3", default-features = false, features = ["async-await"] }
@@ -24,3 +24,4 @@ libsupport_zynq = { git = "https://git.m-labs.hk/M-Labs/zc706.git" }
 libcortex_a9 = { git = "https://git.m-labs.hk/M-Labs/zc706.git" }
 libasync = { git = "https://git.m-labs.hk/M-Labs/zc706.git" }
 dyld = { path = "../libdyld" }
+fatfs = { version = "0.3.3", features = ["core_io"], default-features = false }

src/runtime/src/main.rs

@@ -12,6 +12,8 @@ use libsupport_zynq::ram;
 
 use core_io::{Seek, Read, Write, SeekFrom};
 
+use fatfs;
+
 mod proto_core_io;
 mod proto_async;
 // mod comms;
@@ -43,8 +45,10 @@ pub fn main_core0() {
     log::set_max_level(log::LevelFilter::Debug);
     info!("NAR3/Zynq7000 starting...");
 
+    info!("Init alloc linker");
+    ram::init_alloc_linker();
     // let mut ddr_ram = ddr::DdrRam::new();
-    // ram::init_alloc_linker();
+    // info!("Init alloc ddr");
     // ram::init_alloc_ddr(&mut ddr_ram);
 
     let mut sdio0 = sdio::SDIO::sdio0(true);
@@ -52,21 +56,32 @@ pub fn main_core0() {
         info!("Card inserted. Getting SD Card data.");
         let mut sd = sdio::sd_card::SdCard::from_sdio(sdio0).unwrap();
         let mut reader = sd_reader::SdReader::new(&mut sd);
-        // let mut buffer: alloc::vec::Vec<u8> = alloc::vec::Vec::with_capacity(128);
-        // unsafe {
-        //     buffer.set_len(128);
-        // }
-        let mut buffer: [u8; 1000] = [0; 1000];
-        for i in 0..buffer.len() {
-            buffer[i] = (i % 64) as u8;
+
+        let mut lba_buffer: [u8; 4] = [0; 4];
+        reader.seek(SeekFrom::Start(0x1BE + 0x8));
+        reader.read(&mut lba_buffer).unwrap();
+        // read MBR and get first partition LBA, hopefully it is FAT32
+        let mut lba: u32 = 0;
+        for i in 0..4 {
+            lba |= (lba_buffer[i] as u32) << (i * 8);
         }
-        // just trying randomly access some portion of the memory...
-        reader.write(&buffer[0..800]).unwrap();
-        reader.seek(SeekFrom::Start(30)).unwrap();
-        reader.read(&mut buffer).unwrap();
-        for i in 0..buffer.len() {
-            info!("buffer[{}] = {:0X}", i, buffer[i]);
+        info!("LBA = 0x{:0X}", lba);
+        reader.seek(SeekFrom::Start(0)).unwrap();
+        reader.set_base_offset(lba * 0x200);
+
+        let fs = fatfs::FileSystem::new(reader, fatfs::FsOptions::new()).unwrap();
+        let root_dir = fs.root_dir();
+        for entry in root_dir.iter() {
+            if let Ok(entry) = entry {
+                let bytes = entry.short_file_name_as_bytes();
+                info!("");
+                for b in bytes {
+                    info!("{}", *b as char);
+                }
+                // info!("- {}", entry.short_file_name_as_bytes());
+            }
         }
+
     } else {
         info!("Card not inserted")
     }

src/runtime/src/sd_reader.rs

@@ -22,6 +22,8 @@ pub struct SdReader<'a> {
     index: usize,
     /// Dirty flag indicating the content has to be flushed.
     dirty: bool,
+    /// Base offset for upcoming read/writes
+    offset: u32,
 }
 
 impl<'a> SdReader<'a> {
@@ -32,6 +34,7 @@ impl<'a> SdReader<'a> {
             byte_addr: 0,
             index: BLOCK_SIZE,
             dirty: false,
+            offset: 0,
         }
     }
 
@@ -95,6 +98,12 @@ impl<'a> SdReader<'a> {
     fn invalidate_buffer(&mut self) {
         self.index = BLOCK_SIZE;
     }
+
+    pub fn set_base_offset(&mut self, offset: u32) {
+        self.offset = offset;
+        self.byte_addr += offset;
+        self.invalidate_buffer();
+    }
 }
 
 impl<'a> Read for SdReader<'a> {
@@ -150,11 +159,13 @@ impl<'a> Write for SdReader<'a> {
         self.write_unaligned(a)?;
         if b.len() > 0 {
             self.invalidate_buffer();
-            self.sd.write_block(
-                self.byte_addr / BLOCK_SIZE as u32,
-                (b.len() / BLOCK_SIZE) as u16,
-                b,
-            ).map_err(cmd_error_to_io_error)?;
+            self.sd
+                .write_block(
+                    self.byte_addr / BLOCK_SIZE as u32,
+                    (b.len() / BLOCK_SIZE) as u16,
+                    b,
+                )
+                .map_err(cmd_error_to_io_error)?;
         }
         self.write_unaligned(c)?;
         Ok(buf.len())
@@ -178,12 +189,13 @@ impl<'a> Seek for SdReader<'a> {
             SeekFrom::Start(x) => x as i64,
             SeekFrom::Current(x) => self.byte_addr as i64 + x,
             SeekFrom::End(_) => panic!("SD card does not support seek from end"),
-        };
+        } + self.offset as i64;
         if raw_target < 0 || raw_target > core::u32::MAX as i64 {
             return Err(Error::new(ErrorKind::InvalidInput, "Invalid address"));
         }
         let target_byte_addr = raw_target as u32;
-        let address_same_block = self.byte_addr / (BLOCK_SIZE as u32) == target_byte_addr / (BLOCK_SIZE as u32);
+        let address_same_block =
+            self.byte_addr / (BLOCK_SIZE as u32) == target_byte_addr / (BLOCK_SIZE as u32);
         // if the buffer was invalidated, we consider seek as different block
         let same_block = address_same_block && self.index != BLOCK_SIZE;
         if !same_block {