12 files changed, 379 insertions, 180 deletions

diff --git a/firmware/export/config.h b/firmware/export/config.h
index 5e4178cd4c..2a1cdb3416 100644
--- a/firmware/export/config.h
+++ b/firmware/export/config.h
@@ -27,12 +27,21 @@
 /* symbolic names for multiple choice configurations: */
 
 /* CONFIG_STORAGE (note these are combineable bit-flags) */
-#define STORAGE_ATA     0x01
-#define STORAGE_MMC     0x02
-#define STORAGE_SD      0x04
-#define STORAGE_NAND    0x08
-#define STORAGE_RAMDISK 0x10
-#define STORAGE_HOSTFS  0x20 /* meant for APPLICATION targets (implicit for SIMULATOR) */
+#define STORAGE_ATA_NUM     0
+#define STORAGE_MMC_NUM     1
+#define STORAGE_SD_NUM      2
+#define STORAGE_NAND_NUM    3
+#define STORAGE_RAMDISK_NUM 4
+#define STORAGE_HOSTFS_NUM  5
+#define STORAGE_NUM_TYPES   6
+
+#define STORAGE_ATA         (1 << STORAGE_ATA_NUM)
+#define STORAGE_MMC         (1 << STORAGE_MMC_NUM)
+#define STORAGE_SD          (1 << STORAGE_SD_NUM)
+#define STORAGE_NAND        (1 << STORAGE_NAND_NUM)
+#define STORAGE_RAMDISK     (1 << STORAGE_RAMDISK_NUM)
+ /* meant for APPLICATION targets (implicit for SIMULATOR) */
+#define STORAGE_HOSTFS      (1 << STORAGE_HOSTFS_NUM)
 
 /* CONFIG_TUNER (note these are combineable bit-flags) */
 #define S1A0903X01 0x01 /* Samsung */
@@ -573,6 +582,8 @@ Lyre prototype 1 */
 #ifdef __PCTOOL__
 #undef CONFIG_CPU
 #define CONFIG_CPU 0
+#undef HAVE_MULTIVOLUME
+#undef HAVE_MULTIDRIVE
 #endif
 
 #ifdef APPLICATION
@@ -831,9 +842,11 @@ Lyre prototype 1 */
  * plenty of RAM. Both features can be enabled independently. */
 #if (MEMORYSIZE >= 8) && !defined(BOOTLOADER) && !defined(__PCTOOL__) \
     && !defined(APPLICATION)
+#ifndef SIMULATOR
 #define HAVE_DIRCACHE
+#endif
 #ifdef HAVE_TAGCACHE
-#define HAVE_TC_RAMCACHE
+//#define HAVE_TC_RAMCACHE
 #endif
 #endif
 
@@ -1178,7 +1191,7 @@ Lyre prototype 1 */
 /* This attribute can be used to enable to detection of plugin file handles leaks.
  * When enabled, the plugin core will monitor open/close/creat and when the plugin exits
  * will display an error message if the plugin leaked some file handles */
-#if (CONFIG_PLATFORM & PLATFORM_NATIVE)
+#if (CONFIG_PLATFORM & PLATFORM_NATIVE) || defined (SIMULATOR)
 #define HAVE_PLUGIN_CHECK_OPEN_CLOSE
 #endif
 
diff --git a/firmware/export/config/gigabeats.h b/firmware/export/config/gigabeats.h
index 11fc02be3d..6657134f9d 100644
--- a/firmware/export/config/gigabeats.h
+++ b/firmware/export/config/gigabeats.h
@@ -16,6 +16,9 @@
 /* define this if you use an ATA controller */
 #define CONFIG_STORAGE STORAGE_ATA
 
+/* For the Gigabeat S, we mount the second partition */
+#define CONFIG_DEFAULT_PARTNUM 1
+
 /*define this if the ATA controller and method of USB access support LBA48 */
 #define HAVE_LBA48
 
diff --git a/firmware/export/disk.h b/firmware/export/disk.h
index 8d6b41b5bd..c66028fe45 100644
--- a/firmware/export/disk.h
+++ b/firmware/export/disk.h
@@ -24,7 +24,8 @@
 #include "config.h"
 #include "mv.h" /* for volume definitions */
 
