5 files changed, 243 insertions, 45 deletions

diff --git a/firmware/common/devicedata.c b/firmware/common/devicedata.c
new file mode 100644
index 0000000000..75fe79d7fa
--- /dev/null
+++ b/firmware/common/devicedata.c
@@ -0,0 +1,88 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ *
+ * Copyright (C) 2024 by William Wilgus
+ *
+ * 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 2
+ * of the License, or (at your option) any later version.
+ *
+ * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
+ * KIND, either express or implied.
+ *
+ ****************************************************************************/
+
+#include "devicedata.h"
+#include "crc32.h"
+#include <stddef.h>
+#include <string.h>
+#include "debug.h"
+
+#ifndef BOOTLOADER
+void verify_device_data(void) INIT_ATTR;
+void verify_device_data(void)
+{
+    DEBUGF("%s", __func__);
+    /* verify payload with checksum */
+    uint32_t crc = crc_32(device_data.payload, device_data.length, 0xffffffff);
+    if (crc == device_data.crc)
+        return; /* return if data is valid */
+
+    /* Write the default if data is invalid */
+    memset(device_data.payload, 0xff, DEVICE_DATA_PAYLOAD_SIZE); /* Invalid data */
+    device_data.length = DEVICE_DATA_PAYLOAD_SIZE;
+    device_data.crc = crc_32(device_data.payload, device_data.length, 0xffffffff);
+
+}
+
+/******************************************************************************/
+#endif /* ndef BOOTLOADER ******************************************************/
+/******************************************************************************/
+
+#if defined(HAVE_DEVICEDATA)
+void  __attribute__((weak)) fill_devicedata(struct device_data_t *data)
+{
+    memset(data->payload, 0xff, data->length);
+}
+#endif
+
+/* Write bootdata into location in FIRMWARE marked by magic header
+ * Assumes buffer is already loaded with the firmware image
+ * We just need to find the location and write data into the
+ * payload region along with the crc for later verification and use.
+ * Returns payload len on success,
+ * On error returns false
+ */
+bool write_devicedata(unsigned char* buf, int len)
+{
+    int search_len = MIN(len, DEVICE_DATA_SEARCH_SIZE) - sizeof(struct device_data_t);
+
+    /* search for decvice data header prior to search_len */
+    for(int i = 0; i < search_len; i++)
+    {
+        struct device_data_t *data = (struct device_data_t *)&buf[i];
+        if (data->magic[0] != DEVICE_DATA_MAGIC0 ||
+            data->magic[1] != DEVICE_DATA_MAGIC1)
+            continue;
+
+        /* Ignore it if the length extends past the end of the buffer. */
+        int data_len = offsetof(struct device_data_t, payload) + data->length;
+        if (i + data_len > len)
+            continue;
+
+        fill_devicedata(data);
+
+        /* Calculate payload CRC */
+        data->crc = crc_32(data->payload, data->length, 0xffffffff);
+        return true;
+    }
+
+    return false;
+}
+
diff --git a/firmware/common/disk.c b/firmware/common/disk.c
index 9b6454c9a2..958f09755a 100644
--- a/firmware/common/disk.c
+++ b/firmware/common/disk.c
@@ -29,6 +29,7 @@
 #include "dir.h"
 #include "rb_namespace.h"
 #include "disk.h"
+#include "panic.h"
 
 #if defined(HAVE_BOOTDATA) && !defined(SIMULATOR) && !defined(BOOTLOADER)
 #include "bootdata.h"
@@ -110,7 +111,7 @@ static void init_volume(struct volumeinfo *vi, int drive, int part)
 }
 
 #ifdef MAX_LOG_SECTOR_SIZE
-static int disk_sector_multiplier[NUM_DRIVES] =
+static uint16_t disk_sector_multiplier[NUM_DRIVES] =
     { [0 ... NUM_DRIVES-1] = 1 };
 
 int disk_get_sector_multiplier(IF_MD_NONVOID(int drive))
@@ -125,6 +126,33 @@ int disk_get_sector_multiplier(IF_MD_NONVOID(int drive))
 }
 #endif /* MAX_LOG_SECTOR_SIZE */
 
