add flash caching for msc spiflash example

Author: hathach

examples/MassStorage/msc_spiflash/msc_spiflash.ino

@@ -29,6 +29,7 @@ Adafruit_SPIFlash flash(FLASH_SS, &FLASH_SPI_PORT);     // Use hardware SPI
 
 Adafruit_USBD_MSC usb_msc;
 
+
 // the setup function runs once when you press reset or power the board
 void setup()
 {
@@ -67,7 +68,8 @@ void loop()
 int32_t msc_read_cb (uint32_t lba, void* buffer, uint32_t bufsize)
 {
   const uint32_t addr = lba*512;
-  return flash.readBuffer(addr, (uint8_t*) buffer, bufsize);
+  flash_cache_read((uint8_t*) buffer, addr, bufsize);
+  return bufsize;
 }
 
 // Callback invoked when received WRITE10 command.
@@ -77,12 +79,116 @@ int32_t msc_write_cb (uint32_t lba, uint8_t* buffer, uint32_t bufsize)
 {
   // need to erase & caching write back
   const uint32_t addr = lba*512;
-  return flash.writeBuffer(addr, buffer, bufsize);
+  flash_cache_write(addr, buffer, bufsize);
+  return bufsize;
 }
 
 // Callback invoked when WRITE10 command is completed (status received and accepted by host).
 // used to flush any pending cache.
 void msc_flush_cb (void)
 {
-  // nothing to do
+  flash_cache_flush();
+}
+
+//--------------------------------------------------------------------+
+// Flash Caching
+//--------------------------------------------------------------------+
+#define FLASH_CACHE_SIZE          4096        // must be a erasable page size
+#define FLASH_CACHE_INVALID_ADDR  0xffffffff
+
+uint32_t cache_addr = FLASH_CACHE_INVALID_ADDR;
+uint8_t  cache_buf[FLASH_CACHE_SIZE];
+
+static inline uint32_t page_addr_of (uint32_t addr)
+{
+  return addr & ~(FLASH_CACHE_SIZE - 1);
+}
+
+static inline uint32_t page_offset_of (uint32_t addr)
+{
+  return addr & (FLASH_CACHE_SIZE - 1);
+}
+
+void flash_cache_flush (void)
+{
+  if ( cache_addr == FLASH_CACHE_INVALID_ADDR ) return;
+
+  // indicator
+//  ledOn(LED_BUILTIN);
+
+  flash.eraseSector(cache_addr/FLASH_CACHE_SIZE);
+  flash.writeBuffer(cache_addr, cache_buf, FLASH_CACHE_SIZE);
+
+//  ledOff(LED_BUILTIN);
+
+  cache_addr = FLASH_CACHE_INVALID_ADDR;
+}
+
+uint32_t flash_cache_write (uint32_t dst, void const * src, uint32_t len)
+{
+  uint8_t const * src8 = (uint8_t const *) src;
+  uint32_t remain = len;
+
+  // Program up to page boundary each loop
+  while ( remain )
+  {
+    uint32_t const page_addr = page_addr_of(dst);
+    uint32_t const offset = page_offset_of(dst);
+
+    uint32_t wr_bytes = FLASH_CACHE_SIZE - offset;
+    wr_bytes = min(remain, wr_bytes);
+
+    // Page changes, flush old and update new cache
+    if ( page_addr != cache_addr )
+    {
+      flash_cache_flush();
+      cache_addr = page_addr;
+
+      // read a whole page from flash
+      flash.readBuffer(page_addr, cache_buf, FLASH_CACHE_SIZE);
+    }
+
+    memcpy(cache_buf + offset, src8, wr_bytes);
+
+    // adjust for next run
+    src8 += wr_bytes;
+    remain -= wr_bytes;
+    dst += wr_bytes;
+  }
+
+  return len - remain;
+}
+
+void flash_cache_read (uint8_t* dst, uint32_t addr, uint32_t count)
+{
+  // overwrite with cache value if available
+  if ( (cache_addr != FLASH_CACHE_INVALID_ADDR) &&
+       !(addr < cache_addr && addr + count <= cache_addr) &&
+       !(addr >= cache_addr + FLASH_CACHE_SIZE) )
+  {
+    int dst_off = cache_addr - addr;
+    int src_off = 0;
+
+    if ( dst_off < 0 )
+    {
+      src_off = -dst_off;
+      dst_off = 0;
+    }
+
+    int cache_bytes = min(FLASH_CACHE_SIZE-src_off, count - dst_off);
+
+    // start to cached
+    if ( dst_off ) flash.readBuffer(addr, dst, dst_off);
+
+    // cached
+    memcpy(dst + dst_off, cache_buf + src_off, cache_bytes);
+
+    // cached to end
+    int copied = dst_off + cache_bytes;
+    if ( copied < count ) flash.readBuffer(addr + copied, dst + copied, count - copied);
+  }
+  else
+  {
+    flash.readBuffer(addr, dst, count);
+  }
 }