fat fs no longer in RAM. mkfs as part of build process. page cache to still be able to write from usb or app.

CMakeLists.txt

@@ -114,6 +114,7 @@ target_sources(gadget PUBLIC
     src/state_wifi_edit.c
     src/state_string.c
     src/http.c
+    src/cache.c
 
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ff.c
     ${CMAKE_CURRENT_BINARY_DIR}/fatfs/ffunicode.c
@@ -142,9 +143,9 @@ target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_LIST_DIR}/build)
 target_include_directories(gadget PUBLIC ${CMAKE_CURRENT_BINARY_DIR})
 
 # compress source code and stuff we want to include
-add_custom_target(pack bash -c "./pack_data.sh"
+add_custom_target(pack bash -c "./pack_data.sh ${CMAKE_CURRENT_BINARY_DIR}"
     WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    BYPRODUCTS "build/pack_data.h"
+    BYPRODUCTS "${CMAKE_CURRENT_BINARY_DIR}/fat_fs.o"
 )
 add_dependencies(gadget pack)
 
@@ -163,9 +164,6 @@ set_source_files_properties(pico-sdk/lib/btstack/src/classic/avdtp_util.c PROPER
 set_source_files_properties(pico-sdk/lib/btstack/src/classic/goep_client.c PROPERTIES COMPILE_FLAGS -Wno-unused-parameter)
 set_source_files_properties(pico-sdk/lib/btstack/src/classic/goep_server.c PROPERTIES COMPILE_FLAGS -Wno-unused-parameter)
 
-# suppress warnings for BittyHTTP
-set_source_files_properties(BittyHTTP/src/WebServer.c PROPERTIES COMPILE_FLAGS "-Wno-sign-compare -Wno-unused-parameter -Wno-maybe-uninitialized")
-
 # pull in common dependencies
 target_link_libraries(gadget
     pico_stdlib

conf/ffconf.h

@@ -30,7 +30,7 @@
 /  f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */
 
 
-#define FF_USE_MKFS		1
+#define FF_USE_MKFS		0
 /* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
 
 

conf/memmap_custom.ld

@@ -3,12 +3,21 @@
  * https://community.element14.com/products/raspberry-pi/b/blog/posts/raspberry-pico-c-sdk-reserve-a-flash-memory-block-for-persistent-storage
  */
 
-/* TODO hard-coded. Should take into account PICO_FLASH_BANK_STORAGE_OFFSET */
+INPUT (./fat_fs.o)
+
+/*
+ * TODO hard-coded.
+ * Should take into account PICO_FLASH_BANK_STORAGE_OFFSET
+ * and DISK_BLOCK_SIZE and DISK_BLOCK_COUNT from config.h
+ */
 __PERSISTENT_STORAGE_LEN = (3 * 4k);
+__FLASH_CACHE_LEN = (48 * 4k);
+__ADDITIONAL_LEN = (__PERSISTENT_STORAGE_LEN + __FLASH_CACHE_LEN);
 
 MEMORY
 {
-    FLASH(rx) : ORIGIN = 0x10000000, LENGTH = 2048k - __PERSISTENT_STORAGE_LEN
+    FLASH(rx) : ORIGIN = 0x10000000, LENGTH = 2048k - __ADDITIONAL_LEN
+    FLASH_CACHE(r) : ORIGIN = 0x10000000 + (2048k - __ADDITIONAL_LEN) , LENGTH = __FLASH_CACHE_LEN
     FLASH_PERSISTENT(r) : ORIGIN = 0x10000000 + (2048k - __PERSISTENT_STORAGE_LEN) , LENGTH = __PERSISTENT_STORAGE_LEN
     RAM(rwx) : ORIGIN =  0x20000000, LENGTH = 256k
     SCRATCH_X(rwx) : ORIGIN = 0x20040000, LENGTH = 4k
@@ -216,6 +225,10 @@ SECTIONS
         KEEP(*(.stack*))
     } > SCRATCH_Y
 
+    .fat_fs_bin : {
+        KEEP(./fat_fs.o (.fat_fs_bin))
+    } > FLASH_CACHE
+
     .flash_end : {
         PROVIDE(__flash_binary_end = .);
     } > FLASH

data/README.md

@@ -0,0 +1,6 @@
+# Volcano Remote Control Gadget
+
+Project by Thomas Buck <thomas@xythobuz.de>
+Licensed under GPLv3.
+See included 'src.tar.xz' for sources.
+Repo at https://git.xythobuz.de/thomas/sb-py

include/fat_disk.h → include/cache.h

@@ -1,7 +1,7 @@
-/* 
- * fat_disk.h
+/*
+ * cache.h
  *
- * Copyright (c) 2022 - 2023 Thomas Buck (thomas@xythobuz.de)
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -16,6 +16,17 @@
  * See <http://www.gnu.org/licenses/>.
  */
 
-void fat_disk_init(void);
+#ifndef __CACHE_H__
+#define __CACHE_H__
 
-uint8_t *fat_disk_get_sector(uint32_t sector);
+#include <sys/types.h>
+
+void cache_init(void);
+void cache_status(void);
+void cache_sync(void);
+void cache_run(void);
+
+ssize_t cache_read(uint8_t *buf, size_t addr, size_t len);
+ssize_t cache_write(const uint8_t *buf, size_t addr, size_t len);
+
+#endif // __CACHE_H__

include/config.h

@@ -34,10 +34,10 @@
 // Release build
 #define AUTO_MOUNT_MASS_STORAGE
 #define AUTO_LOG_ON_MASS_STORAGE
-#define DEBUG_DISK_WRITE_SOURCES
 #endif // NDEBUG
 
 #define WATCHDOG_PERIOD_MS 1000
+#define FLASH_LOCK_TIMEOUT_MS 500
 
 // ASCII 0x18 = CAN (cancel)
 #define ENTER_BOOTLOADER_MAGIC 0x18
@@ -47,15 +47,9 @@
 
 #define SERIAL_WRITES_BLOCK_WHEN_BUFFER_FULL
 
+// TODO needs to be the same as in pack_data.sh
 #define DISK_BLOCK_SIZE 512
-
-#ifdef DEBUG_DISK_WRITE_SOURCES
-#define DISK_ADD_BLOCKS_SOURCES 90 //128
-#else // DEBUG_DISK_WRITE_SOURCES
-#define DISK_ADD_BLOCKS_SOURCES 0
-#endif // DEBUG_DISK_WRITE_SOURCES
-
-#define DISK_BLOCK_COUNT (256 + DISK_ADD_BLOCKS_SOURCES)
+#define DISK_BLOCK_COUNT (256 + 128) // 384 * 512 = 196608
 
 //#define TEST_VOLCANO_AUTO_CONNECT "xx:xx:xx:xx:xx:xx 1"
 //#define TEST_CRAFTY_AUTO_CONNECT "xx:xx:xx:xx:xx:xx 0"

include/debug_disk.h

@@ -19,9 +19,9 @@
 #ifndef __DEBUG_DISK_H__
 #define __DEBUG_DISK_H__
 
-void debug_disk_init(void);
-
 int debug_disk_mount(void);
 int debug_disk_unmount(void);
 
+void debug_disk_init_log(void);
+
 #endif // __DEBUG_DISK_H__

include/mem.h

@@ -19,12 +19,22 @@
 #ifndef __MEM_H__
 #define __MEM_H__
 
+#include "hardware/flash.h"
+#include "pico/btstack_flash_bank.h"
+
 #include <stdint.h>
 #include <stdbool.h>
 
 #include "workflow.h"
 #include "wifi.h"
 
+/*
+ * Last two flash pages are used by BTstack.
+ * So we use the third-last page for our persistent storage.
+ * This is kept clear by our custom linker script.
+ */
+#define EEPROM_FLASH_OFFSET (PICO_FLASH_BANK_STORAGE_OFFSET - FLASH_SECTOR_SIZE)
+
 // to migrate settings when struct changes between releases
 #define MEM_VERSION 0
 

pack_data.sh

@@ -18,23 +18,40 @@
 
 set -euo pipefail
 
+# TODO take from config.h
+DISK_BLOCK_SIZE=512
+DISK_BLOCK_COUNT=384
+
 cd "$(dirname "$0")"
 echo "Packing data"
 
-rm -rf build/src
-mkdir -p build/src
-cp COPYING build/src
-cp README.md build/src
-cp CMakeLists.txt build/src
-cp .gitmodules build/src/gitmodules
-cp -r include build/src
-cp -r conf build/src
-cp -r src build/src
-
-cd build
+rm -rf $1/src
+mkdir -p $1/src
+cp COPYING $1/src
+cp README.md $1/src
+cp CMakeLists.txt $1/src
+cp .gitmodules $1/src/gitmodules
+cp -r include $1/src
+cp -r conf $1/src
+cp -r src $1/src
+
+echo "Compressing data"
+cd $1
 rm -rf data.tar data.tar.xz
 tar -f data.tar -c src
 xz -z -9 data.tar
 
-xxd -i data.tar.xz > pack_data.h
-sed -i 's/unsigned/static const unsigned/g' pack_data.h
+echo "Creating empty bin"
+dd if=/dev/zero of=fat_fs.bin bs=$DISK_BLOCK_SIZE count=$DISK_BLOCK_COUNT
+
+echo "Writing FAT file system"
+mkfs.vfat fat_fs.bin
+
+echo "Copying source code archive"
+mcopy -i fat_fs.bin ../data/README.md ::README.md
+mcopy -i fat_fs.bin data.tar.xz ::src.tar.xz
+
+echo "Converting to object file"
+arm-none-eabi-objcopy -I binary -O elf32-littlearm \
+    --rename-section .data=.fat_fs_bin,CONTENTS,ALLOC,LOAD,READONLY,DATA \
+    fat_fs.bin fat_fs.o

picowota

@@ -1 +1 @@
-Subproject commit 682ce01a0ea6ae9d702d404e3e24894f904c277d
+Subproject commit 9e9371e28b635a15d702c2f117a27831c8ce683e

src/cache.c

@@ -0,0 +1,308 @@
+/*
+ * cache.c
+ *
+ * Copyright (c) 2023 Thomas Buck (thomas@xythobuz.de)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * See <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdbool.h>
+#include <string.h>
+
+#include "pico/flash.h"
+
+#include "config.h"
+#include "log.h"
+#include "mem.h"
+#include "cache.h"
+
+#define CACHE_MAX_AGE_MS (5 * 1000)
+
+#define PAGE_SIZE FLASH_SECTOR_SIZE // 4K
+#define CACHE_ENTRIES 10 // 40K in RAM
+
+// 384 * 512 = 196608 bytes = 48 Pages (Sectors) in Flash
+#define DISK_SIZE (DISK_BLOCK_SIZE * DISK_BLOCK_COUNT)
+#define DISK_PAGES (DISK_SIZE / PAGE_SIZE)
+
+static_assert((DISK_SIZE % PAGE_SIZE) == 0, "Disk blocks need to fit cleanly into flash pages.");
+
+// PICO_FLASH_SIZE_BYTES is 2MB = 512 * 4K pages
+// BTstack uses the last two pages, we use one more for EEPROM config.
+// So 509 pages remain, minus the 48 pages for the FAT disk.
+// --> 461 pages remain for bootloader and application.
+// --> 461 * 4096 = 1888256 bytes
+#define CACHE_FLASH_OFFSET (EEPROM_FLASH_OFFSET - (DISK_PAGES * PAGE_SIZE))
+static_assert(DISK_PAGES == 48, "TODO conversions are hard-coded currently");
+
+struct cache_entry {
+    bool set;
+    size_t page;
+    bool dirty;
+    uint32_t age;
+    uint8_t buff[PAGE_SIZE];
+};
+
+static struct cache_entry cache[CACHE_ENTRIES] = {0};
+static const uint8_t *disk = (const uint8_t *)(XIP_BASE + CACHE_FLASH_OFFSET);
+
+void cache_init(void) {
+    for (size_t i = 0; i < CACHE_ENTRIES; i++) {
+        cache[i].set = false;
+    }
+}
+
+void cache_status(void) {
+    size_t count = 0;
+
+    for (size_t i = 0; i < CACHE_ENTRIES; i++) {
+        if (!cache[i].set) {
+            continue;
+        }
+
+        println("Cache Entry %d:", count);
+        println("  Page: %d", cache[i].page);
+        println("  Dirty: %s", cache[i].dirty ? "Yes" : "No");
+
+        uint32_t now = to_ms_since_boot(get_absolute_time());
+        println("  Age: %.1fs", (now - cache[i].age) / 1000.0f);
+
+        count++;
+    }
+
+    println("Total entries: %d", count);
+}
+
+struct cache_write_data {
+    uint32_t addr;
+    uint8_t *buff;
+};
+
+static void cache_write_flash(void *param) {
+    struct cache_write_data *tmp = param;
+    flash_range_erase(tmp->addr, PAGE_SIZE);
+    flash_range_program(tmp->addr, tmp->buff, PAGE_SIZE);
+}
+
+static void cache_flush(size_t i) {
+    // after this the cache entry is gone
+    cache[i].set = false;
+
+    // if it is not actually modified, we can bail out here
+    if (!cache[i].dirty) {
+        return;
+    }
+
+    // now actually write contents back to flash
+    uint32_t addr = CACHE_FLASH_OFFSET + (cache[i].page * PAGE_SIZE);
+    debug("flushing entry %d page %d at 0x%08lX", i, cache[i].page, addr);
+
+    struct cache_write_data tmp = { .addr = addr, .buff = cache[i].buff };
+    int r = flash_safe_execute(cache_write_flash, &tmp, FLASH_LOCK_TIMEOUT_MS);
+    if (r != PICO_OK) {
+        debug("error calling cache_write_flash: %d", r);
+    }
+}
+
+void cache_sync(void) {
+    for (size_t i = 0; i < CACHE_ENTRIES; i++) {
+        if (!cache[i].set) {
+            continue;
+        }
+
+        // just flush out all available entries
+        cache_flush(i);
+    }
+}
+
+void cache_run(void) {
+    for (size_t i = 0; i < CACHE_ENTRIES; i++) {
+        if (!cache[i].set) {
+            continue;
+        }
+
+        // only flush out entries that are too old
+        uint32_t now = to_ms_since_boot(get_absolute_time());
+        if ((now - cache[i].age) >= CACHE_MAX_AGE_MS) {
+            cache_flush(i);
+        }
+    }
+}
+
+static ssize_t cache_read_single(uint8_t *buf, size_t page, size_t off, size_t len) {
+    if (page >= DISK_PAGES) {
+        debug("error: invalid page %d", page);
+        return -1;
+    }
+
+    if ((off + len) > PAGE_SIZE) {
+        debug("error: too long %d %d", off, len);
+        return -1;
+    }
+
+    // is it in the cache?
+    for (size_t i = 0; i < CACHE_ENTRIES; i++) {
+        if (!cache[i].set) {
+            continue;
+        }
+
+        if (cache[i].page != page) {
+            continue;
+        }
+
+        // it is in the cache!
+        memcpy(buf, cache[i].buff + off, len);
+        return len;
+    }
+
+    // not in cache, read directly from flash
+    memcpy(buf, disk + (page * PAGE_SIZE) + off, len);
+    return len;
+}
+
+static ssize_t write_into_cache(size_t idx, const uint8_t *buf, size_t off, size_t len) {
+    bool changed = false;
+    for (size_t i = 0; i < len; i++) {
+        if (cache[idx].buff[off + i] != buf[i]) {
+            changed = true;
+        }
+
+        cache[idx].buff[off + i] = buf[i];
+    }
+
+    if (changed) {
+        cache[idx].dirty = true;
+        cache[idx].age = to_ms_since_boot(get_absolute_time());
+    }
+
+    return len;
+}
+
+static ssize_t cache_write_single(const uint8_t *buf, size_t page, size_t off, size_t len) {
+    if (page >= DISK_PAGES) {
+        debug("error: invalid page %d", page);
+        return -1;
+    }
+
+    if ((off + len) > PAGE_SIZE) {
+        debug("error: too long %d %d", off, len);
+        return -1;
+    }
+
+    // is it in the cache?
+    for (size_t i = 0; i < CACHE_ENTRIES; i++) {
+        if (!cache[i].set) {
+            continue;
+        }
+
+        if (cache[i].page != page) {
+            continue;
+        }
+
+        // it is in the cache!
+        return write_into_cache(i, buf, off, len);
+    }
+
+    // not in cache yet, find free cache entry
+    ssize_t free = -1, oldest = -1;
+    uint32_t min_age = 0xFFFFFFFF;
+    for (size_t i = 0; i < CACHE_ENTRIES; i++) {
+        if (!cache[i].set) {
+            if (free < 0) {
+                free = i;
+            }
+        }
+
+        if (cache[i].age < min_age) {
+            min_age = cache[i].age;
+            oldest = i;
+        }
+    }
+
+    if (free < 0) {
+        // flush oldest current entry and use its place
+        if (oldest < 0) {
+            debug("error, no oldest entry?!");
+            return -1;
+        }
+
+        cache_flush(oldest);
+        free = oldest;
+    }
+
+    // populate new cache entry
+    cache[free].set = true;
+    cache[free].page = page;
+    cache[free].dirty = false;
+    cache[free].age = to_ms_since_boot(get_absolute_time());
+    memcpy(cache[free].buff, disk + (page * PAGE_SIZE), PAGE_SIZE);
+
+    debug("add cache %d for page %d", free, page);
+
+    // perform write operation into cache entry
+    return write_into_cache(free, buf, off, len);
+}
+
+ssize_t cache_read(uint8_t *buf, size_t addr, size_t len) {
+    size_t page = addr / PAGE_SIZE;
+    size_t off = addr % PAGE_SIZE;
+    size_t count = 0;
+
+    while ((off + len) > PAGE_SIZE) {
+        debug("split cache page read");
+
+        size_t chunk = PAGE_SIZE - off;
+        ssize_t r = cache_read_single(buf + count, page, off, chunk);
+        if (r < 0) {
+            return r;
+        }
+        count += r;
+        len -= r;
+        off = 0;
+        page++;
+    }
+
+    ssize_t r = cache_read_single(buf + count, page, off, len);
+    if (r < 0) {
+        return r;
+    }
+    count += r;
+    return count;
+}
+
+ssize_t cache_write(const uint8_t *buf, size_t addr, size_t len) {
+    size_t page = addr / PAGE_SIZE;
+    size_t off = addr % PAGE_SIZE;
+    size_t count = 0;
+
+    while ((off + len) > PAGE_SIZE) {
+        debug("split cache page write");
+
+        size_t chunk = PAGE_SIZE - off;
+        ssize_t r = cache_write_single(buf + count, page, off, chunk);
+        if (r < 0) {
+            return r;
+        }
+        count += r;
+        len -= r;
+        off = 0;
+        page++;
+    }
+
+    ssize_t r = cache_write_single(buf + count, page, off, len);
+    if (r < 0) {
+        return r;
+    }
+    count += r;
+    return count;
+}

src/console.c

@@ -42,6 +42,7 @@
 #include "workflow.h"
 #include "crafty.h"
 #include "mem.h"
+#include "cache.h"
 #include "console.h"
 
 #define CNSL_BUFF_SIZE 64
@@ -103,6 +104,8 @@ static void cnsl_interpret(const char *line) {
         println("  power - show Lipo battery status");
         println("   memr - reset flash memory config");
         println("     bl - print backlight pwm level");
+        println("  cache - print flash cache status");
+        println("  flush - flush flash cache");
         println("");
         println("   scan - start or stop BLE scan");
         println("scanres - print list of found BLE devices");
@@ -158,6 +161,10 @@ static void cnsl_interpret(const char *line) {
         mem_write();
     } else if (strcmp(line, "bl") == 0) {
         println("bl: 0x%04X", mem_data()->backlight);
+    } else if (strcmp(line, "cache") == 0) {
+        cache_status();
+    } else if (strcmp(line, "flush") == 0) {
+        cache_sync();
     } else if (strcmp(line, "scan") == 0) {
         ble_scan(BLE_SCAN_TOGGLE);
     } else if (strcmp(line, "scanres") == 0) {

src/debug_disk.c

@@ -26,87 +26,16 @@
 #include "log.h"
 #include "debug_disk.h"
 
-#ifdef DEBUG_DISK_WRITE_SOURCES
-#include "pack_data.h"
-#endif // DEBUG_DISK_WRITE_SOURCES
-
 static FATFS fs;
 static bool mounted = false;
 
-static void write_readme(void) {
-    FIL file;
-    FRESULT res = f_open(&file, "README.md", FA_CREATE_ALWAYS | FA_WRITE);
-    if (res != FR_OK) {
-        debug("error: f_open returned %d", res);
-    } else {
-        char readme[1024];
-        size_t pos = 0;
-        pos += snprintf(readme + pos, 1024 - pos, "# Volcano Remote Control Gadget\r\n");
-        pos += snprintf(readme + pos, 1024 - pos, "\r\n");
-        pos += snprintf(readme + pos, 1024 - pos, "Project by Thomas Buck <thomas@xythobuz.de>\r\n");
-        pos += snprintf(readme + pos, 1024 - pos, "Licensed under GPLv3.\r\n");
-        pos += snprintf(readme + pos, 1024 - pos, "See included 'src.tar.xz' for sources.\r\n");
-        pos += snprintf(readme + pos, 1024 - pos, "Repo at https://git.xythobuz.de/thomas/sb-py\r\n");
-
-        size_t len = strlen(readme);
-        UINT bw;
-        res = f_write(&file, readme, len, &bw);
-        if ((res != FR_OK) || (bw != len)) {
-            debug("error: f_write returned %d", res);
-        }
-
-        res = f_close(&file);
-        if (res != FR_OK) {
-            debug("error: f_close returned %d", res);
-        }
-    }
-}
-
-#ifdef DEBUG_DISK_WRITE_SOURCES
-static void write_sources(void) {
-    FIL file;
-    FRESULT res = f_open(&file, "src.tar.xz", FA_CREATE_ALWAYS | FA_WRITE);
-    if (res != FR_OK) {
-        debug("error: f_open returned %d", res);
-    } else {
-        UINT bw;
-        UINT len = 0;
-        while (1) {
-            res = f_write(&file, data_tar_xz + len, data_tar_xz_len - len, &bw);
-            len += bw;
-            if (res != FR_OK) {
-                debug("error: f_write returned %d", res);
-                break;
-            } else if (bw == 0) {
-                debug("error: f_write did not write");
-                break;
-            } else if (bw == data_tar_xz_len) {
-                break;
-            }
-        }
-
-        res = f_close(&file);
-        if (res != FR_OK) {
-            debug("error: f_close returned %d", res);
-        }
-    }
-}
-#endif // DEBUG_DISK_WRITE_SOURCES
-
-void debug_disk_init(void) {
+void debug_disk_init_log(void) {
     if (debug_disk_mount() != 0) {
         debug("error mounting disk");
         return;
     }
 
-    // maximum length: 11 bytes
-    f_setlabel("Volcano RC");
-
-    write_readme();
-
-#ifdef DEBUG_DISK_WRITE_SOURCES
-    write_sources();
-#endif // DEBUG_DISK_WRITE_SOURCES
+    log_dump_to_disk();
 
     if (debug_disk_unmount() != 0) {
         debug("error unmounting disk");

src/fat_disk.c

@@ -24,23 +24,9 @@
 #include "diskio.h"
 
 #include "config.h"
+#include "cache.h"
 #include "log.h"
 #include "debug_disk.h"
-#include "fat_disk.h"
-
-static uint8_t disk[DISK_BLOCK_COUNT * DISK_BLOCK_SIZE];
-
-void fat_disk_init(void) {
-    BYTE work[FF_MAX_SS];
-    FRESULT res = f_mkfs("", 0, work, sizeof(work));
-    if (res != FR_OK) {
-        debug("error: f_mkfs returned %d", res);
-    }
-}
-
-uint8_t *fat_disk_get_sector(uint32_t sector) {
-    return disk + (sector * DISK_BLOCK_SIZE);
-}
 
 /*
  * FatFS ffsystem.c
@@ -87,8 +73,8 @@ DRESULT disk_read(BYTE pdrv, BYTE *buff, LBA_t sector, UINT count) {
         return RES_ERROR;
     }
 
-    memcpy(buff, disk + (sector * DISK_BLOCK_SIZE), count * DISK_BLOCK_SIZE);
-    return RES_OK;
+    ssize_t r = cache_read(buff, sector * DISK_BLOCK_SIZE, count * DISK_BLOCK_SIZE);
+    return (r == (ssize_t)(count * DISK_BLOCK_SIZE)) ? RES_OK : RES_ERROR;
 }
 
 DRESULT disk_write(BYTE pdrv, const BYTE *buff, LBA_t sector, UINT count) {
@@ -102,8 +88,8 @@ DRESULT disk_write(BYTE pdrv, const BYTE *buff, LBA_t sector, UINT count) {
         return RES_ERROR;
     }
 
-    memcpy(disk + (sector * DISK_BLOCK_SIZE), buff, count * DISK_BLOCK_SIZE);
-    return RES_OK;
+    ssize_t r = cache_write(buff, sector * DISK_BLOCK_SIZE, count * DISK_BLOCK_SIZE);
+    return (r == (ssize_t)(count * DISK_BLOCK_SIZE)) ? RES_OK : RES_ERROR;
 }
 
 DRESULT disk_ioctl(BYTE pdrv, BYTE cmd, void *buff) {

src/http.c

@@ -26,25 +26,26 @@
 #include "log.h"
 #include "http.h"
 
-
 void http_init(void) {
     httpd_init();
 }
 
-#ifdef DEBUG_DISK_WRITE_SOURCES
-
 #include "lwip/apps/fs.h"
 #include <string.h>
-#include "pack_data.h"
 
 int fs_open_custom(struct fs_file *file, const char *name) {
+    // TODO hook up to fat fs
     if (strcmp(name, "/src.tar.xz") == 0) {
+        /*
         memset(file, 0, sizeof(struct fs_file));
         file->data = (const char *)data_tar_xz;
         file->len = data_tar_xz_len;
         file->index = file->len;
         file->flags = FS_FILE_FLAGS_HEADER_PERSISTENT;
         return 1;
+        */
+        (void)file;
+        return 0;
     }
     return 0;
 }
@@ -52,5 +53,3 @@ int fs_open_custom(struct fs_file *file, const char *name) {
 void fs_close_custom(struct fs_file *file) {
     (void)file;
 }
-
-#endif // DEBUG_DISK_WRITE_SOURCES

src/main.c

@@ -27,7 +27,6 @@
 #include "log.h"
 #include "usb.h"
 #include "usb_msc.h"
-#include "fat_disk.h"
 #include "debug_disk.h"
 #include "buttons.h"
 #include "ble.h"
@@ -40,6 +39,7 @@
 #include "workflow.h"
 #include "wifi.h"
 #include "http.h"
+#include "cache.h"
 #include "main.h"
 
 void main_loop_hw(void) {
@@ -53,6 +53,7 @@ void main_loop_hw(void) {
     }
 
     networking_run();
+    cache_run();
 }
 
 void networking_init(void) {
@@ -121,11 +122,8 @@ int main(void) {
     debug("ble_init");
     ble_init();
 
-    debug("fat_disk_init");
-    fat_disk_init();
-
-    debug("debug_disk_init");
-    debug_disk_init();
+    debug("cache_init");
+    cache_init();
 
 #ifdef AUTO_MOUNT_MASS_STORAGE
     msc_set_medium_available(true);

src/mem.c

@@ -18,23 +18,12 @@
 
 #include <string.h>
 
-#include "hardware/flash.h"
 #include "pico/flash.h"
-#include "pico/btstack_flash_bank.h"
 
 #include "config.h"
 #include "log.h"
 #include "mem.h"
 
-#define FLASH_LOCK_TIMEOUT_MS 500
-
-/*
- * Last two flash pages are used by BTstack.
- * So we use the third-last page for our persistent storage.
- * This is kept clear by our custom linker script.
- */
-#define FLASH_OFFSET (PICO_FLASH_BANK_STORAGE_OFFSET - FLASH_SECTOR_SIZE)
-
 struct mem_contents {
     uint8_t version;
     uint32_t checksum;
@@ -50,7 +39,7 @@ struct mem_contents {
 
 static const struct mem_contents data_defaults = MEM_CONTENTS_INIT;
 static struct mem_contents data_ram = data_defaults;
-static const uint8_t *data_flash = (const uint8_t *)(XIP_BASE + FLASH_OFFSET);
+static const uint8_t *data_flash = (const uint8_t *)(XIP_BASE + EEPROM_FLASH_OFFSET);
 
 static_assert(sizeof(struct mem_contents) < FLASH_SECTOR_SIZE,
               "Config needs to fit inside a flash sector");
@@ -142,10 +131,10 @@ void mem_load(void) {
 }
 
 static void mem_write_flash(void *param) {
-    flash_range_erase(FLASH_OFFSET, FLASH_SECTOR_SIZE);
+    flash_range_erase(EEPROM_FLASH_OFFSET, FLASH_SECTOR_SIZE);
 
     // TODO only need to write with length multiple of FLASH_PAGE_SIZE
-    flash_range_program(FLASH_OFFSET, param, FLASH_SECTOR_SIZE);
+    flash_range_program(EEPROM_FLASH_OFFSET, param, FLASH_SECTOR_SIZE);
 }
 
 void mem_write(void) {

src/usb_msc.c

@@ -30,7 +30,7 @@
 #include "tusb.h"
 
 #include "config.h"
-#include "fat_disk.h"
+#include "cache.h"
 #include "debug_disk.h"
 #include "log.h"
 
@@ -125,12 +125,7 @@ int32_t tud_msc_read10_cb(uint8_t lun, uint32_t lba,
         return -1;
     }
 
-    // TODO better range checking and length calculation?
-
-    uint8_t const* addr = fat_disk_get_sector(lba) + offset;
-    memcpy(buffer, addr, bufsize);
-
-    return (int32_t) bufsize;
+    return cache_read(buffer, (lba * DISK_BLOCK_SIZE) + offset, bufsize);
 }
 
 bool tud_msc_is_writable_cb (uint8_t lun) {
@@ -150,12 +145,7 @@ int32_t tud_msc_write10_cb(uint8_t lun, uint32_t lba,
         return -1;
     }
 
-    // TODO better range checking and length calculation?
-
-    uint8_t* addr = fat_disk_get_sector(lba) + offset;
-    memcpy(addr, buffer, bufsize);
-
-    return (int32_t) bufsize;
+    return cache_write(buffer, (lba * DISK_BLOCK_SIZE) + offset, bufsize);
 }
 
 // Callback invoked when received an SCSI command not in built-in list below
@@ -182,9 +172,7 @@ int32_t tud_msc_scsi_cb (uint8_t lun, uint8_t const scsi_cmd[16],
                 medium_locked = true;
 
 #ifdef AUTO_LOG_ON_MASS_STORAGE
-                debug_disk_mount();
-                log_dump_to_disk();
-                debug_disk_unmount();
+                debug_disk_init_log();
 #endif // AUTO_LOG_ON_MASS_STORAGE
             }
         } else {