+#if (CONFIG_STORAGE & STORAGE_ATA)  // XXX make this more generic?
+static uint16_t disk_log_sector_size[NUM_DRIVES] =
+    { [0 ... NUM_DRIVES-1] = SECTOR_SIZE }; /* Updated from STORAGE_INFO */
+int disk_get_log_sector_size(IF_MD_NONVOID(int drive))
+{
+    if (!CHECK_DRV(drive))
+        return 0;
+
+    disk_reader_lock();
+    int size = disk_log_sector_size[IF_MD_DRV(drive)];
+    disk_reader_unlock();
+    return size;
+}
+#ifdef HAVE_MULTIDRIVE
+#define LOG_SECTOR_SIZE(__drive) disk_log_sector_size[__drive]
+#else
+#define LOG_SECTOR_SIZE(__drive) disk_log_sector_size[0]
+#endif /* HAVE_MULTIDRIVE */
+#else /* !STORAGE_ATA */
+#define LOG_SECTOR_SIZE(__drive) SECTOR_SIZE
+int disk_get_log_sector_size(IF_MD_NONVOID(int drive))
+{
+    IF_MD((void)drive);
+    return SECTOR_SIZE;
+}
+#endif /* !CONFIG_STORAGE & STORAGE_ATA */
+
 bool disk_init(IF_MD_NONVOID(int drive))
 {
     if (!CHECK_DRV(drive))
@@ -134,7 +162,30 @@ bool disk_init(IF_MD_NONVOID(int drive))
     if (!sector)
         return false;
 
-    memset(sector, 0, SECTOR_SIZE);
+#if (CONFIG_STORAGE & STORAGE_ATA)
+    /* Query logical sector size */
+    struct storage_info *info = (struct storage_info*) sector;
+    storage_get_info(IF_MD_DRV(drive), info);
+    disk_writer_lock();
+#ifdef MAX_LOG_SECTOR_SIZE
+    disk_log_sector_size[IF_MD_DRV(drive)] = info->sector_size;
+#endif
+    disk_writer_unlock();
+
+#ifdef MAX_LOG_SECTOR_SIZE
+    if (info->sector_size > MAX_LOG_SECTOR_SIZE) {
+        panicf("Unsupported logical sector size: %d",
+               info->sector_size);
+    }
+#else
+    if (info->sector_size != SECTOR_SIZE) {
+        panicf("Unsupported logical sector size: %d",
+               info->sector_size);
+    }
+#endif
+#endif /* CONFIG_STORAGE & STORAGE_ATA */
+
+    memset(sector, 0, LOG_SECTOR_SIZE(drive));
     storage_read_sectors(IF_MD(drive,) 0, 1, sector);
 
     bool init = false;
@@ -172,6 +223,8 @@ bool disk_init(IF_MD_NONVOID(int drive))
             }
         }
 