-struct partinfo {
+struct partinfo
+{
     unsigned long start; /* first sector (LBA) */
     unsigned long size;  /* number of sectors */
     unsigned char type;
@@ -35,11 +36,9 @@ struct partinfo {
 #define PARTITION_TYPE_FAT16                0x06
 #define PARTITION_TYPE_OS2_HIDDEN_C_DRIVE   0x84
 
-/* returns a pointer to an array of 8 partinfo structs */
-struct partinfo* disk_init(IF_MD_NONVOID(int drive));
-struct partinfo* disk_partinfo(int partition);
+bool disk_init(IF_MD_NONVOID(int drive));
+bool disk_partinfo(int partition, struct partinfo *info);
 
-void disk_init_subsystem(void) INIT_ATTR; /* Initialises mutexes */
 int disk_mount_all(void); /* returns the # of successful mounts */
 int disk_mount(int drive);
 int disk_unmount_all(void);
@@ -50,4 +49,6 @@ int disk_unmount(int drive);
 int disk_get_sector_multiplier(IF_MD_NONVOID(int drive));
 #endif
 
-#endif
+bool disk_present(IF_MD_NONVOID(int drive));
+
+#endif /* _DISK_H_ */
diff --git a/firmware/export/fat.h b/firmware/export/fat.h
index a0d52acc35..3aa1e254dc 100644
--- a/firmware/export/fat.h
+++ b/firmware/export/fat.h
@@ -18,123 +18,168 @@
  * KIND, either express or implied.
  *
  ****************************************************************************/
-
 #ifndef FAT_H
 #define FAT_H
 
 #include <stdbool.h>
-#include "mv.h" /* for volume definitions */
+#include <sys/types.h>
+#include <time.h>
 #include "config.h"
 #include "system.h"
+#include "mv.h" /* for volume definitions */
+
+/********
+ **** DO NOT use these functions directly unless otherwise noted. Required
+ **** synchronization is done by higher-level interfaces to minimize locking
+ **** overhead.
+ ****
+ **** Volume, drive, string, etc. parameters should also be checked by
+ **** callers for gross violations-- NULL strings, out-of-bounds values,
+ **** etc.
+ ****/
+
+/****************************************************************************
+ ** Values that can be overridden by a target in config-[target].h
+ **/
+
+/* if your ATA implementation can do better, go right ahead and increase this
+ * value */
+#ifndef FAT_MAX_TRANSFER_SIZE
+#define FAT_MAX_TRANSFER_SIZE 256
+#endif
 
-/* This value can be overwritten by a target in config-[target].h, but
-   that behaviour is still experimental */
+/* still experimental? */
+/* increasing this will increase the total memory used by the cache; the
+   cache, as noted in disk_cache.h, has other minimum requirements that may
+   prevent reducing its number of entries in order to compensate */
 #ifndef SECTOR_SIZE
 #define SECTOR_SIZE 512
 #endif
 
+/**
+ ****************************************************************************/
+
+#define INVALID_SECNUM     (0xfffffffeul) /* sequential, not FAT */
+#define FAT_MAX_FILE_SIZE  (0xfffffffful) /* 2^32-1 bytes */
+#define MAX_DIRENTRIES     65536
+#define MAX_DIRECTORY_SIZE (MAX_DIRENTRIES*32) /* 2MB max size */
+
+/* these aren't I/O error conditions, so define specially; failure rc's
+ * shouldn't return the last digit as "0", therefore this is unambiguous */
+#define FAT_RC_ENOSPC (-10)
+#define FAT_SEEK_EOF  (-20)
+
 /* Number of bytes reserved for a file name (including the trailing \0).
-   Since names are stored in the entry as UTF-8, we won't be able to
+   Since names are stored in the entry as UTF-8, we won't be ble to
    store all names allowed by FAT. In FAT, a name can have max 255
    characters (not bytes!). Since the UTF-8 encoding of a char may take
    up to 4 bytes, there will be names that we won't be able to store
    completely. For such names, the short DOS name is used. */
-#define FAT_FILENAME_BYTES 256
-
+#define FAT_DIRENTRY_NAME_MAX 255
 struct fat_direntry
 {
-    unsigned char name[FAT_FILENAME_BYTES]; /* UTF-8 encoded name plus \0 */
-    unsigned short attr;            /* Attributes */
-    unsigned char crttimetenth;     /* Millisecond creation
-                                       time stamp (0-199) */
-    unsigned short crttime;         /* Creation time */
-    unsigned short crtdate;         /* Creation date */
-    unsigned short lstaccdate;      /* Last access date */
-    unsigned short wrttime;         /* Last write time */
-    unsigned short wrtdate;         /* Last write date */
-    unsigned long filesize;          /* File size in bytes */
-    long firstcluster;               /* fstclusterhi<<16 + fstcluslo */
+    union {
+    uint8_t  name[255+1+4];     /* UTF-8 name plus \0 plus parse slop */
+    uint16_t ucssegs[5+20][13]; /* UTF-16 segment buffer - layout saves... */
+    };                          /* ...130 bytes (important if stacked) */
+    uint16_t ucsterm;           /* allow one NULL-term after ucssegs */
+    uint8_t  shortname[13];     /* DOS filename (OEM charset) */
+    uint8_t  attr;              /* file attributes */
+    uint8_t  crttimetenth;      /* millisecond creation time stamp (0-199) */
+    uint16_t crttime;           /* creation time */
+    uint16_t crtdate;           /* creation date */
+    uint16_t lstaccdate;        /* last access date */
+    uint16_t wrttime;           /* last write time */
+    uint16_t wrtdate;           /* last write date */
+    uint32_t filesize;          /* file size in bytes */
+    int32_t  firstcluster;      /* first FAT cluster of file, 0 if empty */
 };
 
-#define FAT_ATTR_READ_ONLY   0x01
-#define FAT_ATTR_HIDDEN      0x02
-#define FAT_ATTR_SYSTEM      0x04
-#define FAT_ATTR_VOLUME_ID   0x08
-#define FAT_ATTR_DIRECTORY   0x10
-#define FAT_ATTR_ARCHIVE     0x20
-#define FAT_ATTR_VOLUME      0x40 /* this is a volume, not a real directory */
+/* cursor structure used for scanning directories; holds the last-returned
+   entry information */
+struct fat_dirscan_info
+{
+    unsigned int entry;         /* short dir entry index in parent */
+    unsigned int entries;       /* number of dir entries used */
+};
+
+#define FAT_RW_VAL  (0u - 1)
 
+/* basic FAT file information about where to find a file and who houses it */
 struct fat_file
 {
-    long firstcluster;    /* first cluster in file */
-    long lastcluster;     /* cluster of last access */
-    long lastsector;      /* sector of last access */
-    long clusternum;      /* current clusternum */
-    long sectornum;       /* sector number in this cluster */
-    unsigned int direntry;   /* short dir entry index from start of dir */
-    unsigned int direntries; /* number of dir entries used by this file */
-    long dircluster;      /* first cluster of dir */
-    bool eof;
 #ifdef HAVE_MULTIVOLUME
-    int volume;          /* file resides on which volume */
+    int    volume;              /* file resides on which volume (first!) */
 #endif
+    long   firstcluster;        /* first cluster in file */
+    long   dircluster;          /* first cluster of parent directory */
+    struct fat_dirscan_info e;  /* entry information */
 };
 
-struct fat_dir
+/* this stores what was last accessed when read or writing a file's data */
+struct fat_filestr
 {
-    unsigned char sectorcache[SECTOR_SIZE] CACHEALIGN_ATTR;
-    unsigned int entry;
-    unsigned int entrycount;
-    long sector;
-    struct fat_file file;
-    /* There are 2-bytes per characters. We don't want to bother too much, as LFN entries are
-     * at much 255 characters longs, that's at most 20 LFN entries. Each entry hold at most
-     * 13 characters, that a total of 260 characters. So we keep a buffer of that size.
-     * Keep coherent with fat.c code. */
-    unsigned char longname[260 * 2];
-} CACHEALIGN_ATTR;
-
-#ifdef HAVE_HOTSWAP
-extern void fat_lock(void);
-extern void fat_unlock(void);
-#endif
+    struct fat_file *fatfilep;  /* common file information */
+    long          lastcluster;  /* cluster of last access */
+    unsigned long lastsector;   /* sector of last access */
+    long          clusternum;   /* cluster number of last access */
+    unsigned long sectornum;    /* sector number within current cluster */
+    bool          eof;          /* end-of-file reached */
+};
+
+/** File entity functions **/
+int fat_create_file(struct fat_file *parent, const char *name,
+                    uint8_t attr, struct fat_file *file,
+                    struct fat_direntry *fatent);
+bool fat_dir_is_parent(const struct fat_file *dir, const struct fat_file *file);
+bool fat_file_is_same(const struct fat_file *file1, const struct fat_file *file2);
+int fat_fstat(struct fat_file *file, struct fat_direntry *entry);
+int fat_open(const struct fat_file *parent, long startcluster,
+             struct fat_file *file);
+int fat_open_rootdir(IF_MV(int volume,) struct fat_file *dir);
+enum fat_remove_op           /* what should fat_remove(), remove? */
+{
+    FAT_RM_DIRENTRIES = 0x1, /* remove only directory entries */
+    FAT_RM_DATA       = 0x2, /* remove only file data */
+    FAT_RM_ALL        = 0x3, /* remove all of above */
+};
+int fat_remove(struct fat_file *file, enum fat_remove_op what);
+int fat_rename(struct fat_file *parent, struct fat_file *file,
+               const unsigned char *newname);
 
-extern void fat_init(void);
-extern int fat_get_bytes_per_sector(IF_MV_NONVOID(int volume));
-extern int fat_mount(IF_MV(int volume,) IF_MD(int drive,) long startsector);
-extern int fat_unmount(int volume, bool flush);
-extern void fat_size(IF_MV(int volume,) /* public for info */
-                     unsigned long* size,
-                     unsigned long* free);
-extern void fat_recalc_free(IF_MV_NONVOID(int volume)); /* public for debug info screen */
-extern int fat_create_dir(const char* name,
-                          struct fat_dir* newdir,
-                          struct fat_dir* dir);
-extern int fat_open(IF_MV(int volume,)
-                    long cluster,
-                    struct fat_file* ent,
-                    const struct fat_dir* dir);
-extern int fat_create_file(const char* name,
-                           struct fat_file* ent,
-                           struct fat_dir* dir);
-extern long fat_readwrite(struct fat_file *ent, long sectorcount, 
-                         void* buf, bool write );
-extern int fat_closewrite(struct fat_file *ent, long size, int attr);
-extern int fat_seek(struct fat_file *ent, unsigned long sector );
-extern int fat_remove(struct fat_file *ent);
-extern int fat_truncate(const struct fat_file *ent);
-extern int fat_rename(struct fat_file* file, 
-                      struct fat_dir* dir,
-                      const unsigned char* newname,
-                      long size, int attr);
-
-extern int fat_opendir(IF_MV(int volume,)
-                       struct fat_dir *ent, unsigned long startcluster,
-                       const struct fat_dir *parent_dir);
-extern int fat_getnext(struct fat_dir *ent, struct fat_direntry *entry);
-extern unsigned int fat_get_cluster_size(IF_MV_NONVOID(int volume)); /* public for debug info screen */
-extern bool fat_ismounted(int volume);
-extern void* fat_get_sector_buffer(void);
-extern void fat_release_sector_buffer(void);
+/** File stream functions **/
+int fat_closewrite(struct fat_filestr *filestr, uint32_t size,
+                   struct fat_direntry *fatentp);
+void fat_filestr_init(struct fat_filestr *filestr, struct fat_file *file);
+unsigned long fat_query_sectornum(const struct fat_filestr *filestr);
+long fat_readwrite(struct fat_filestr *filestr, unsigned long sectorcount,
+                   void *buf, bool write);
+void fat_rewind(struct fat_filestr *filestr);
+int fat_seek(struct fat_filestr *filestr, unsigned long sector);
+int fat_truncate(const struct fat_filestr *filestr);
 
-#endif
+/** Directory stream functions **/
+struct filestr_cache;
+int fat_readdir(struct fat_filestr *dirstr, struct fat_dirscan_info *scan,
+                struct filestr_cache *cachep, struct fat_direntry *entry);
+void fat_rewinddir(struct fat_dirscan_info *scan);
+
+/** Mounting and unmounting functions **/
+bool fat_ismounted(IF_MV_NONVOID(int volume));
+int fat_mount(IF_MV(int volume,) IF_MD(int drive,) unsigned long startsector);
+int fat_unmount(IF_MV_NONVOID(int volume));
+
+/** Debug screen stuff **/
+#ifdef MAX_LOG_SECTOR_SIZE
+int fat_get_bytes_per_sector(IF_MV_NONVOID(int volume));
+#endif /* MAX_LOG_SECTOR_SIZE */
+unsigned int fat_get_cluster_size(IF_MV_NONVOID(int volume));
+void fat_recalc_free(IF_MV_NONVOID(int volume));
+bool fat_size(IF_MV(int volume,) unsigned long *size, unsigned long *free);
+
+/** Misc. **/
+time_t fattime_mktime(uint16_t fatdate, uint16_t fattime);
+void fat_empty_fat_direntry(struct fat_direntry *entry);
+void fat_init(void);
+
+#endif /* FAT_H */
diff --git a/firmware/export/filefuncs.h b/firmware/export/filefuncs.h
deleted file mode 100644
index 92e97f65b0..0000000000
--- a/firmware/export/filefuncs.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/***************************************************************************
- *             __________               __   ___.
- *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
- *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
- *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
- *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
- *                     \/            \/     \/    \/            \/
- * $Id$
- *
- * Copyright (C) 2009 by Maurus Cuelenaere
- *
- * 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.
- *
- ****************************************************************************/
-
-#ifndef __INCLUDE_FILEFUNCS_H_
-#define __INCLUDE_FILEFUNCS_H_
-
-#include <stdbool.h>
-#include "config.h"
-#include "file.h"
-#include "dir.h"
-
-#ifdef HAVE_MULTIVOLUME
-int strip_volume(const char* name, char* namecopy);
-#endif
-
-bool file_exists(const char *file);
-bool dir_exists(const char *path);
-
-extern struct dirinfo dir_get_info(DIR* parent, struct dirent *entry);
-
-#endif /* __INCLUDE_FILEFUNCS_H_ */
diff --git a/firmware/export/hostfs.h b/firmware/export/hostfs.h
index bbadecec31..a24d009ca9 100644
--- a/firmware/export/hostfs.h
+++ b/firmware/export/hostfs.h
@@ -41,4 +41,29 @@ extern bool hostfs_removable(int drive);
 extern bool hostfs_present(int drive);
 #endif
 
+/* This has to be repeated here for now for sim's sake since HAVE_HOSTFS
+   eats all the other stuff in storage.h. The sim probably shouldn't use
+   this. */
+#ifdef CONFIG_STORAGE_MULTI
+extern int hostfs_driver_type(int drive);
+#else
+# ifdef APPLICATION
+#  define hostfs_driver_type(drive) (STORAGE_HOSTFS_NUM)
+# else /* !APPLICATION */
+#  if (CONFIG_STORAGE & STORAGE_ATA)
+#   define hostfs_driver_type(drive) (STORAGE_ATA_NUM)
+#  elif (CONFIG_STORAGE & STORAGE_SD)
+#   define hostfs_driver_type(drive) (STORAGE_SD_NUM)
+#  elif (CONFIG_STORAGE & STORAGE_MMC)
+#   define hostfs_driver_type(drive) (STORAGE_MMC_NUM)
+#  elif (CONFIG_STORAGE & STORAGE_NAND)
+#   define hostfs_driver_type(drive) (STORAGE_NAND_NUM)
+#  elif (CONFIG_STORAGE & STORAGE_RAMDISK)
+#   define hostfs_driver_type(drive) (STORAGE_RAMDISK_NUM)
+#  else
+#   error Unknown storage driver
+#  endif /* CONFIG_STORAGE */
+# endif /* APPLICATION */
+#endif /* CONFIG_STORAGE_MULTI */
+
 #endif /* HOSTFS_H */
diff --git a/firmware/export/load_code.h b/firmware/export/load_code.h
index cca577044e..df85a81f82 100644
--- a/firmware/export/load_code.h
+++ b/firmware/export/load_code.h
@@ -45,7 +45,17 @@ static inline void lc_close(void *handle) { (void)handle; }
 
 #elif (CONFIG_PLATFORM & PLATFORM_HOSTED)
 
+#ifdef APPLICATION
+/* App doesn't simulate code loading from a buffer */
+static inline void * lc_open_from_mem(void *addr, size_t blob_size)
+{
+    return NULL;
+    (void)addr; (void)blob_size;
+}
+#else
 extern void *lc_open_from_mem(void* addr, size_t blob_size);
+#endif
+
 extern void *lc_get_header(void *handle);
 extern void  lc_close(void *handle);
 
diff --git a/firmware/export/mv.h b/firmware/export/mv.h
index 1d0a536663..620d77d30d 100644
--- a/firmware/export/mv.h
+++ b/firmware/export/mv.h
@@ -45,23 +45,44 @@
 #define IF_MV(x...) x          /* valist contents or empty */
 #define IF_MV_NONVOID(x...) x  /* valist contents or 'void' */
 #define IF_MV_VOL(v) v         /* volume argument or '0' */
-/* how to name volumes, first char must be outside of legal file names,
-   a number gets appended to enumerate, if applicable */
-#if (CONFIG_STORAGE & STORAGE_MMC)
-#define VOL_NAMES "<MMC%d>"
-#define VOL_ENUM_POS 4 /* position of %d, to avoid runtime calculation */
-#elif (CONFIG_STORAGE & STORAGE_SD)
-#define VOL_NAMES "<microSD%d>"
-#define VOL_ENUM_POS 8 /* position of %d, to avoid runtime calculation */
-#else
-#define VOL_NAMES "<HD%d>"
-#define VOL_ENUM_POS 3
-#endif /* CONFIG_STORAGE */
 
-#ifdef HAVE_HOTSWAP
-bool volume_removable(int volume);
-bool volume_present(int volume);
+/* Format: "/<DEC###>/foo/bar"
+ * The "DEC" is pure decoration and treated as a comment. Only an unbroken
+ * trailing string of digits within the brackets is parsed as the volume
+ * number.
+ *
+ * IMPORTANT!: Adjust VOL_DEC_MAX_LEN if needed to the longest of these
+ */
+#define DEFAULT_VOL_DEC "Volume"
+
+#if (CONFIG_STORAGE & STORAGE_ATA)
+#define ATA_VOL_DEC     "HDD"
+#endif
+#if (CONFIG_STORAGE & STORAGE_MMC)
+#define MMC_VOL_DEC     "MMC"
+#endif
+#if (CONFIG_STORAGE & STORAGE_SD)
+#define SD_VOL_DEC      "microSD"
+#endif
+#if (CONFIG_STORAGE & STORAGE_NAND)
+#define NAND_VOL_DEC    "NAND"
+#endif
+#if (CONFIG_STORAGE & STORAGE_RAMDISK)
+#define RAMDISK_VOL_DEC "RAMDisk"
+#endif
+#if (CONFIG_STORAGE & STORAGE_HOSTFS)
+#ifndef HOSTFS_VOL_DEC /* overridable */
+#define HOSTFS_VOL_DEC  DEFAULT_VOL_DEC
 #endif
+#endif
+
+/* Characters that delimit a volume specifier at any root point in the path.
+   The tokens must be outside of legal filename characters */
+#define VOL_START_TOK    '<'
+#define VOL_END_TOK      '>'
+#define VOL_DEC_MAX_LEN  7 /* biggest of all xxx_VOL_DEC defines */
+#define VOL_MAX_LEN      (1 + VOL_DEC_MAX_LEN + 2 + 1)
+#define VOL_NUM_MAX      100
 
 #else /* empty definitions if no multi-volume */
 #define IF_MV(x...)
@@ -69,4 +90,30 @@ bool volume_present(int volume);
 #define IF_MV_VOL(v) 0
 #endif /* HAVE_MULTIVOLUME */
 
+#define CHECK_VOL(volume) \
+    ((unsigned int)IF_MV_VOL(volume) < NUM_VOLUMES)
+
+#define CHECK_DRV(drive) \
+    ((unsigned int)IF_MD_DRV(drive) < NUM_DRIVES)
+
+/* Volume-centric functions (in disk.c) */
+void volume_recalc_free(IF_MV_NONVOID(int volume));
+unsigned int volume_get_cluster_size(IF_MV_NONVOID(int volume));
+void volume_size(IF_MV(int volume,) unsigned long *size, unsigned long *free);
+bool volume_ismounted(IF_MV_NONVOID(int volume));
+#ifdef HAVE_HOTSWAP
+bool volume_removable(int volume);
+bool volume_present(int volume);
+#endif /* HAVE_HOTSWAP */
+
+#ifdef HAVE_MULTIDRIVE
+int volume_drive(int volume);
+#else /* !HAVE_MULTIDRIVE */
+static inline int volume_drive(int volume)
+{
+    return 0;
+    (void)volume;
+}
+#endif /* HAVE_MULTIDRIVE */
+
 #endif /* __MV_H__ */
diff --git a/firmware/export/pathfuncs.h b/firmware/export/pathfuncs.h
new file mode 100644
index 0000000000..26eb4a1067
--- /dev/null
+++ b/firmware/export/pathfuncs.h
@@ -0,0 +1,100 @@
+/***************************************************************************
+ *             __________               __   ___.
+ *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
+ *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
+ *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
+ *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
+ *                     \/            \/     \/    \/            \/
+ * $Id$
+ *
+ * Copyright (C) 2014 by Michael Sevakis
+ *
+ * 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.
+ *
+ ****************************************************************************/
+#ifndef _PATHFUNCS_H_
+#define _PATHFUNCS_H_
+
+#include <sys/types.h>
+#define __need_size_t
+#include <stddef.h>
+#include <stdbool.h>
+#include "config.h"
+
+/* useful char constants that could be reconfigured if desired */
+#define PATH_SEPCH    '/'
+#define PATH_SEPSTR   "/"
+#define PATH_ROOTSTR  "/"
+#define PATH_BADSEPCH '\\'
+#define PATH_DRVSEPCH ':'
+
+/* a nicer way to check for "." and ".." than two strcmp() calls */
+static inline bool is_dotdir_name(const char *name)
+{
+    return name[0] == '.' && (!name[1] || (name[1] == '.' && !name[2]));
+}
+
+static inline bool name_is_dot(const char *name)
+{
+    return name[0] == '.' && !name[1];
+}
+
+static inline bool name_is_dot_dot(const char *name)
+{
+    return name[0] == '.' && name[1] == '.' && !name[2];
+}
+
+/* return a pointer to the character following path separators */
+#define GOBBLE_PATH_SEPCH(p) \
+    ({ int _c;                          \
+       const char *_p = (p);            \
+       while ((_c = *_p) == PATH_SEPCH) \
+            ++_p;                       \
+       _p; })
+
+/* return a pointer to the character following a path component which may
+   be a separator or the terminating nul */
+#define GOBBLE_PATH_COMP(p) \
+    ({ int _c;                                \
+       const char *_p = (p);                  \
+       while ((_c = *_p) && _c != PATH_SEPCH) \
+           ++_p;                              \
+       _p; })
+
+/* does the character terminate a path component? */
+#define IS_COMP_TERMINATOR(c) \
+    ({ int _c = (c);               \
+       !_c || _c == PATH_SEPCH; })
+
+#ifdef HAVE_MULTIVOLUME
+int path_strip_volume(const char *name, const char **nameptr, bool greedy);
+int get_volume_name(int volume, char *name);
+#endif
+
+int path_strip_drive(const char *name, const char **nameptr, bool greedy);
+size_t path_trim_whitespace(const char *name, const char **nameptr);
+size_t path_basename(const char *name, const char **nameptr);
+size_t path_dirname(const char *name, const char **nameptr);
+size_t path_strip_trailing_separators(const char *name, const char **nameptr);
+void path_correct_separators(char *dstpath, const char *path);
+
+/* constants useable in basepath and component */
+#define PA_SEP_HARD NULL /* separate even if base is empty */
+#define PA_SEP_SOFT ""   /* separate only if base is nonempty */
+size_t path_append(char *buffer, const char *basepath, const char *component,
+                   size_t bufsize);
+ssize_t parse_path_component(const char **pathp, const char **namep);
+
+/* return true if path begins with a root '/' component and is not NULL */
+static inline bool path_is_absolute(const char *path)
+{
+    return path && path[0] == PATH_SEPCH;
+}
+
+#endif /* _PATHFUNCS_H_ */
diff --git a/firmware/export/rbpaths.h b/firmware/export/rbpaths.h
index 3600709482..b04d669716 100644
--- a/firmware/export/rbpaths.h
+++ b/firmware/export/rbpaths.h
@@ -70,27 +70,6 @@
 
 #define HOME_DIR_LEN (sizeof(HOME_DIR)-1)
 
-#ifdef APPLICATION
-
-#include <dirent.h>
-#include <fcntl.h>
-#include <unistd.h>
-
-int app_open(const char *name, int o, ...);
-int app_creat(const char* name, mode_t mode);
-int app_remove(const char *name);
-int app_rename(const char *old, const char *new);
-DIR* app_opendir(const char *_name);
-int app_closedir(DIR *dir);
-struct dirent* app_readdir(DIR* dir);
-int app_mkdir(const char* name);
-int app_rmdir(const char* name);
-ssize_t app_readlink(const char *path, char *buf, size_t bufsiz);
-
-extern void paths_init(void);
-
-#endif
-
 #define REC_BASE_DIR        HOME_DIR
 #define PLAYLIST_CATALOG_DEFAULT_DIR HOME_DIR "/Playlists"
 
diff --git a/firmware/export/storage.h b/firmware/export/storage.h
index 8e7281d523..14cba09b35 100644
--- a/firmware/export/storage.h
+++ b/firmware/export/storage.h
@@ -93,6 +93,7 @@ static inline void stub_storage_spindown(int timeout) { (void)timeout; }
             #define storage_removable(drive) hostfs_removable(IF_MD(drive))
             #define storage_present(drive) hostfs_present(IF_MD(drive))
         #endif
+        #define storage_driver_type(drive) hostfs_driver_type(IF_MV(drive))
     #elif (CONFIG_STORAGE & STORAGE_ATA)
         #define STORAGE_FUNCTION(NAME) (ata_## NAME)
         #define storage_spindown ata_spindown
@@ -119,6 +120,7 @@ static inline void stub_storage_spindown(int timeout) { (void)timeout; }
             #define storage_removable(drive) ata_removable(IF_MD(drive))
             #define storage_present(drive) ata_present(IF_MD(drive))
         #endif
+        #define storage_driver_type(drive) (STORAGE_ATA_NUM)
     #elif (CONFIG_STORAGE & STORAGE_SD)
         #define STORAGE_FUNCTION(NAME) (sd_## NAME)
         #define storage_spindown sd_spindown
@@ -145,6 +147,7 @@ static inline void stub_storage_spindown(int timeout) { (void)timeout; }
             #define storage_removable(drive) sd_removable(IF_MD(drive))
             #define storage_present(drive) sd_present(IF_MD(drive))
         #endif
+        #define storage_driver_type(drive) (STORAGE_SD_NUM)
      #elif (CONFIG_STORAGE & STORAGE_MMC)
         #define STORAGE_FUNCTION(NAME) (mmc_## NAME)
         #define storage_spindown mmc_spindown
@@ -170,6 +173,7 @@ static inline void stub_storage_spindown(int timeout) { (void)timeout; }
             #define storage_removable(drive) mmc_removable(IF_MD(drive))
             #define storage_present(drive) mmc_present(IF_MD(drive))
         #endif
+        #define storage_driver_type(drive) (STORAGE_MMC_NUM)
     #elif (CONFIG_STORAGE & STORAGE_NAND)
         #define STORAGE_FUNCTION(NAME) (nand_## NAME)
         #define storage_spindown nand_spindown
@@ -195,6 +199,7 @@ static inline void stub_storage_spindown(int timeout) { (void)timeout; }
             #define storage_removable(drive) nand_removable(IF_MD(drive))
             #define storage_present(drive) nand_present(IF_MD(drive))
         #endif
+        #define storage_driver_type(drive) (STORAGE_NAND_NUM)
     #elif (CONFIG_STORAGE & STORAGE_RAMDISK)
         #define STORAGE_FUNCTION(NAME) (ramdisk_## NAME)
         #define storage_spindown ramdisk_spindown
@@ -220,6 +225,7 @@ static inline void stub_storage_spindown(int timeout) { (void)timeout; }
             #define storage_removable(drive) ramdisk_removable(IF_MD(drive))
             #define storage_present(drive) ramdisk_present(IF_MD(drive))
         #endif
+        #define storage_driver_type(drive) (STORAGE_RAMDISK_NUM)
     #else
         //#error No storage driver!
     #endif
@@ -246,6 +252,7 @@ void storage_get_info(int drive, struct storage_info *info);
 bool storage_removable(int drive);
 bool storage_present(int drive);
 #endif
+int storage_driver_type(int drive);
 
 #endif /* NOT CONFIG_STORAGE_MULTI and NOT SIMULATOR*/
 
diff --git a/firmware/export/system.h b/firmware/export/system.h
index 4442eb96d7..47dd858d81 100644
--- a/firmware/export/system.h
+++ b/firmware/export/system.h
@@ -104,6 +104,10 @@ int get_cpu_boost_counter(void);
 /* return number of elements in array a */
 #define ARRAYLEN(a) (sizeof(a)/sizeof((a)[0]))
 
+/* is the given pointer "p" inside the said bounds of array "a"? */
+#define PTR_IN_ARRAY(a, p, numelem) \
+    ((uintptr_t)(p) - (uintptr_t)(a) < (uintptr_t)(numelem)*sizeof ((a)[0]))
+
 /* return p incremented by specified number of bytes */
 #define SKIPBYTES(p, count) ((typeof (p))((char *)(p) + (count)))
 
@@ -188,9 +192,13 @@ enum {
 #include "system-target.h"
 #elif defined(HAVE_SDL) /* SDL build */
 #include "system-sdl.h"
+#ifdef SIMULATOR
+#include "system-sim.h"
+#endif
 #elif defined(__PCTOOL__)
-#include "system-sdl.h"
+#include "system-hosted.h"
 #endif
+
 #include "bitswap.h"
 #include "rbendian.h"