+        // XXX backup GPT header at final LBA of drive...
+
         while (is_gpt) {
             /* Re-start partition parsing using GPT */
             uint64_t part_lba;
@@ -211,11 +264,11 @@ bool disk_init(IF_MD_NONVOID(int drive))
 reload:
             storage_read_sectors(IF_MD(drive,) part_lba, 1, sector);
             uint8_t *pptr = ptr;
-            while (part < MAX_PARTITIONS_PER_DRIVE && part_entries) {
-                if (pptr - ptr >= SECTOR_SIZE) {
-                    part_lba++;
-                    goto reload;
-                }
+            while (part < MAX_PARTITIONS_PER_DRIVE && part_entries) {
+                if (pptr - ptr >= LOG_SECTOR_SIZE(drive)) {
+                    part_lba++;
+                    goto reload;
+                }
 
                 /* Parse GPT entry.  We only care about the "General Data" type, ie:
                      EBD0A0A2-B9E5-4433-87C0-68B6B72699C7
@@ -243,20 +296,24 @@ reload:
                     goto skip; /* Any flag makes us ignore this */
                 }
                 tmp = BYTES2INT64(pptr, 32); /* FIRST LBA */
-                if (tmp > UINT32_MAX) { // XXX revisit when we resize struct partinfo!
-                    DEBUGF("GPT: partition starts after 2GiB mark\n");
+#ifndef STORAGE_64BIT_SECTOR
+                if (tmp > UINT32_MAX) {
+                    DEBUGF("GPT: partition starts after 2TiB mark\n");
                     goto skip;
                 }
+#endif
                 if (tmp < 34) {
                     DEBUGF("GPT: Invalid start LBA\n");
                     goto skip;
                 }
                 pinfo[part].start = tmp;
                 tmp = BYTES2INT64(pptr, 40); /* LAST LBA */
-                if (tmp > UINT32_MAX) { // XXX revisit when we resize struct partinfo!
-                    DEBUGF("GPT: partition ends after 2GiB mark\n");
+#ifndef STORAGE_64BIT_SECTOR
+                if (tmp > UINT32_MAX) {
+                    DEBUGF("GPT: partition ends after 2TiB mark\n");
                     goto skip;
                 }
+#endif
                 if (tmp <= pinfo[part].start) {
                     DEBUGF("GPT: Invalid end LBA\n");
                     goto skip;
@@ -264,7 +321,7 @@ reload:
                 pinfo[part].size = tmp - pinfo[part].start + 1;
                 pinfo[part].type = PARTITION_TYPE_FAT32_LBA;
 
-                DEBUGF("GPart%d: start: %08lx size: %08lx\n",
+                DEBUGF("GPart%d: start: %016lx size: %016lx\n",
                        part,pinfo[part].start,pinfo[part].size);
                 part++;
 
@@ -325,19 +382,18 @@ int disk_mount(int drive)
     disk_sector_multiplier[IF_MD_DRV(drive)] = 1;
 #endif
 
-        /* try "superfloppy" mode */
-        DEBUGF("Trying to mount sector 0.\n");
+    /* try "superfloppy" mode */
+    DEBUGF("Trying to mount sector 0.\n");
 
-        if (!fat_mount(IF_MV(volume,) IF_MD(drive,) 0))
-        {
-        #ifdef MAX_LOG_SECTOR_SIZE
-            disk_sector_multiplier[drive] =
-                fat_get_bytes_per_sector(IF_MV(volume)) / SECTOR_SIZE;
-        #endif
-            mounted = 1;
-            init_volume(&volumes[volume], drive, 0);
-            volume_onmount_internal(IF_MV(volume));
-        }
+    if (!fat_mount(IF_MV(volume,) IF_MD(drive,) 0))
+    {
+#ifdef MAX_LOG_SECTOR_SIZE
+        disk_sector_multiplier[drive] = fat_get_bytes_per_sector(IF_MV(volume)) / LOG_SECTOR_SIZE(drive);
+#endif
+        mounted = 1;
+        init_volume(&volumes[volume], drive, 0);
+        volume_onmount_internal(IF_MV(volume));
+    }
 
     if (mounted == 0 && volume != -1) /* not a "superfloppy"? */
     {
@@ -348,10 +404,10 @@ int disk_mount(int drive)
             if (pinfo[i].type == 0 || pinfo[i].type == 5)
                 continue;  /* skip free/extended partitions */
 
-        DEBUGF("Trying to mount partition %d.\n", i);
+            DEBUGF("Trying to mount partition %d.\n", i);
 
-        #ifdef MAX_LOG_SECTOR_SIZE
-            for (int j = 1; j <= (MAX_LOG_SECTOR_SIZE/SECTOR_SIZE); j <<= 1)
+#ifdef MAX_LOG_SECTOR_SIZE
+            for (int j = 1; j <= (MAX_LOG_SECTOR_SIZE/LOG_SECTOR_SIZE(drive)); j <<= 1)
             {
                 if (!fat_mount(IF_MV(volume,) IF_MD(drive,) pinfo[i].start * j))
                 {
@@ -365,7 +421,7 @@ int disk_mount(int drive)
                     break;
                 }
             }
-        #else /* ndef MAX_LOG_SECTOR_SIZE */
+#else /* ndef MAX_LOG_SECTOR_SIZE */
             if (!fat_mount(IF_MV(volume,) IF_MD(drive,) pinfo[i].start))
             {
                 mounted++;
@@ -373,7 +429,7 @@ int disk_mount(int drive)
                 volume_onmount_internal(IF_MV(volume));
                 volume = get_free_volume(); /* prepare next entry */
             }
-        #endif /* MAX_LOG_SECTOR_SIZE */
+#endif /* MAX_LOG_SECTOR_SIZE */
         }
     }
 
@@ -499,13 +555,13 @@ unsigned int volume_get_cluster_size(IF_MV_NONVOID(int volume))
     return clustersize;
 }
 
-void volume_size(IF_MV(int volume,) unsigned long *sizep, unsigned long *freep)
+void volume_size(IF_MV(int volume,) sector_t *sizep, sector_t *freep)
 {
     disk_reader_lock();
 
     if (!CHECK_VOL(volume) || !fat_size(IF_MV(volume,) sizep, freep))
     {
-        if (freep) *sizep = 0;
+        if (sizep) *sizep = 0;
         if (freep) *freep = 0;
     }
 
diff --git a/firmware/common/disk_cache.c b/firmware/common/disk_cache.c
index 9e4dee6a91..74c4d5f35b 100644
--- a/firmware/common/disk_cache.c
+++ b/firmware/common/disk_cache.c
@@ -71,12 +71,12 @@ struct disk_cache_entry
 #ifdef HAVE_MULTIVOLUME
     unsigned char volume;   /* volume of sector */
 #endif
-    unsigned long sector;   /* cached disk sector number */
+    sector_t sector;   /* cached disk sector number */
 };
 
 BITARRAY_TYPE_DECLARE(cache_map_entry_t, cache_map, DC_NUM_ENTRIES)
 
-static inline unsigned int map_sector(unsigned long sector)
+static inline unsigned int map_sector(sector_t sector)
 {
     /* keep sector hash simple for now */
     return sector % DC_MAP_NUM_ENTRIES;
@@ -172,7 +172,7 @@ static inline void cache_discard_entry(struct disk_cache_entry *dce,
 /* search the cache for the specified sector, returning a buffer, either
    to the specified sector, if it exists, or a new/evicted entry that must
    be filled */
-void * dc_cache_probe(IF_MV(int volume,) unsigned long sector,
+void * dc_cache_probe(IF_MV(int volume,) sector_t sector,
                       unsigned int *flagsp)
 {
     unsigned int mapnum = map_sector(sector);
@@ -200,7 +200,7 @@ void * dc_cache_probe(IF_MV(int volume,) unsigned long sector,
     if (old_flags)
     {
         int old_volume = IF_MV_VOL(dce->volume);
-        unsigned long sector = dce->sector;
+        sector_t sector = dce->sector;
         unsigned int old_mapnum = map_sector(sector);
 
         if (old_flags & DCE_DIRTY)
diff --git a/firmware/common/pathfuncs.c b/firmware/common/pathfuncs.c
index db3abe6940..b5e5ecb0cf 100644
--- a/firmware/common/pathfuncs.c
+++ b/firmware/common/pathfuncs.c
@@ -24,10 +24,14 @@
 #include "pathfuncs.h"
 #include "string-extra.h"
 #include <stdio.h>
+#include "file_internal.h"
+#include "debug.h"
 
 #ifdef HAVE_MULTIVOLUME
 #include "storage.h"
 
+static char vol_dec_strings[NUM_VOLUMES][ALIGN_UP(VOL_MAX_LEN+2, 4)] = {{0}};
+
 enum storage_name_dec_indexes
 {
 #if (CONFIG_STORAGE & STORAGE_ATA)
@@ -106,6 +110,54 @@ static const unsigned char storage_dec_indexes[STORAGE_NUM_TYPES+1] =
 #endif
 };
 
+/* builds a list of drive/volume specifiers <volstr#> */
+void init_volume_names(void)
+{
+    DEBUGF("%s: ", __func__);
+    FOR_EACH_VOLUME(-1, volume)
+    {
+        const char *voldec = "";
+        char *buffer = vol_dec_strings[volume];
+
+        int type = storage_driver_type(volume_drive(volume));
+        if (type < 0 || type > STORAGE_NUM_TYPES)
+            type = STORAGE_NUM_TYPES;
+        voldec = storage_dec_names[storage_dec_indexes[type]];
+        snprintf(buffer, VOL_MAX_LEN + 1, "%c%s%d%c",
+                VOL_START_TOK, voldec, volume, VOL_END_TOK);
+        DEBUGF("vol<%d> = %s ", volume, buffer);
+    }
+    DEBUGF("\n");
+}
+
+#include <stdio.h>
+
+int path_get_volume_id(const char *name)
+{
+    int v = -1;
+
+    if (!name || *name != VOL_START_TOK)
+        goto bail;
+
+    do {
+        switch (*name)
+        {
+        case '0' ... '9':       /* digit; parse volume number */
+            v = (v * 10 + *name - '0') % VOL_NUM_MAX;
+            break;
+        case '\0':
+        case PATH_SEPCH:        /* no closing bracket; no volume */
+            v = -1;
+            goto bail;
+        default:                /* something else; reset volume */
+            v = 0;
+        }
+    } while (*++name != VOL_END_TOK);  /* found end token? */
+
+bail:
+    return v;
+}
+
 /* Returns on which volume this is and sets *nameptr to the portion of the
  * path after the volume specifier, which could be the null if the path is
  * just a volume root. If *nameptr > name, then a volume specifier was
@@ -203,7 +255,8 @@ int path_strip_last_volume(const char *name, const char **nameptr, bool greedy)
 }
 
 /* Returns the volume specifier decorated with the storage type name.
- * Assumes the supplied buffer size is at least {VOL_MAX_LEN}+1.
+ * Assumes the supplied buffer size is at least {VOL_MAX_LEN}+1,
+ * vol_dec_strings has been initialized by init_volume_names().
  */
 int get_volume_name(int volume, char *buffer)
 {
@@ -218,17 +271,12 @@ int get_volume_name(int volume, char *buffer)
 
     volume %= VOL_NUM_MAX; /* as path parser would have it */
 
-    int type = storage_driver_type(volume_drive(volume));
-    if (type < 0 || type > STORAGE_NUM_TYPES)
-        type = STORAGE_NUM_TYPES;
-
-    const char *voldec = storage_dec_names[storage_dec_indexes[type]];
-    return snprintf(buffer, VOL_MAX_LEN + 1, "%c%s%d%c",
-                    VOL_START_TOK, voldec, volume, VOL_END_TOK);
+    return strlcpy(buffer, vol_dec_strings[volume], VOL_MAX_LEN + 1);
 }
 
 /* Returns volume name formatted with the root. Assumes buffer size is at
- * least {VOL_MAX_LEN}+2 */
+ * least {VOL_MAX_LEN}+2, vol_dec_strings has been initialized by init_volume_names().
+ */
 int make_volume_root(int volume, char *buffer)
 {
     char *t = buffer;
diff --git a/firmware/common/rb-loader.c b/firmware/common/rb-loader.c
index 61d8b1ddd2..2f5e06e165 100644
--- a/firmware/common/rb-loader.c
+++ b/firmware/common/rb-loader.c
@@ -30,6 +30,9 @@
 #include "multiboot.h"
 #endif
 
+#ifdef HAVE_DEVICEDATA
+#include "devicedata.h"
+#endif
 /* loads a firmware file from supplied filename
  * file opened, checks firmware size and checksum
  * if no error, firmware loaded to supplied buffer
@@ -118,7 +121,6 @@ int load_firmware(unsigned char* buf, const char* firmware, int buffer_size)
             /* if ret is valid breaks from loop to continue loading */
         }
 #endif
-
         if (ret < 0) /* Check default volume, no valid firmware file loaded yet */
         {
             /* First check in BOOTDIR */
@@ -141,5 +143,9 @@ int load_firmware(unsigned char* buf, const char* firmware, int buffer_size)
     else /* full path passed ROLO etc.*/
         ret = load_firmware_filename(buf, firmware, buffer_size);
 
+#ifdef HAVE_DEVICEDATA
+        write_devicedata(buf, ret);
+#endif
+
     return ret;
 }