FAT fs changes: FAT code and larger ROM size

	. add fatfs umon cli to it. unmodified from the umon 1.19
	  distribution, apache-licensed.
	. also add dosfs from the umon 1.19 distribution, which is
	  similarly liberally licensed.
	. increase available 'ROM' size to 128kB minus
	  1kB secure + 18kB reserved (numbers from uboot wiki).
	. no unaligned access - needed to access fields in
	  on-disk structs without gcc generating unaligned
	  access instructions (causes data abort exceptions)
	. turn on shellvars for BBB as they are needed to
	  connect FATFS to the SD i/o functions

5 files changed, 2420 insertions, 4 deletions

diff --git a/main/common/dosfs.c b/main/common/dosfs.c
new file mode 100644
index 0000000..e49fb73
--- /dev/null
+++ b/main/common/dosfs.c
@@ -0,0 +1,1326 @@
+/*
+	DOSFS Embedded FAT-Compatible Filesystem
+	(C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com)
+
+	You are permitted to modify and/or use this code in your own projects without
+	payment of royalty, regardless of the license(s) you choose for those projects.
+
+	You cannot re-copyright or restrict use of the code as released by Lewin Edwards.
+
+	Modifications: Aug 2006 (esutter/ghenderson)
+		Initial integration into uMon source tree.
+		Eliminated a few precedence warnings by adding parenthesis.
+		Eliminated one "variable unused" warning.
+	Modifications: Sept 2006 (ghenderson)
+		Added DFS_DirToCanonical.
+		All structures in dosfs.h have been defined with the
+			__attribute__ ((__packed__)).
+		Added macros in dosfs.h to help in formating time,
+			date, and filesize.
+	Modifications: Sept 25, 2006 (esutter)
+		Updated to dosfs-1.02 (dated Sept 16, 2006).
+	Modifications: Oct 2, 2006 (esutter)
+		Updated to dosfs-1.03 (dated Sept 30, 2006).
+		Incorporate fix from Graham Henderson (see USE_GMHFIX)
+*/
+#include "config.h"
+
+#if INCLUDE_FATFS
+#include "genlib.h"
+#include "dosfs.h"
+
+#define memcpy(a,b,c) memcpy((char *)a, (char *)b,(int)c)
+#define memset(a,b,c) memset((char *)a, (char)b,(int)c)
+#define memcmp(a,b,c) memcmp((char *)a, (char *)b,(int)c)
+
+/*
+	Get starting sector# of specified partition on drive #unit
+	NOTE: This code ASSUMES an MBR on the disk.
+	scratchsector should point to a SECTOR_SIZE scratch area
+	Returns 0xffffffff for any error.
+	If pactive is non-NULL, this function also returns the partition active flag.
+	If pptype is non-NULL, this function also returns the partition type.
+	If psize is non-NULL, this function also returns the partition size.
+*/
+uint32_t DFS_GetPtnStart(uint8_t unit, uint8_t *scratchsector, uint8_t pnum, uint8_t *pactive, uint8_t *pptype, uint32_t *psize)
+{
+	uint32_t result;
+	PMBR mbr = (PMBR) scratchsector;
+
+	// DOS ptable supports maximum 4 partitions
+	if (pnum > 3)
+		return DFS_ERRMISC;
+
+	// Read MBR from target media
+	if (DFS_ReadSector(unit,scratchsector,0,1)) {
+		return DFS_ERRMISC;
+	}
+
+	result = (uint32_t) mbr->ptable[pnum].start_0 |
+	  (((uint32_t) mbr->ptable[pnum].start_1) << 8) |
+	  (((uint32_t) mbr->ptable[pnum].start_2) << 16) |
+	  (((uint32_t) mbr->ptable[pnum].start_3) << 24);
+
+	if (pactive)
+		*pactive = mbr->ptable[pnum].active;
+
+	if (pptype)
+		*pptype = mbr->ptable[pnum].type;
+
+	if (psize)
+		*psize = (uint32_t) mbr->ptable[pnum].size_0 |
+		  (((uint32_t) mbr->ptable[pnum].size_1) << 8) |
+		  (((uint32_t) mbr->ptable[pnum].size_2) << 16) |
+		  (((uint32_t) mbr->ptable[pnum].size_3) << 24);
+
+	return result;
+}
+
+
+/*
+	Retrieve volume info from BPB and store it in a VOLINFO structure
+	You must provide the unit and starting sector of the filesystem, and
+	a pointer to a sector buffer for scratch
+	Attempts to read BPB and glean information about the FS from that.
+	Returns 0 OK, nonzero for any error.
+*/
+uint32_t DFS_GetVolInfo(uint8_t unit, uint8_t *scratchsector, uint32_t startsector, PVOLINFO volinfo)
+{
+	PLBR lbr = (PLBR) scratchsector;
+	volinfo->unit = unit;
+	volinfo->startsector = startsector;
+
+	if(DFS_ReadSector(unit,scratchsector,startsector,1))
+		return DFS_ERRMISC;
+
+// tag: OEMID, refer dosfs.h
+//	strncpy(volinfo->oemid, lbr->oemid, 8);
+//	volinfo->oemid[8] = 0;
+
+	volinfo->secperclus = lbr->bpb.secperclus;
+	volinfo->reservedsecs = (uint16_t) lbr->bpb.reserved_l |
+		  (((uint16_t) lbr->bpb.reserved_h) << 8);
+
+	volinfo->numsecs =  (uint16_t) lbr->bpb.sectors_s_l |
+		  (((uint16_t) lbr->bpb.sectors_s_h) << 8);
+
+	if (!volinfo->numsecs)
+		volinfo->numsecs = (uint32_t) lbr->bpb.sectors_l_0 |
+		  (((uint32_t) lbr->bpb.sectors_l_1) << 8) |
+		  (((uint32_t) lbr->bpb.sectors_l_2) << 16) |
+		  (((uint32_t) lbr->bpb.sectors_l_3) << 24);
+
+	// If secperfat is 0, we must be in a FAT32 volume; get secperfat
+	// from the FAT32 EBPB. The volume label and system ID string are also
+	// in different locations for FAT12/16 vs FAT32.
+	volinfo->secperfat =  (uint16_t) lbr->bpb.secperfat_l |
+		  (((uint16_t) lbr->bpb.secperfat_h) << 8);
+	if (!volinfo->secperfat) {
+		volinfo->secperfat = (uint32_t) lbr->ebpb.ebpb32.fatsize_0 |
+		  (((uint32_t) lbr->ebpb.ebpb32.fatsize_1) << 8) |
+		  (((uint32_t) lbr->ebpb.ebpb32.fatsize_2) << 16) |
+		  (((uint32_t) lbr->ebpb.ebpb32.fatsize_3) << 24);
+
+		memcpy(volinfo->label, lbr->ebpb.ebpb32.label, 11);
+		volinfo->label[11] = 0;
+	
+// tag: OEMID, refer dosfs.h
+//		memcpy(volinfo->system, lbr->ebpb.ebpb32.system, 8);
+//		volinfo->system[8] = 0; 
+	}
+	else {
+		memcpy(volinfo->label, lbr->ebpb.ebpb.label, 11);
+		volinfo->label[11] = 0;
+	
+// tag: OEMID, refer dosfs.h
+//		memcpy(volinfo->system, lbr->ebpb.ebpb.system, 8);
+//		volinfo->system[8] = 0; 
+	}
+
+	// note: if rootentries is 0, we must be in a FAT32 volume.
+	volinfo->rootentries =  (uint16_t) lbr->bpb.rootentries_l |
+		  (((uint16_t) lbr->bpb.rootentries_h) << 8);
+
+	// after extracting raw info we perform some useful precalculations
+	volinfo->fat1 = startsector + volinfo->reservedsecs;
+
+	// The calculation below is designed to round up the root directory size for FAT12/16
+	// and to simply ignore the root directory for FAT32, since it's a normal, expandable
+	// file in that situation.
+	if (volinfo->rootentries) {
+		volinfo->rootdir = volinfo->fat1 + (volinfo->secperfat * 2);
+		volinfo->dataarea = volinfo->rootdir + (((volinfo->rootentries * 32) + (SECTOR_SIZE - 1)) / SECTOR_SIZE);
+	}
+	else {
+		volinfo->dataarea = volinfo->fat1 + (volinfo->secperfat * 2);
+		volinfo->rootdir = (uint32_t) lbr->ebpb.ebpb32.root_0 |
+		  (((uint32_t) lbr->ebpb.ebpb32.root_1) << 8) |
+		  (((uint32_t) lbr->ebpb.ebpb32.root_2) << 16) |
+		  (((uint32_t) lbr->ebpb.ebpb32.root_3) << 24);
+	}
+
+	// Calculate number of clusters in data area and infer FAT type from this information.
+	volinfo->numclusters = (volinfo->numsecs - volinfo->dataarea) / volinfo->secperclus;
+	if (volinfo->numclusters < 4085)
+		volinfo->filesystem = FAT12;
+	else if (volinfo->numclusters < 65525)
+		volinfo->filesystem = FAT16;
+	else
+		volinfo->filesystem = FAT32;
+
+	return DFS_OK;
+}
+
+/*
+	Fetch FAT entry for specified cluster number
+	You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO
+	Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired
+	FAT entry.
+	scratchcache should point to a UINT32. This variable caches the physical sector number
+	last read into the scratch buffer for performance enhancement reasons.
+*/
+uint32_t DFS_GetFAT(PVOLINFO volinfo, uint8_t *scratch, uint32_t *scratchcache, uint32_t cluster)
+{
+	uint32_t offset, sector, result;
+
+	if (volinfo->filesystem == FAT12) {
+		offset = cluster + (cluster / 2);
+	}
+	else if (volinfo->filesystem == FAT16) {
+		offset = cluster * 2;
+	}
+	else if (volinfo->filesystem == FAT32) {
+		offset = cluster * 4;
+	}
+	else
+		return 0x0ffffff7;	// FAT32 bad cluster	
+
+	// at this point, offset is the BYTE offset of the desired sector from the start
+	// of the FAT. Calculate the physical sector containing this FAT entry.
+	sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1;
+
+	// If this is not the same sector we last read, then read it into RAM
+	if (sector != *scratchcache) {
+		if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
+			// avoid anyone assuming that this cache value is still valid, which
+			// might cause disk corruption
+			*scratchcache = 0;
+			return 0x0ffffff7;	// FAT32 bad cluster	
+		}
+		*scratchcache = sector;
+	}
+
+	// At this point, we "merely" need to extract the relevant entry.
+	// This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry
+	// may span a sector boundary. The normal way around this is always to read two
+	// FAT sectors, but that luxury is (by design intent) unavailable to DOSFS.
+	offset = ldiv(offset, SECTOR_SIZE).rem;
+
+	if (volinfo->filesystem == FAT12) {
+		// Special case for sector boundary - Store last byte of current sector.
+		// Then read in the next sector and put the first byte of that sector into
+		// the high byte of result.
+		if (offset == SECTOR_SIZE - 1) {
+			result = (uint32_t) scratch[offset];
+			sector++;
+			if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
+				// avoid anyone assuming that this cache value is still valid, which
+				// might cause disk corruption
+				*scratchcache = 0;
+				return 0x0ffffff7;	// FAT32 bad cluster	
+			}
+			*scratchcache = sector;
+			// Thanks to Claudio Leonel for pointing out this missing line.
+			result |= ((uint32_t) scratch[0]) << 8;
+		}
+		else {
+			result = (uint32_t) scratch[offset] |
+			  ((uint32_t) scratch[offset+1]) << 8;
+		}
+		if (cluster & 1)
+			result = result >> 4;
+		else
+			result = result & 0xfff;
+	}
+	else if (volinfo->filesystem == FAT16) {
+		result = (uint32_t) scratch[offset] |
+		  ((uint32_t) scratch[offset+1]) << 8;
+	}
+	else if (volinfo->filesystem == FAT32) {
+		result = ((uint32_t) scratch[offset] |
+		  ((uint32_t) scratch[offset+1]) << 8 |
+		  ((uint32_t) scratch[offset+2]) << 16 |
+		  ((uint32_t) scratch[offset+3]) << 24) & 0x0fffffff;
+	}
+	else
+		result = 0x0ffffff7;	// FAT32 bad cluster	
+	return result;
+}
+
+
+/*
+	Set FAT entry for specified cluster number
+	You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO
+	Returns DFS_ERRMISC for any error, otherwise DFS_OK
+	scratchcache should point to a UINT32. This variable caches the physical sector number
+	last read into the scratch buffer for performance enhancement reasons.
+
+	NOTE: This code is HIGHLY WRITE-INEFFICIENT, particularly for flash media. Considerable
+	performance gains can be realized by caching the sector. However this is difficult to
+	achieve on FAT12 without requiring 2 sector buffers of scratch space, and it is a design
+	requirement of this code to operate on a single 512-byte scratch.
+
+	If you are operating DOSFS over flash, you are strongly advised to implement a writeback
+	cache in your physical I/O driver. This will speed up your code significantly and will
+	also conserve power and flash write life.
+*/
+uint32_t DFS_SetFAT(PVOLINFO volinfo, uint8_t *scratch, uint32_t *scratchcache, uint32_t cluster, uint32_t new_contents)
+{
+	uint32_t offset, sector, result;
+	if (volinfo->filesystem == FAT12) {
+		offset = cluster + (cluster / 2);
+		new_contents &=0xfff;
+	}
+	else if (volinfo->filesystem == FAT16) {
+		offset = cluster * 2;
+		new_contents &=0xffff;
+	}
+	else if (volinfo->filesystem == FAT32) {
+		offset = cluster * 4;
+		new_contents &=0x0fffffff;	// FAT32 is really "FAT28"
+	}
+	else
+		return DFS_ERRMISC;	
+
+	// at this point, offset is the BYTE offset of the desired sector from the start
+	// of the FAT. Calculate the physical sector containing this FAT entry.
+	sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1;
+
+	// If this is not the same sector we last read, then read it into RAM
+	if (sector != *scratchcache) {
+		if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
+			// avoid anyone assuming that this cache value is still valid, which
+			// might cause disk corruption
+			*scratchcache = 0;
+			return DFS_ERRMISC;
+		}
+		*scratchcache = sector;
+	}
+
+	// At this point, we "merely" need to extract the relevant entry.
+	// This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry
+	// may span a sector boundary. The normal way around this is always to read two
+	// FAT sectors, but that luxury is (by design intent) unavailable to DOSFS.
+	offset = ldiv(offset, SECTOR_SIZE).rem;
+
+	if (volinfo->filesystem == FAT12) {
+
+		// If this is an odd cluster, pre-shift the desired new contents 4 bits to
+		// make the calculations below simpler
+		if (cluster & 1)
+			new_contents = new_contents << 4;
+
+		// Special case for sector boundary
+		if (offset == SECTOR_SIZE - 1) {
+
+			// Odd cluster: High 12 bits being set
+			if (cluster & 1) {
+				scratch[offset] = (scratch[offset] & 0x0f) | (new_contents & 0xf0);
+			}
+			// Even cluster: Low 12 bits being set
+			else {
+				scratch[offset] = new_contents & 0xff;
+			}
+			result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
+			// mirror the FAT into copy 2
+			if (DFS_OK == result)
+				result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
+
+			// If we wrote that sector OK, then read in the subsequent sector
+			// and poke the first byte with the remainder of this FAT entry.
+			if (DFS_OK == result) {
+#if 0
+				/* ELSNOTE:
+				 * Original line here is illegal (IMHO).  Didn't notice this
+				 * till I used a version of GCC that warned me about it.
+				 * I changed this to eliminate the warning, and *hopefully*
+				 * generate the correct code.  Have not been able to test this.
+				 */
+				*scratchcache++;
+#else
+				(*scratchcache)++;
+#endif
+				result = DFS_ReadSector(volinfo->unit, scratch, *scratchcache, 1);
+				if (DFS_OK == result) {
+					// Odd cluster: High 12 bits being set
+					if (cluster & 1) {
+						scratch[0] = new_contents & 0xff00;
+					}
+					// Even cluster: Low 12 bits being set
+					else {
+						scratch[0] = (scratch[0] & 0xf0) | (new_contents & 0x0f);
+					}
+					result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
+					// mirror the FAT into copy 2
+					if (DFS_OK == result)
+						result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
+				}
+				else {
+					// avoid anyone assuming that this cache value is still valid, which
+					// might cause disk corruption
+					*scratchcache = 0;
+				}
+			}
+		} // if (offset == SECTOR_SIZE - 1)
+
+		// Not a sector boundary. But we still have to worry about if it's an odd
+		// or even cluster number.
+		else {
+			// Odd cluster: High 12 bits being set
+			if (cluster & 1) {
+				scratch[offset] = (scratch[offset] & 0x0f) | (new_contents & 0xf0);
+				scratch[offset+1] = new_contents & 0xff00;
+			}
+			// Even cluster: Low 12 bits being set
+			else {
+				scratch[offset] = new_contents & 0xff;
+				scratch[offset+1] = (scratch[offset+1] & 0xf0) | (new_contents & 0x0f);
+			}
+			result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
+			// mirror the FAT into copy 2
+			if (DFS_OK == result)
+				result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
+		}
+	}
+	else if (volinfo->filesystem == FAT16) {
+		scratch[offset] = (new_contents & 0xff);
+		scratch[offset+1] = (new_contents & 0xff00) >> 8;
+		result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
+		// mirror the FAT into copy 2
+		if (DFS_OK == result)
+			result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
+	}
+	else if (volinfo->filesystem == FAT32) {
+		scratch[offset] = (new_contents & 0xff);
+		scratch[offset+1] = (new_contents & 0xff00) >> 8;
+		scratch[offset+2] = (new_contents & 0xff0000) >> 16;
+		scratch[offset+3] = (scratch[offset+3] & 0xf0) | ((new_contents & 0x0f000000) >> 24);
+		// Note well from the above: Per Microsoft's guidelines we preserve the upper
+		// 4 bits of the FAT32 cluster value. It's unclear what these bits will be used
+		// for; in every example I've encountered they are always zero.
+		result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
+		// mirror the FAT into copy 2
+		if (DFS_OK == result)
+			result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
+	}
+	else
+		result = DFS_ERRMISC;
+
+	return result;
+}
+
+/*
+	Convert a filename element from canonical (8.3) to directory entry (11) form
+	src must point to the first non-separator character.
+	dest must point to a 12-byte buffer.
+*/
+uint8_t *DFS_CanonicalToDir(uint8_t *dest, uint8_t *src)
+{
+	uint8_t *destptr = dest;
+
+	memset(dest, ' ', 11);
+	dest[11] = 0;
+
+	while (*src && (*src != DIR_SEPARATOR) && (destptr - dest < 11)) {
+		if (*src >= 'a' && *src <='z') {
+			*destptr++ = (*src - 'a') + 'A';
+			src++;
+		}
+		else if (*src == '.') {
+			src++;
+			destptr = dest + 8;
+		}
+		else {
+			*destptr++ = *src++;
+		}
+	}
+
+	return dest;
+}
+
+/*
+	Find the first unused FAT entry
+	You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO
+	Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired
+	FAT entry.
+	Returns FAT32 bad_sector (0x0ffffff7) if there is no free cluster available
+*/
+uint32_t DFS_GetFreeFAT(PVOLINFO volinfo, uint8_t *scratch)
+{
+	uint32_t i, result = 0xffffffff, scratchcache = 0;
+	
+	// Search starts at cluster 2, which is the first usable cluster
+	// NOTE: This search can't terminate at a bad cluster, because there might
+	// legitimately be bad clusters on the disk.
+	for (i=2; i < volinfo->numclusters; i++) {
+		result = DFS_GetFAT(volinfo, scratch, &scratchcache, i);
+		if (!result) {
+			return i;
+		}
+	}
+	return 0x0ffffff7;		// Can't find a free cluster
+}
+
+
+/*
+	Open a directory for enumeration by DFS_GetNextDirEnt
+	You must supply a populated VOLINFO (see DFS_GetVolInfo)
+	The empty string or a string containing only the directory separator are
+	considered to be the root directory.
+	Returns 0 OK, nonzero for any error.
+*/
+uint32_t DFS_OpenDir(PVOLINFO volinfo, uint8_t *dirname, PDIRINFO dirinfo)
+{
+	// Default behavior is a regular search for existing entries
+	dirinfo->flags = 0;
+
+	if (!strlen((char *) dirname) || (strlen((char *) dirname) == 1 && dirname[0] == DIR_SEPARATOR)) {
+		if (volinfo->filesystem == FAT32) {
+			dirinfo->currentcluster = volinfo->rootdir;
+			dirinfo->currentsector = 0;
+			dirinfo->currententry = 0;
+
+			// read first sector of directory
+			return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1);
+		}
+		else {
+			dirinfo->currentcluster = 0;
+			dirinfo->currentsector = 0;
+			dirinfo->currententry = 0;
+
+			// read first sector of directory
+			return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1);
+		}
+	}
+
+	// This is not the root directory. We need to find the start of this subdirectory.
+	// We do this by devious means, using our own companion function DFS_GetNext.
+	else {
+		uint8_t tmpfn[12];
+		uint8_t *ptr = dirname;
+		uint32_t result;
+		DIRENT de;
+
+		if (volinfo->filesystem == FAT32) {
+			dirinfo->currentcluster = volinfo->rootdir;
+			dirinfo->currentsector = 0;
+			dirinfo->currententry = 0;
+
+			// read first sector of directory
+			if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1))
+				return DFS_ERRMISC;
+		}
+		else {
+			dirinfo->currentcluster = 0;
+			dirinfo->currentsector = 0;
+			dirinfo->currententry = 0;
+
+			// read first sector of directory
+			if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1))
+				return DFS_ERRMISC;
+		}
+
+		// skip leading path separators
+		while (*ptr == DIR_SEPARATOR && *ptr)
+			ptr++;
+
+		// Scan the path from left to right, finding the start cluster of each entry
+		// Observe that this code is inelegant, but obviates the need for recursion.
+		while (*ptr) {
+			DFS_CanonicalToDir(tmpfn, ptr);
+
+			de.name[0] = 0;
+
+			do {
+				result = DFS_GetNext(volinfo, dirinfo, &de);
+			} while (!result && memcmp(de.name, tmpfn, 11));
+
+			if (!memcmp(de.name, tmpfn, 11) && ((de.attr & ATTR_DIRECTORY) == ATTR_DIRECTORY)) {
+				if (volinfo->filesystem == FAT32) {
+					dirinfo->currentcluster = (uint32_t) de.startclus_l_l |
+					  ((uint32_t) de.startclus_l_h) << 8 |
+					  ((uint32_t) de.startclus_h_l) << 16 |
+					  ((uint32_t) de.startclus_h_h) << 24;
+				}
+				else {
+					dirinfo->currentcluster = (uint32_t) de.startclus_l_l |
+					  ((uint32_t) de.startclus_l_h) << 8;
+				}
+				dirinfo->currentsector = 0;
+				dirinfo->currententry = 0;
+
+				if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus), 1))
+					return DFS_ERRMISC;
+			}
+			else if (!memcmp(de.name, tmpfn, 11) && !(de.attr & ATTR_DIRECTORY))
+				return DFS_NOTFOUND;
+
+			// seek to next item in list
+			while (*ptr != DIR_SEPARATOR && *ptr)
+				ptr++;
+			if (*ptr == DIR_SEPARATOR)
+				ptr++;
+		}
+
+		if (!dirinfo->currentcluster)
+			return DFS_NOTFOUND;
+	}
+	return DFS_OK;
+}
+
+/*
+	Get next entry in opened directory structure. Copies fields into the dirent
+	structure, updates dirinfo. Note that it is the _caller's_ responsibility to
+	handle the '.' and '..' entries.
+	A deleted file will be returned as a NULL entry (first char of filename=0)
+	by this code. Filenames beginning with 0x05 will be translated to 0xE5
+	automatically. Long file name entries will be returned as NULL.
+	returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid,
+	or DFS_ERRMISC for a media error
+*/
+uint32_t DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent)
+{
+	uint32_t tempint;	// required by DFS_GetFAT
+
+	// Do we need to read the next sector of the directory?
+	if (dirinfo->currententry >= SECTOR_SIZE / sizeof(DIRENT)) {
+		dirinfo->currententry = 0;
+		dirinfo->currentsector++;
+
+		// Root directory; special case handling 
+		// Note that currentcluster will only ever be zero if both:
+		// (a) this is the root directory, and
+		// (b) we are on a FAT12/16 volume, where the root dir can't be expanded
+		if (dirinfo->currentcluster == 0) {
+			// Trying to read past end of root directory?
+			if (dirinfo->currentsector * (SECTOR_SIZE / sizeof(DIRENT)) >= volinfo->rootentries)
+				return DFS_EOF;
+
+			// Otherwise try to read the next sector
+			if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir + dirinfo->currentsector, 1))
+				return DFS_ERRMISC;
+		}
+
+		// Normal handling
+		else {
+			if (dirinfo->currentsector >= volinfo->secperclus) {
+				dirinfo->currentsector = 0;
+				if ((dirinfo->currentcluster >= 0xff7 &&  volinfo->filesystem == FAT12) ||
+				  (dirinfo->currentcluster >= 0xfff7 &&  volinfo->filesystem == FAT16) ||
+				  (dirinfo->currentcluster >= 0x0ffffff7 &&  volinfo->filesystem == FAT32)) {
+				  
+				  	// We are at the end of the directory chain. If this is a normal
+				  	// find operation, we should indicate that there is nothing more
+				  	// to see.
+				  	if (!(dirinfo->flags & DFS_DI_BLANKENT))
+						return DFS_EOF;
+					
+					// On the other hand, if this is a "find free entry" search,
+					// we need to tell the caller to allocate a new cluster
+					else
+						return DFS_ALLOCNEW;
+				}
+				dirinfo->currentcluster = DFS_GetFAT(volinfo, dirinfo->scratch, &tempint, dirinfo->currentcluster);
+			}
+			if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus) + dirinfo->currentsector, 1))
+				return DFS_ERRMISC;
+		}
+	}
+
+	memcpy(dirent, &(((PDIRENT) dirinfo->scratch)[dirinfo->currententry]), sizeof(DIRENT));
+
+	if (dirent->name[0] == 0) {		// no more files in this directory
+		// If this is a "find blank" then we can reuse this name.
+		if (dirinfo->flags & DFS_DI_BLANKENT)
+			return DFS_OK;
+		else
+			return DFS_EOF;
+	}
+
+	if (dirent->name[0] == 0xe5)	// handle deleted file entries
+		dirent->name[0] = 0;
+	else if ((dirent->attr & ATTR_LONG_NAME) == ATTR_LONG_NAME)
+		dirent->name[0] = 0;
+	else if (dirent->name[0] == 0x05)	// handle kanji filenames beginning with 0xE5
+		dirent->name[0] = 0xe5;
+
+	dirinfo->currententry++;
+
+	return DFS_OK;
+}
+
+/*
+	INTERNAL
+	Find a free directory entry in the directory specified by path
+	This function MAY cause a disk write if it is necessary to extend the directory
+	size.
+	Note - di.scratch must be preinitialized to point to a sector scratch buffer
+	de is a scratch structure
+	Returns DFS_ERRMISC if a new entry could not be located or created
+	de is updated with the same return information you would expect from DFS_GetNext
+*/
+uint32_t DFS_GetFreeDirEnt(PVOLINFO volinfo, uint8_t *path, PDIRINFO di, PDIRENT de)
+{
+	uint32_t tempclus,i;
+
+	if (DFS_OpenDir(volinfo, path, di))
+		return DFS_NOTFOUND;
+
+	// Set "search for empty" flag so DFS_GetNext knows what we're doing
+	di->flags |= DFS_DI_BLANKENT;
+
+	// We seek through the directory looking for an empty entry
+	// Note we are reusing tempclus as a temporary result holder.
+	tempclus = 0;	
+	do {
+		tempclus = DFS_GetNext(volinfo, di, de);
+
+		// Empty entry found
+		if (tempclus == DFS_OK && (!de->name[0])) {
+			return DFS_OK;
+		}
+
+		// End of root directory reached
+		else if (tempclus == DFS_EOF)
+			return DFS_ERRMISC;
+			
+		else if (tempclus == DFS_ALLOCNEW) {
+			tempclus = DFS_GetFreeFAT(volinfo, di->scratch);
+			if (tempclus == 0x0ffffff7)
+				return DFS_ERRMISC;
+
+			// write out zeroed sectors to the new cluster
+			memset(di->scratch, 0, SECTOR_SIZE);
+			for (i=0;i<volinfo->secperclus;i++) {
+				if (DFS_WriteSector(volinfo->unit, di->scratch, volinfo->dataarea + ((tempclus - 2) * volinfo->secperclus) + i, 1))
+					return DFS_ERRMISC;
+			}
+			// Point old end cluster to newly allocated cluster
+			i = 0;
+			DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus);
+
+			// Update DIRINFO so caller knows where to place the new file			
+			di->currentcluster = tempclus;
+			di->currentsector = 0;
+			di->currententry = 1;	// since the code coming after this expects to subtract 1
+			
+			// Mark newly allocated cluster as end of chain			
+			switch(volinfo->filesystem) {
+				case FAT12:		tempclus = 0xff8;	break;
+				case FAT16:		tempclus = 0xfff8;	break;
+				case FAT32:		tempclus = 0x0ffffff8;	break;
+				default:		return DFS_ERRMISC;
+			}
+			DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus);
+		}
+	} while (!tempclus);
+
+	// We shouldn't get here
+	return DFS_ERRMISC;
+}
+
+/*
+	Open a file for reading or writing. You supply populated VOLINFO, a path to the file,
+	mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to
+	provide a pointer to a sector-sized scratch buffer.
+	Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used
+	to access the file from this point on.
+*/
+uint32_t DFS_OpenFile(PVOLINFO volinfo, uint8_t *path, uint8_t mode, uint8_t *scratch, PFILEINFO fileinfo)
+{
+	uint8_t tmppath[MAX_PATH];
+	uint8_t filename[12];
+	uint8_t *p;
+	DIRINFO di;
+	DIRENT de;
+
+	// larwe 2006-09-16 +1 zero out file structure
+	memset(fileinfo, 0, sizeof(FILEINFO));
+
+	// save access mode
+	fileinfo->mode = mode;
+
+	// Get a local copy of the path. If it's longer than MAX_PATH, abort.
+	strncpy((char *) tmppath, (char *) path, MAX_PATH);
+	tmppath[MAX_PATH - 1] = 0;
+	if (strcmp((char *) path,(char *) tmppath)) {
+		return DFS_PATHLEN;
+	}
+
+	// strip leading path separators
+	while (tmppath[0] == DIR_SEPARATOR)
+		strcpy((char *) tmppath, (char *) tmppath + 1);
+
+	// Parse filename off the end of the supplied path
+	p = tmppath;
+	while (*(p++));
+
+	p--;
+	while (p > tmppath && *p != DIR_SEPARATOR) // larwe 9/16/06 ">=" to ">" bugfix
+		p--;
+	if (*p == DIR_SEPARATOR)
+		p++;
+
+	DFS_CanonicalToDir(filename, p);
+
+	if (p > tmppath)
+		p--;
+	if (*p == DIR_SEPARATOR || p == tmppath) // larwe 9/16/06 +"|| p == tmppath" bugfix
+		*p = 0;
+
+	// At this point, if our path was MYDIR/MYDIR2/FILE.EXT, filename = "FILE    EXT" and
+	// tmppath = "MYDIR/MYDIR2".
+	di.scratch = scratch;
+	if (DFS_OpenDir(volinfo, tmppath, &di))
+		return DFS_NOTFOUND;
+
+	while (!DFS_GetNext(volinfo, &di, &de)) {
+		if (!memcmp(de.name, filename, 11)) {
+			// You can't use this function call to open a directory.
+			if (de.attr & ATTR_DIRECTORY)
+				return DFS_NOTFOUND;
+
+			fileinfo->volinfo = volinfo;
+			fileinfo->pointer = 0;
+			// The reason we store this extra info about the file is so that we can
+			// speedily update the file size, modification date, etc. on a file that is
+			// opened for writing.
+			if (di.currentcluster == 0)
+				fileinfo->dirsector = volinfo->rootdir + di.currentsector;
+			else
+				fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector;
+			fileinfo->diroffset = di.currententry - 1;
+			if (volinfo->filesystem == FAT32) {
+				fileinfo->cluster = (uint32_t) de.startclus_l_l |
+				  ((uint32_t) de.startclus_l_h) << 8 |
+				  ((uint32_t) de.startclus_h_l) << 16 |
+				  ((uint32_t) de.startclus_h_h) << 24;
+			}
+			else {
+				fileinfo->cluster = (uint32_t) de.startclus_l_l |
+				  ((uint32_t) de.startclus_l_h) << 8;
+			}
+			fileinfo->firstcluster = fileinfo->cluster;
+			fileinfo->filelen = (uint32_t) de.filesize_0 |
+			  ((uint32_t) de.filesize_1) << 8 |
+			  ((uint32_t) de.filesize_2) << 16 |
+			  ((uint32_t) de.filesize_3) << 24;
+
+			return DFS_OK;
+		}
+	}
+
+	// At this point, we KNOW the file does not exist. If the file was opened
+	// with write access, we can create it.
+	if (mode & DFS_WRITE) {
+		uint32_t cluster, temp;
+
+		// Locate or create a directory entry for this file
+		if (DFS_OK != DFS_GetFreeDirEnt(volinfo, tmppath, &di, &de))
+			return DFS_ERRMISC;
+
+		// put sane values in the directory entry
+		memset(&de, 0, sizeof(de));
+		memcpy(de.name, filename, 11);
+		de.crttime_l = 0x20;	// 01:01:00am, Jan 1, 2006.
+		de.crttime_h = 0x08;
+		de.crtdate_l = 0x11;
+		de.crtdate_h = 0x34;
+		de.lstaccdate_l = 0x11;
+		de.lstaccdate_h = 0x34;
+		de.wrttime_l = 0x20;
+		de.wrttime_h = 0x08;
+		de.wrtdate_l = 0x11;
+		de.wrtdate_h = 0x34;
+
+		// allocate a starting cluster for the directory entry
+		cluster = DFS_GetFreeFAT(volinfo, scratch);
+
+		de.startclus_l_l = cluster & 0xff;
+		de.startclus_l_h = (cluster & 0xff00) >> 8;
+		de.startclus_h_l = (cluster & 0xff0000) >> 16;
+		de.startclus_h_h = (cluster & 0xff000000) >> 24;
+
+		// update FILEINFO for our caller's sake
+		fileinfo->volinfo = volinfo;
+		fileinfo->pointer = 0;
+		// The reason we store this extra info about the file is so that we can
+		// speedily update the file size, modification date, etc. on a file that is
+		// opened for writing.
+		if (di.currentcluster == 0)
+			fileinfo->dirsector = volinfo->rootdir + di.currentsector;
+		else
+			fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector;
+#ifdef USE_GMHFIX
+		fileinfo->diroffset = di.currententry;
+#else
+		fileinfo->diroffset = di.currententry - 1;
+#endif
+		fileinfo->cluster = cluster;
+		fileinfo->firstcluster = cluster;
+		fileinfo->filelen = 0;
+		
+		// write the directory entry
+		// note that we no longer have the sector containing the directory entry,
+		// tragically, so we have to re-read it
+		if (DFS_ReadSector(volinfo->unit, scratch, fileinfo->dirsector, 1))
+			return DFS_ERRMISC;
+#ifdef USE_GMHFIX
+		memcpy(&(((PDIRENT) scratch)[di.currententry]), &de, sizeof(DIRENT));
+#else
+		memcpy(&(((PDIRENT) scratch)[di.currententry-1]), &de, sizeof(DIRENT));
+#endif
+		if (DFS_WriteSector(volinfo->unit, scratch, fileinfo->dirsector, 1))
+			return DFS_ERRMISC;
+
+		// Mark newly allocated cluster as end of chain			
+		switch(volinfo->filesystem) {
+			case FAT12:		cluster = 0xff8;	break;
+			case FAT16:		cluster = 0xfff8;	break;
+			case FAT32:		cluster = 0x0ffffff8;	break;
+			default:		return DFS_ERRMISC;
+		}
+		temp = 0;
+		DFS_SetFAT(volinfo, scratch, &temp, fileinfo->cluster, cluster);
+
+		return DFS_OK;
+	}
+
+	return DFS_NOTFOUND;
+}
+
+/*
+	Read an open file
+	You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
+	pointer to a SECTOR_SIZE scratch buffer.
+	Note that returning DFS_EOF is not an error condition. This function updates the
+	successcount field with the number of bytes actually read.
+*/
+uint32_t DFS_ReadFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len)
+{
+	uint32_t remain;
+	uint32_t result = DFS_OK;
+	uint32_t sector;
+	uint32_t bytesread;
+
+	// Don't try to read past EOF
+	if (len > fileinfo->filelen - fileinfo->pointer)
+		len = fileinfo->filelen - fileinfo->pointer;
+
+	remain = len;
+	*successcount = 0;
+
+	while (remain && result == DFS_OK) {
+		// This is a bit complicated. The sector we want to read is addressed at a cluster
+		// granularity by the fileinfo->cluster member. The file pointer tells us how many
+		// extra sectors to add to that number.
+		sector = fileinfo->volinfo->dataarea +
+		  ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) +
+		  div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot;
+
+		// Case 1 - File pointer is not on a sector boundary
+		if (div(fileinfo->pointer, SECTOR_SIZE).rem) {
+			uint16_t tempreadsize;
+
+			// We always have to go through scratch in this case
+			result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1);
+
+			// This is the number of bytes that we actually care about in the sector
+			// just read.
+			tempreadsize = SECTOR_SIZE - (div(fileinfo->pointer, SECTOR_SIZE).rem);
+					
+			// Case 1A - We want the entire remainder of the sector. After this
+			// point, all passes through the read loop will be aligned on a sector
+			// boundary, which allows us to go through the optimal path 2A below.
+		   	if (remain >= tempreadsize) {
+				memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), tempreadsize);
+				bytesread = tempreadsize;
+				buffer += tempreadsize;
+				fileinfo->pointer += tempreadsize;
+				remain -= tempreadsize;
+			}
+			// Case 1B - This read concludes the file read operation
+			else {
+				memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), remain);
+
+				buffer += remain;
+				fileinfo->pointer += remain;
+				bytesread = remain;
+				remain = 0;
+			}
+		}
+		// Case 2 - File pointer is on sector boundary
+		else {
+			// Case 2A - We have at least one more full sector to read and don't have
+			// to go through the scratch buffer. You could insert optimizations here to
+			// read multiple sectors at a time, if you were thus inclined (note that
+			// the maximum multi-read you could perform is a single cluster, so it would
+			// be advantageous to have code similar to case 1A above that would round the
+			// pointer to a cluster boundary the first pass through, so all subsequent
+			// [large] read requests would be able to go a cluster at a time).
+			if (remain >= SECTOR_SIZE) {
+				result = DFS_ReadSector(fileinfo->volinfo->unit, buffer, sector, 1);
+				remain -= SECTOR_SIZE;
+				buffer += SECTOR_SIZE;
+				fileinfo->pointer += SECTOR_SIZE;
+				bytesread = SECTOR_SIZE;
+			}
+			// Case 2B - We are only reading a partial sector
+			else {
+				result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1);
+				memcpy(buffer, scratch, remain);
+				buffer += remain;
+				fileinfo->pointer += remain;
+				bytesread = remain;
+				remain = 0;
+			}
+		}
+
+		*successcount += bytesread;
+
+		// check to see if we stepped over a cluster boundary
+		if (div(fileinfo->pointer - bytesread, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot !=
+		  div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
+			// An act of minor evil - we use bytesread as a scratch integer, knowing that
+			// its value is not used after updating *successcount above
+			bytesread = 0;
+			if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) ||
+			  ((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) ||
+			  ((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8)))
+				result = DFS_EOF;
+			else
+				fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &bytesread, fileinfo->cluster);
+		}
+	}
+	
+	return result;
+}
+
+/*
+	Seek file pointer to a given position
+	This function does not return status - refer to the fileinfo->pointer value
+	to see where the pointer wound up.
+	Requires a SECTOR_SIZE scratch buffer
+*/
+void DFS_Seek(PFILEINFO fileinfo, uint32_t offset, uint8_t *scratch)
+{
+	uint32_t tempint;
+
+	// larwe 9/16/06 bugfix split case 0a/0b and changed fallthrough handling
+	// Case 0a - Return immediately for degenerate case
+	if (offset == fileinfo->pointer) {
+		return;
+	}
+	
+	// Case 0b - Don't allow the user to seek past the end of the file
+	if (offset > fileinfo->filelen) {
+		offset = fileinfo->filelen;
+		// NOTE NO RETURN HERE!
+	}
+
+	// Case 1 - Simple rewind to start
+	// Note _intentional_ fallthrough from Case 0b above
+	if (offset == 0) {
+		fileinfo->cluster = fileinfo->firstcluster;
+		fileinfo->pointer = 0;
+		return;		// larwe 9/16/06 +1 bugfix
+	}
+	// Case 2 - Seeking backwards. Need to reset and seek forwards
+	else if (offset < fileinfo->pointer) {
+		fileinfo->cluster = fileinfo->firstcluster;
+		fileinfo->pointer = 0;
+		// NOTE NO RETURN HERE!
+	}
+
+	// Case 3 - Seeking forwards
+	// Note _intentional_ fallthrough from Case 2 above
+
+	// Case 3a - Seek size does not cross cluster boundary - 
+	// very simple case
+	// larwe 9/16/06 changed .rem to .quot in both div calls, bugfix
+	if (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot ==
+	  div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
+		fileinfo->pointer = offset;
+	}
+	// Case 3b - Seeking across cluster boundary(ies)
+	else {
+		// round file pointer down to cluster boundary
+		fileinfo->pointer = div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot *
+		  fileinfo->volinfo->secperclus * SECTOR_SIZE;
+
+		// seek by clusters
+		// larwe 9/30/06 bugfix changed .rem to .quot in both div calls
+		while (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot !=
+		  div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
+
+			fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &tempint, fileinfo->cluster);
+			// Abort if there was an error
+			if (fileinfo->cluster == 0x0ffffff7) {
+				fileinfo->pointer = 0;
+				fileinfo->cluster = fileinfo->firstcluster;
+				return;
+			}
+			fileinfo->pointer += SECTOR_SIZE * fileinfo->volinfo->secperclus;
+		}
+
+		// since we know the cluster is right, we have no more work to do
+		fileinfo->pointer = offset;
+	}
+}
+
+/*
+	Delete a file
+	scratch must point to a sector-sized buffer
+*/
+uint32_t DFS_UnlinkFile(PVOLINFO volinfo, uint8_t *path, uint8_t *scratch)
+{
+	FILEINFO fi;
+	uint32_t cache = 0;
+	uint32_t tempclus;
+
+	// DFS_OpenFile gives us all the information we need to delete it
+	if (DFS_OK != DFS_OpenFile(volinfo, path, DFS_READ, scratch, &fi))
+		return DFS_NOTFOUND;
+
+	// First, read the directory sector and delete that entry
+	if (DFS_ReadSector(volinfo->unit, scratch, fi.dirsector, 1))
+		return DFS_ERRMISC;
+	((PDIRENT) scratch)[fi.diroffset].name[0] = 0xe5;
+	if (DFS_WriteSector(volinfo->unit, scratch, fi.dirsector, 1))
+		return DFS_ERRMISC;
+
+	// Now follow the cluster chain to free the file space
+	while (!((volinfo->filesystem == FAT12 && fi.firstcluster >= 0x0ff7) ||
+	  (volinfo->filesystem == FAT16 && fi.firstcluster >= 0xfff7) ||
+	  (volinfo->filesystem == FAT32 && fi.firstcluster >= 0x0ffffff7))) {
+		tempclus = fi.firstcluster;
+
+		fi.firstcluster = DFS_GetFAT(volinfo, scratch, &cache, fi.firstcluster);
+		DFS_SetFAT(volinfo, scratch, &cache, tempclus, 0);
+
+	}
+	return DFS_OK;
+}
+
+
+/*
+	Write an open file
+	You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
+	pointer to a SECTOR_SIZE scratch buffer.
+	This function updates the successcount field with the number of bytes actually written.
+*/
+uint32_t DFS_WriteFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len)
+{
+	uint32_t remain;
+	uint32_t result = DFS_OK;
+	uint32_t sector;
+	uint32_t byteswritten;
+
+	// Don't allow writes to a file that's open as readonly
+	if (!(fileinfo->mode & DFS_WRITE))
+		return DFS_ERRMISC;
+
+	remain = len;
+	*successcount = 0;
+
+	while (remain && result == DFS_OK) {
+		// This is a bit complicated. The sector we want to read is addressed at a cluster
+		// granularity by the fileinfo->cluster member. The file pointer tells us how many
+		// extra sectors to add to that number.
+		sector = fileinfo->volinfo->dataarea +
+		  ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) +
+		  div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot;
+
+		// Case 1 - File pointer is not on a sector boundary
+		if (div(fileinfo->pointer, SECTOR_SIZE).rem) {
+			uint16_t tempsize;
+
+			// We always have to go through scratch in this case
+			result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1);
+
+			// This is the number of bytes that we don't want to molest in the
+			// scratch sector just read.
+			tempsize = div(fileinfo->pointer, SECTOR_SIZE).rem;
+					
+			// Case 1A - We are writing the entire remainder of the sector. After
+			// this point, all passes through the read loop will be aligned on a
+			// sector boundary, which allows us to go through the optimal path
+			// 2A below.
+		   	if (remain >= SECTOR_SIZE - tempsize) {
+				memcpy(scratch + tempsize, buffer, SECTOR_SIZE - tempsize);
+				if (!result)
+					result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1);
+
+				byteswritten = SECTOR_SIZE - tempsize;
+				buffer += SECTOR_SIZE - tempsize;
+				fileinfo->pointer += SECTOR_SIZE - tempsize;
+				if (fileinfo->filelen < fileinfo->pointer) {
+					fileinfo->filelen = fileinfo->pointer;
+				}
+				remain -= SECTOR_SIZE - tempsize;
+			}
+			// Case 1B - This concludes the file write operation
+			else {
+				memcpy(scratch + tempsize, buffer, remain);
+				if (!result)
+					result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1);
+
+				buffer += remain;
+				fileinfo->pointer += remain;
+				if (fileinfo->filelen < fileinfo->pointer) {
+					fileinfo->filelen = fileinfo->pointer;
+				}
+				byteswritten = remain;
+				remain = 0;
+			}
+		} // case 1
+		// Case 2 - File pointer is on sector boundary
+		else {
+			// Case 2A - We have at least one more full sector to write and don't have
+			// to go through the scratch buffer. You could insert optimizations here to
+			// write multiple sectors at a time, if you were thus inclined. Refer to
+			// similar notes in DFS_ReadFile.
+			if (remain >= SECTOR_SIZE) {
+				result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1);
+				remain -= SECTOR_SIZE;
+				buffer += SECTOR_SIZE;
+				fileinfo->pointer += SECTOR_SIZE;
+				if (fileinfo->filelen < fileinfo->pointer) {
+					fileinfo->filelen = fileinfo->pointer;
+				}
+				byteswritten = SECTOR_SIZE;
+			}
+			// Case 2B - We are only writing a partial sector and potentially need to
+			// go through the scratch buffer.
+			else {
+				// If the current file pointer is not yet at or beyond the file
+				// length, we are writing somewhere in the middle of the file and
+				// need to load the original sector to do a read-modify-write.
+				if (fileinfo->pointer < fileinfo->filelen) {
+					result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1);
+					if (!result) {
+						memcpy(scratch, buffer, remain);
+						result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1);
+					}
+				}
+				else {
+					result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1);
+				}
+
+				buffer += remain;
+				fileinfo->pointer += remain;
+				if (fileinfo->filelen < fileinfo->pointer) {
+					fileinfo->filelen = fileinfo->pointer;
+				}
+				byteswritten = remain;
+				remain = 0;
+			}
+		}
+
+		*successcount += byteswritten;
+
+		// check to see if we stepped over a cluster boundary
+		if (div(fileinfo->pointer - byteswritten, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot !=
+		  div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
+		  	uint32_t lastcluster;
+
+		  	// We've transgressed into another cluster. If we were already at EOF,
+		  	// we need to allocate a new cluster.
+			// An act of minor evil - we use byteswritten as a scratch integer, knowing
+			// that its value is not used after updating *successcount above
+			byteswritten = 0;
+
+			lastcluster = fileinfo->cluster;
+			fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster);
+			
+			// Allocate a new cluster?
+			if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) ||
+			  ((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) ||
+			  ((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8))) {
+			  	uint32_t tempclus;
+
+				tempclus = DFS_GetFreeFAT(fileinfo->volinfo, scratch);
+				byteswritten = 0; // invalidate cache
+				if (tempclus == 0x0ffffff7)
+					return DFS_ERRMISC;
+
+				// Link new cluster onto file
+				DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, lastcluster, tempclus);
+				fileinfo->cluster = tempclus;
+
+				// Mark newly allocated cluster as end of chain			
+				switch(fileinfo->volinfo->filesystem) {
+					case FAT12:		tempclus = 0xff8;	break;
+					case FAT16:		tempclus = 0xfff8;	break;
+					case FAT32:		tempclus = 0x0ffffff8;	break;
+					default:		return DFS_ERRMISC;
+				}
+				DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster, tempclus);
+
+				result = DFS_OK;
+			}
+			// No else clause is required.
+		}
+	}
+	
+	// Update directory entry
+		if (DFS_ReadSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1))
+			return DFS_ERRMISC;
+		((PDIRENT) scratch)[fileinfo->diroffset].filesize_0 = fileinfo->filelen & 0xff;
+		((PDIRENT) scratch)[fileinfo->diroffset].filesize_1 = (fileinfo->filelen & 0xff00) >> 8;
+		((PDIRENT) scratch)[fileinfo->diroffset].filesize_2 = (fileinfo->filelen & 0xff0000) >> 16;
+		((PDIRENT) scratch)[fileinfo->diroffset].filesize_3 = (fileinfo->filelen & 0xff000000) >> 24;
+		if (DFS_WriteSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1))
+			return DFS_ERRMISC;
+	return result;
+}
+
+/*************************************************************************
+ * 
+ * The remainder of this file has been added as a result of the dosfs
+ * distribution being used in MicroMonitor.
+ * This is not part of the original dosfs.c as distributed by Lewin Edwards.
+ *
+ *************************************************************************
+ */
+
+/*
+ * Convert a filename element from directory entry (11) to canonical (8.3) form
+ * 	dest must point to the first non-separator character.
+ * 	sec must point to a 12-byte buffer.
+ */
+uint8_t *DFS_DirToCanonical(uint8_t *dest, uint8_t *src)
+{
+	uint8_t *srcptr = src;
+
+   // copy filename until spaces
+   while(( srcptr -  src) <= 11)
+   {
+	  if (*srcptr == 0) break;
+
+      // name.ext seperator
+      if(( srcptr - src) == 8) *dest++ = '.';
+      if( *srcptr != ' ') *dest++ = *srcptr;
+
+      srcptr++;
+   }
+
+   // null terminate and rewind one char
+   *dest-- = 0;
+
+   // if name has no extension - kill the seperator
+   if( *dest == '.') *dest = 0;
+
+	return dest;
+}
+#endif
diff --git a/main/common/dosfs.h b/main/common/dosfs.h
new file mode 100644
index 0000000..1deb16b
--- /dev/null
+++ b/main/common/dosfs.h
@@ -0,0 +1,393 @@
+/*
+	DOSFS Embedded FAT-Compatible Filesystem
+	(C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com)
+*/
+
+#ifndef _DOSFS_H
+#define _DOSFS_H
+
+#include <stddefs.h>
+
+//#define USE_GMHFIX	// Defined to pull in dosfs fixes from Graham Henderson
+
+
+//===================================================================
+// User-supplied functions
+uint32_t DFS_ReadSector(uint8_t unit, uint8_t *buffer, uint32_t sector, uint32_t count);
+uint32_t DFS_WriteSector(uint8_t unit, uint8_t *buffer, uint32_t sector, uint32_t count);
+
+
+//===================================================================
+// Configurable items
+#define MAX_PATH		64		// Maximum path length (increasing this will
+								// GREATLY increase stack requirements!)
+#define DIR_SEPARATOR	'/'		// character separating directory components
+
+// End of configurable items
+//===================================================================
+
+//===================================================================
+// 32-bit error codes
+#define DFS_OK			0			// no error
+#define DFS_EOF			1			// end of file (not an error)
+#define DFS_WRITEPROT	2			// volume is write protected
+#define DFS_NOTFOUND	3			// path or file not found
+#define DFS_PATHLEN		4			// path too long
+#define DFS_ALLOCNEW	5			// must allocate new directory cluster
+#define DFS_ERRMISC		0xffffffff	// generic error
+
+//===================================================================
+// File access modes
+#define DFS_READ		1			// read-only
+#define DFS_WRITE		2			// write-only
+
+//===================================================================
+// Miscellaneous constants
+#define SECTOR_SIZE		512		// sector size in bytes
+
+//===================================================================
+// Internal subformat identifiers
+#define FAT12			0
+#define FAT16			1
+#define FAT32			2
+
+//===================================================================
+// DOS attribute bits
+#define ATTR_READ_ONLY	0x01
+#define ATTR_HIDDEN		0x02
+#define ATTR_SYSTEM		0x04
+#define ATTR_VOLUME_ID	0x08
+#define ATTR_DIRECTORY	0x10
+#define ATTR_ARCHIVE	0x20
+#define ATTR_LONG_NAME	(ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_VOLUME_ID)
+
+
+/*
+	Directory entry structure
+	note: if name[0] == 0xe5, this is a free dir entry
+	      if name[0] == 0x00, this is a free entry and all subsequent entries are free
+		  if name[0] == 0x05, the first character of the name is 0xe5 [a kanji nicety]
+
+	Date format: bit 0-4  = day of month (1-31)
+	             bit 5-8  = month, 1=Jan..12=Dec
+				 bit 9-15 =	count of years since 1980 (0-127)
+	Time format: bit 0-4  = 2-second count, (0-29)
+	             bit 5-10 = minutes (0-59)
+				 bit 11-15= hours (0-23)
+*/
+
+// some macros to aid in formatting file date, times. and file sizes
+#define CREATE_DAY(  _x_)  ((_x_.crtdate_l)      & 0x1f)
+#define CREATE_MON(  _x_) (((_x_.crtdate_l >> 5) & 0x07) | ((_x_.crtdate_h & 1) << 3))
+#define CREATE_YEAR( _x_)  ((_x_.crtdate_h >> 1) + 1980)
+
+#define CREATE_SEC( _x_)  (((_x_.crttime_l)      & 0x1f)  * 2)
+#define CREATE_MIN( _x_)  (((_x_.crttime_l >> 5) & 0x07) | ((_x_.crttime_h & 0x07) << 3))
+#define CREATE_HR(  _x_)   ((_x_.crttime_h >> 3))
+
+#define FILESIZE(_x_)      (int)( ( _x_.filesize_3 << 24)| ( _x_.filesize_2 << 16) | ( _x_.filesize_1 << 8) | _x_.filesize_0)
+
+
+typedef struct __attribute__ ((__packed__)) _tagDIRENT {
+	uint8_t name[11];			// filename
+	uint8_t attr;				// attributes (see ATTR_* constant definitions)
+	uint8_t reserved;			// reserved, must be 0
+	uint8_t crttimetenth;		// create time, 10ths of a second (0-199 are valid)
+	uint8_t crttime_l;			// creation time low byte
+	uint8_t crttime_h;			// creation time high byte
+	uint8_t crtdate_l;			// creation date low byte
+	uint8_t crtdate_h;			// creation date high byte
+	uint8_t lstaccdate_l;		// last access date low byte
+	uint8_t lstaccdate_h;		// last access date high byte
+	uint8_t startclus_h_l;		// high word of first cluster, low byte (FAT32)
+	uint8_t startclus_h_h;		// high word of first cluster, high byte (FAT32)
+	uint8_t wrttime_l;			// last write time low byte
+	uint8_t wrttime_h;			// last write time high byte
+	uint8_t wrtdate_l;			// last write date low byte
+	uint8_t wrtdate_h;			// last write date high byte
+	uint8_t startclus_l_l;		// low word of first cluster, low byte
+	uint8_t startclus_l_h;		// low word of first cluster, high byte
+	uint8_t filesize_0;			// file size, low byte
+	uint8_t filesize_1;			//
+	uint8_t filesize_2;			//
+	uint8_t filesize_3;			// file size, high byte
+} DIRENT, *PDIRENT;
+
+/*
+	Partition table entry structure
+*/
+typedef struct __attribute__ ((__packed__)) _tagPTINFO {
+	uint8_t		active;			// 0x80 if partition active
+	uint8_t		start_h;		// starting head
+	uint8_t		start_cs_l;		// starting cylinder and sector (low byte)
+	uint8_t		start_cs_h;		// starting cylinder and sector (high byte)
+	uint8_t		type;			// type ID byte
+	uint8_t		end_h;			// ending head
+	uint8_t		end_cs_l;		// ending cylinder and sector (low byte)
+	uint8_t		end_cs_h;		// ending cylinder and sector (high byte)
+	uint8_t		start_0;		// starting sector# (low byte)
+	uint8_t		start_1;		//
+	uint8_t		start_2;		//
+	uint8_t		start_3;		// starting sector# (high byte)
+	uint8_t		size_0;			// size of partition (low byte)
+	uint8_t		size_1;			//
+	uint8_t		size_2;			//
+	uint8_t		size_3;			// size of partition (high byte)
+} PTINFO, *PPTINFO;
+
+/*
+	Master Boot Record structure
+*/
+typedef struct __attribute__ ((__packed__)) _tagMBR {
+	uint8_t bootcode[0x1be];	// boot sector
+	PTINFO ptable[4];			// four partition table structures
+	uint8_t sig_55;				// 0x55 signature byte
+	uint8_t sig_aa;				// 0xaa signature byte
+} MBR, *PMBR;
+
+/*
+	BIOS Parameter Block structure (FAT12/16)
+*/
+typedef struct __attribute__ ((__packed__)) _tagBPB {
+	uint8_t bytepersec_l;		// bytes per sector low byte (0x00)
+	uint8_t bytepersec_h;		// bytes per sector high byte (0x02)
+	uint8_t	secperclus;			// sectors per cluster (1,2,4,8,16,32,64,128 are valid)
+	uint8_t reserved_l;			// reserved sectors low byte
+	uint8_t reserved_h;			// reserved sectors high byte
+	uint8_t numfats;			// number of FAT copies (2)
+	uint8_t rootentries_l;		// number of root dir entries low byte (0x00 normally)
+	uint8_t rootentries_h;		// number of root dir entries high byte (0x02 normally)
+	uint8_t sectors_s_l;		// small num sectors low byte
+	uint8_t sectors_s_h;		// small num sectors high byte
+	uint8_t mediatype;			// media descriptor byte
+	uint8_t secperfat_l;		// sectors per FAT low byte
+	uint8_t secperfat_h;		// sectors per FAT high byte
+	uint8_t secpertrk_l;		// sectors per track low byte
+	uint8_t secpertrk_h;		// sectors per track high byte
+	uint8_t heads_l;			// heads low byte
+	uint8_t heads_h;			// heads high byte
+	uint8_t hidden_0;			// hidden sectors low byte
+	uint8_t hidden_1;			// (note - this is the number of MEDIA sectors before
+	uint8_t hidden_2;			// first sector of VOLUME - we rely on the MBR instead)
+	uint8_t hidden_3;			// hidden sectors high byte
+	uint8_t sectors_l_0;		// large num sectors low byte
+	uint8_t sectors_l_1;		//
+	uint8_t sectors_l_2;		//
+	uint8_t sectors_l_3;		// large num sectors high byte
+} BPB, *PBPB;
+
+/*
+	Extended BIOS Parameter Block structure (FAT12/16)
+*/
+typedef struct __attribute__ ((__packed__)) _tagEBPB {
+	uint8_t unit;				// int 13h drive#
+	uint8_t head;				// archaic, used by Windows NT-class OSes for flags
+	uint8_t signature;			// 0x28 or 0x29
+	uint8_t serial_0;			// serial#
+	uint8_t serial_1;			// serial#
+	uint8_t serial_2;			// serial#
+	uint8_t serial_3;			// serial#
+	uint8_t label[11];			// volume label
+	uint8_t system[8];			// filesystem ID
+} EBPB, *PEBPB;
+
+/*
+	Extended BIOS Parameter Block structure (FAT32)
+*/
+typedef struct __attribute__ ((__packed__)) _tagEBPB32 {
+	uint8_t fatsize_0;			// big FAT size in sectors low byte
+	uint8_t fatsize_1;			//
+	uint8_t fatsize_2;			//
+	uint8_t fatsize_3;			// big FAT size in sectors high byte
+	uint8_t extflags_l;			// extended flags low byte
+	uint8_t extflags_h;			// extended flags high byte
+	uint8_t fsver_l;			// filesystem version (0x00) low byte
+	uint8_t fsver_h;			// filesystem version (0x00) high byte
+	uint8_t root_0;				// cluster of root dir, low byte
+	uint8_t root_1;				//
+	uint8_t root_2;				//
+	uint8_t root_3;				// cluster of root dir, high byte
+	uint8_t fsinfo_l;			// sector pointer to FSINFO within reserved area, low byte (2)
+	uint8_t fsinfo_h;			// sector pointer to FSINFO within reserved area, high byte (0)
+	uint8_t bkboot_l;			// sector pointer to backup boot sector within reserved area, low byte (6)
+	uint8_t bkboot_h;			// sector pointer to backup boot sector within reserved area, high byte (0)
+	uint8_t reserved[12];		// reserved, should be 0
+
+	uint8_t unit;				// int 13h drive#
+	uint8_t head;				// archaic, used by Windows NT-class OSes for flags
+	uint8_t signature;			// 0x28 or 0x29
+	uint8_t serial_0;			// serial#
+	uint8_t serial_1;			// serial#
+	uint8_t serial_2;			// serial#
+	uint8_t serial_3;			// serial#
+	uint8_t label[11];			// volume label
+	uint8_t system[8];			// filesystem ID
+} EBPB32, *PEBPB32;
+
+/*
+	Logical Boot Record structure (volume boot sector)
+*/
+typedef struct  __attribute__ ((__packed__)) _tagLBR {
+	uint8_t jump[3];			// JMP instruction
+	uint8_t oemid[8];			// OEM ID, space-padded
+	BPB bpb;					// BIOS Parameter Block
+	union {
+		EBPB ebpb;				// FAT12/16 Extended BIOS Parameter Block
+		EBPB32 ebpb32;			// FAT32 Extended BIOS Parameter Block
+	} ebpb;
+	uint8_t code[420];			// boot sector code
+	uint8_t sig_55;				// 0x55 signature byte
+	uint8_t sig_aa;				// 0xaa signature byte
+} LBR, *PLBR;
+
+/*
+	Volume information structure (Internal to DOSFS)
+*/
+typedef struct  __attribute__ ((__packed__)) _tagVOLINFO {
+	uint8_t unit;				// unit on which this volume resides
+	uint8_t filesystem;			// formatted filesystem
+
+// These two fields aren't very useful, so support for them has been commented out to
+// save memory. (Note that the "system" tag is not actually used by DOS to determine
+// filesystem type - that decision is made entirely on the basis of how many clusters
+// the drive contains. DOSFS works the same way).
+// See tag: OEMID in dosfs.c
+//	uint8_t oemid[9];			// OEM ID ASCIIZ
+//	uint8_t system[9];			// system ID ASCIIZ
+	uint8_t label[12];			// volume label ASCIIZ
+	uint32_t startsector;		// starting sector of filesystem
+	uint8_t secperclus;			// sectors per cluster
+	uint16_t reservedsecs;		// reserved sectors
+	uint32_t numsecs;			// number of sectors in volume
+	uint32_t secperfat;			// sectors per FAT
+	uint16_t rootentries;		// number of root dir entries
+
+	uint32_t numclusters;		// number of clusters on drive
+
+	// The fields below are PHYSICAL SECTOR NUMBERS.
+	uint32_t fat1;				// starting sector# of FAT copy 1
+	uint32_t rootdir;			// starting sector# of root directory (FAT12/FAT16) or cluster (FAT32)
+	uint32_t dataarea;			// starting sector# of data area (cluster #2)
+} VOLINFO, *PVOLINFO;
+
+/*
+	Flags in DIRINFO.flags
+*/
+#define DFS_DI_BLANKENT		0x01	// Searching for blank entry
+
+/*
+	Directory search structure (Internal to DOSFS)
+*/
+typedef struct  __attribute__ ((__packed__)) _tagDIRINFO {
+	uint32_t currentcluster;	// current cluster in dir
+	uint8_t currentsector;		// current sector in cluster
+	uint8_t currententry;		// current dir entry in sector
+	uint8_t *scratch;			// ptr to user-supplied scratch buffer (one sector)
+	uint8_t flags;				// internal DOSFS flags
+} DIRINFO, *PDIRINFO;
+
+/*
+	File handle structure (Internal to DOSFS)
+*/
+typedef struct  __attribute__ ((__packed__)) _tagFILEINFO {
+	PVOLINFO volinfo;			// VOLINFO used to open this file
+	uint32_t dirsector;			// physical sector containing dir entry of this file
+	uint8_t diroffset;			// # of this entry within the dir sector
+	uint8_t mode;				// mode in which this file was opened
+	uint32_t firstcluster;		// first cluster of file
+	uint32_t filelen;			// byte length of file
+
+	uint32_t cluster;			// current cluster
+	uint32_t pointer;			// current (BYTE) pointer
+} FILEINFO, *PFILEINFO;
+
+/*
+	Get starting sector# of specified partition on drive #unit
+	NOTE: This code ASSUMES an MBR on the disk.
+	scratchsector should point to a SECTOR_SIZE scratch area
+	Returns 0xffffffff for any error.
+	If pactive is non-NULL, this function also returns the partition active flag.
+	If pptype is non-NULL, this function also returns the partition type.
+	If psize is non-NULL, this function also returns the partition size.
+*/
+uint32_t DFS_GetPtnStart(uint8_t unit, uint8_t *scratchsector, uint8_t pnum, uint8_t *pactive, uint8_t *pptype, uint32_t *psize);
+
+/*
+	Retrieve volume info from BPB and store it in a VOLINFO structure
+	You must provide the unit and starting sector of the filesystem, and
+	a pointer to a sector buffer for scratch
+	Attempts to read BPB and glean information about the FS from that.
+	Returns 0 OK, nonzero for any error.
+*/
+uint32_t DFS_GetVolInfo(uint8_t unit, uint8_t *scratchsector, uint32_t startsector, PVOLINFO volinfo);
+
+/*
+	Open a directory for enumeration by DFS_GetNextDirEnt
+	You must supply a populated VOLINFO (see DFS_GetVolInfo)
+	The empty string or a string containing only the directory separator are
+	considered to be the root directory.
+	Returns 0 OK, nonzero for any error.
+*/
+uint32_t DFS_OpenDir(PVOLINFO volinfo, uint8_t *dirname, PDIRINFO dirinfo);
+
+/*
+	Get next entry in opened directory structure. Copies fields into the dirent
+	structure, updates dirinfo. Note that it is the _caller's_ responsibility to
+	handle the '.' and '..' entries.
+	A deleted file will be returned as a NULL entry (first char of filename=0)
+	by this code. Filenames beginning with 0x05 will be translated to 0xE5
+	automatically. Long file name entries will be returned as NULL.
+	returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid,
+	or DFS_ERRMISC for a media error
+*/
+uint32_t DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent);
+
+/*
+	Open a file for reading or writing. You supply populated VOLINFO, a path to the file,
+	mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to
+	provide a pointer to a sector-sized scratch buffer.
+	Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used
+	to access the file from this point on.
+*/
+uint32_t DFS_OpenFile(PVOLINFO volinfo, uint8_t *path, uint8_t mode, uint8_t *scratch, PFILEINFO fileinfo);
+
+/*
+	Read an open file
+	You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
+	pointer to a SECTOR_SIZE scratch buffer.
+	Note that returning DFS_EOF is not an error condition. This function updates the
+	successcount field with the number of bytes actually read.
+*/
+uint32_t DFS_ReadFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len);
+
+/*
+	Write an open file
+	You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
+	pointer to a SECTOR_SIZE scratch buffer.
+	This function updates the successcount field with the number of bytes actually written.
+*/
+uint32_t DFS_WriteFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len);
+
+/*
+	Seek file pointer to a given position
+	This function does not return status - refer to the fileinfo->pointer value
+	to see where the pointer wound up.
+	Requires a SECTOR_SIZE scratch buffer
+*/
+void DFS_Seek(PFILEINFO fileinfo, uint32_t offset, uint8_t *scratch);
+
+/*
+	Delete a file
+	scratch must point to a sector-sized buffer
+*/
+uint32_t DFS_UnlinkFile(PVOLINFO volinfo, uint8_t *path, uint8_t *scratch);
+
+uint32_t DFS_GetFAT(PVOLINFO volinfo, uint8_t *scratch, uint32_t *scratchcache, uint32_t cluster);
+uint8_t *DFS_DirToCanonical(uint8_t *dest, uint8_t *src);
+
+// If we are building a host-emulation version, include host support
+#ifdef HOSTVER
+#include "hostemu.h"
+#endif
+
+#endif // _DOSFS_H
diff --git a/main/common/fatfs.c b/main/common/fatfs.c
new file mode 100644
index 0000000..34c6275
--- /dev/null
+++ b/main/common/fatfs.c
@@ -0,0 +1,696 @@
+/* vi: set ts=4: */
+/* fatfs.c:
+ * This is a front end (i.e. the CLI portion) of the dosfs.c source code.
+ * The dosfs.c file is code from Lewin Edwards.  The website I got this
+ * from originally was: http://www.zws.com/products/dosfs/index.html .
+ *
+ * The dosfs.c dosfs.h files in uMon common (i.e. here) are taken directly
+ * from that website, with minimal modification (so as to remain compatible
+ * with any DOSFS updates).  Much of this fatfs code is also shamelessly
+ * cut-and-pasted from Lewin's source file main.c (part of the dosfs
+ * tarball) used to demonstrate the dosfs interface.
+ *
+ * Discussion on uMon's philosophy of file-systems other than TFS...
+ * The intent under the scope of uMon for support of file systems other than
+ * TFS is to support two commands: a file-system-specific command and an
+ * interface-specific command.  The goal is that members of the two different
+ * command sets can be mixed and matched as needed in a particular design.
+ * For example, if we have commands for compact flash (CF), SPI and I2C 
+ * interfaces the "fatfs" command could use anyone of them to retrieve files
+ * from that interface (assuming of course, that the interface has an FAT
+ * FS on the other side).
+ *
+ * The way this works is simple, the only thing the fatfs command needs is
+ * a set of interface-specific functions: readblock and writeblock. As
+ * long as the CF/SPI/I2C commands support this, and also support the
+ * ability to share those interface functions through the CLI, it simply
+ * becomes a matter of assigning the function pointers in a startup script
+ * when uMon boots up (probably in monrc).
+ *
+ * That being said, here's the model...
+ *
+ * File-system-specific Command:
+ * Each command will support the ability to establish its read and write
+ * pointers through the command line.  The -r and -w options do this in
+ * the fatfs command, and it would be nice if other similar commands could
+ * follow the same model.  The command should support (at minimum) the
+ * ability to list the files in the FS (ls), query for the presence of a
+ * specific file within the FS (qry), copy a file from the FS to TFS or
+ * ram (get), and also dump the content of an ASCII file from the FS to the
+ * console (cat).  If the command supports modification of the FS, then,
+ * it should also support the ability remove (rm) and copy from ram or TFS
+ * to the FS (put).  The command also supports default shell variables that
+ * may contain the read write functions.
+ *
+ * Interface-specific Command:
+ * Each command will support the potential of multiple interfaces of the 
+ * same type.  The command must be able to initialize (with optional
+ * verbosity) said interface and populate a defined set of shell variables
+ * with the address of the read and write functions applicable to that
+ * interface.  Ideally the interface command should also support the ability
+ * to do raw reads (FS to memory) and writes (memory to FS) on the interface.
+ *
+ * With the above model we then have the ability to connect the "FS" command
+ * with any "Interface" command; so as file system support in uMon grows,
+ * it immediately becomes useful on a variety of interfaces, as long as
+ * they adhere to the above simple model.  As of this writing the "cf" and
+ * "fatfs" commands comply to this model and can be used as a template for
+ * developing new commands that fit into this category.
+ * 
+ * Here is an example of their usage:
+ *
+ * uMON> cf init FATFS    # Initialize the compact flash interface and
+ *                        # laod FATFS_RD and FATFS_WR with the read and
+ *                        # write function pointers. 
+ * uMON> fatfs cat file1  # Using the FATFS_RD and FATFS_WR shell variables
+ *                        # previously set up, dump the content of the file 
+ *                        # named 'file1'.
+ *
+ *	General notice:
+ *	This code is part of a boot-monitor package developed as a generic base
+ *	platform for embedded system designs.  As such, it is likely to be
+ *	distributed to various projects beyond the control of the original
+ *	author.  Please notify the author of any enhancements made or bugs found
+ *	so that all may benefit from the changes.  In addition, notification back
+ *	to the author will allow the new user to pick up changes that may have
+ *	been made by other users after this version of the code was distributed.
+ *
+ *	Note1: the majority of this code was edited with 4-space tabs.
+ *	Note2: as more and more contributions are accepted, the term "author"
+ *		   is becoming a mis-representation of credit.
+ *
+ *	Original author:	Ed Sutter			esutter@lucent.com 
+ *	Contributor(s):		Graham Henderson
+ */
+ 
+#include "config.h"
+#if INCLUDE_FATFS
+#include "stddefs.h"
+#include "genlib.h"
+#include "cli.h"
+#include "tfs.h"
+#include "tfsprivate.h"
+#include "dosfs.h"
+
+static int	(*fatfsRead)(int interface, char *buf, int blknum, int count);
+static int	(*fatfsWrite)(int interface, char *buf, int blknum, int count);
+
+static char fatfs_initialized;
+static char *fatfs_tmp_space;
+static VOLINFO vi __attribute__((aligned (32)));
+static uint8_t sector[SECTOR_SIZE]  __attribute__ ((aligned (32)));
+static uint8_t sector2[SECTOR_SIZE] __attribute__ ((aligned (32)));
+
+/* Support skipping LFN dir entries...
+ */
+#define ATTR_LONG_NAME  \
+	(ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_VOLUME_ID)
+
+#define FATFS_FNAME_STR		"FATFSFNAME"
+#define FATFS_FTOT_STR		"FATFSFTOT"
+#define FATFS_FSIZE_STR		"FATFSFSIZE"
+
+/* fatfsInit():
+ * Start up the fs by reading in volume information.
+ * This function will return if already initialized, unless force
+ * is nonzero.
+ */
+static int
+fatfsInit(int force, int verbose)
+{
+	uint8_t pactive, ptype;
+	uint32_t pstart, psize;
+
+	if ((fatfs_initialized == 1) && (force == 0))
+		return(0);
+
+	/* Obtain pointer to first partition on first (only) unit.
+	 */
+	pstart = DFS_GetPtnStart(0, sector, 0, &pactive, &ptype, &psize);
+	if (pstart == 0xffffffff) {
+		printf("Cannot find first partition\n");
+		return(-1);
+	}
+
+	if (verbose) {
+		printf("Partition 0...\n");
+		printf("  Start sector 0x%08lx\n",pstart);
+		printf("  Active %d\n",pactive);
+		printf("  Type 0x%x\n",ptype);
+		printf("  Size 0x%lx\n",psize);
+	}
+
+	if (DFS_GetVolInfo(0, sector, pstart, &vi)) {
+		printf("Error getting volume information\n");
+		return(-1);
+	}
+
+	if (verbose) {
+		printf("Volume label '%-11s'\n", vi.label);
+		printf("  %d sector(s) per cluster\n",vi.secperclus);
+		printf("  %d reserved sector(s)\n",vi.reservedsecs);
+		printf("  %d total volume sector(s)\n", vi.numsecs);
+		printf("  %d sectors per FAT\n",vi.secperfat);
+		printf("  first FAT at sector #%d\n",vi.fat1);
+		printf("  root dir at #%d\n",vi.rootdir);
+
+		printf("For.. FAT32 rootdir is CLUSTER #,\n");
+		printf("      FAT12/16 rootdir is a SECTOR #.\n");
+		printf("%d root dir entries, data area commences at sector #%d.\n",
+			vi.rootentries,vi.dataarea);
+		printf("%d clusters (%d bytes) in data area, filesystem IDd as ",
+			vi.numclusters, vi.numclusters * vi.secperclus * SECTOR_SIZE);
+
+		if (vi.filesystem == FAT12)
+			printf("FAT12.\n");
+		else if (vi.filesystem == FAT16)
+			printf("FAT16.\n");
+		else if (vi.filesystem == FAT32)
+			printf("FAT32.\n");
+		else
+			printf("[unknown]\n");
+	}
+	fatfs_initialized = 1;
+	return(0);
+}
+
+/* fatfsCat():
+ * Dump the content of the specified fatfs file to the console.
+ * This function assumes the data is ASCII.
+ */
+static int
+fatfsCat(char *filepath)
+{
+	uint32_t i, j;
+	FILEINFO fi;
+	uint8_t *p;
+
+	if (DFS_OpenFile(&vi, (uint8_t *)filepath, DFS_READ, sector, &fi)) {
+		printf("error opening '%s'\n",filepath);
+		return(-1);
+	}
+	p = (uint8_t *)fatfs_tmp_space;
+	DFS_ReadFile(&fi, sector, p, &i, fi.filelen);
+	for(j=0;j<fi.filelen;j++)
+		putchar(*p++);
+	putchar('\n');
+	return(0);
+}
+
+/* fatfsGet():
+ * Retreive a file from the FATFS and place it in the specified destination.
+ * The destination may be either a TFS filename or a hex address
+ * (indicated by a leading "0x").
+ *
+ * Input:
+ * char *fatfspath
+ *	Pointer to FATFS file and path.
+ * char *dest
+ *	Pointer to TFS filename or a addr,len string.
+ *	The expected "addr,len" syntax is 0xADDR,LEN or 0xADDR,0xLEN.
+ */
+static int
+fatfsGet(char *fatfile, char *dest)
+{
+	FILEINFO fi;
+	char *p, tfs;
+	uint32_t i;
+
+	if (DFS_OpenFile(&vi, (uint8_t *)fatfile, DFS_READ, sector, &fi)) {
+		printf("error opening file\n");
+		return(-1);
+	}
+	if (strncmp(dest,"0x",2) == 0) {
+		tfs = 0;
+		p = (char *)strtoul(dest,0,0);
+	}
+	else {
+		tfs = 1;
+		p = fatfs_tmp_space;
+	}
+
+	DFS_ReadFile(&fi, sector, (uint8_t *)p, &i, fi.filelen);
+	if (i != fi.filelen) {
+		printf("read %d, expected %d\n",i,fi.filelen);
+		return(-1);
+	}
+	if (tfs) {
+#if INCLUDE_TFS
+		int	tfserr;
+		char *flags, *info;
+
+		flags = info = (char *)0;
+		if ((flags = strchr(dest,','))) {
+			*flags++ = 0;
+			if ((info = strchr(flags,',')))
+				*info++ = 0;
+		}
+		tfserr = tfsadd(dest,info,flags,(uchar *)p,fi.filelen);
+		if (tfserr != TFS_OKAY) {
+			printf("TFS error: %s\n",tfserrmsg(tfserr));
+			return(-1);
+		}
+#else
+		printf("TFS not built in\n");
+		return(-1);
+#endif
+	}
+	return(0);
+}
+
+/* fatfsPut():
+ * Copy data or file to a FATFS file.
+ *
+ * Input:
+ * char *fatfspath
+ *	Pointer to FATFS file and path.
+ * char *src
+ *	Pointer to TFS filename or a addr,len string.
+ *	The expected "addr,len" syntax is 0xADDR,LEN or 0xADDR,0xLEN.
+ */
+static int
+fatfsPut(char *src, char *fatfspath)
+{
+	FILEINFO fi;
+	char tfs, *p, *cp;
+	uint32_t successcount, len, size, rc;
+
+	if (strncmp(src,"0x",2) == 0) {
+		tfs = 0;
+		p = (char *)strtoul(src,&cp,0);
+		cp++;
+		len = strtoul(cp,0,0);
+	}
+	else {
+#if INCLUDE_TFS
+		TFILE *tfp;
+
+		tfs = 1;
+		if ((tfp = tfsstat(src)) == 0) {
+			printf("Can't find file '%s' in TFS\n",src);
+			return(CMD_FAILURE);
+		}
+		p = TFS_BASE(tfp);
+		len = TFS_SIZE(tfp);
+#else
+		printf("TFS not built in\n");
+		return(-1);
+#endif
+	}
+
+	/* Copy 'len' bytes from 'p' to DOSFS file 'fatfspath'...
+	 */
+	if (DFS_OpenFile(&vi, (uint8_t *)fatfspath, DFS_WRITE, sector, &fi)) {
+		printf("error opening '%s'\n",fatfspath);
+		return(-1);
+	}
+
+	while(len > 0) {
+		if (len >= SECTOR_SIZE)
+			size = SECTOR_SIZE;
+		else
+			size = len;
+
+		rc = DFS_WriteFile(&fi, sector2, (uint8_t *)p, &successcount, size);
+		if ((rc != DFS_OK) || (successcount != size)) {
+			printf("error writing '%s'\n",fatfspath);
+			return(-1);
+		}
+		p += size;
+		len -= size;
+	}
+	return(0);
+}
+
+/* fatfsRm():
+ * Remove the specified file from the FATFS.
+ * If the path is a directory, then don't remove anything.
+ */
+static int
+fatfsRm(char *fatfspath)
+{
+	DIRINFO di;
+
+	di.scratch = sector;
+	if (DFS_OpenDir(&vi, (uint8_t *)fatfspath, &di) == 0) {
+		printf("can't remove directory '%s'\n",fatfspath);
+		return(-1);
+	}
+	if (DFS_UnlinkFile(&vi, (uint8_t *)fatfspath, sector)) {
+		printf("error unlinking file %s\n",fatfspath);
+		return(-1);
+	}
+	return(0);
+}
+
+/* fatfsLs():
+ * The incoming string is assumed to be some directory name.
+ * If NULL, then it is assumed to be the CF's top-most level.
+ */ 
+static int
+fatfsLs(char *dirname)
+{
+	int	ftot;
+	DIRENT de;
+	DIRINFO di;
+	char *dir;
+
+	if (dirname)
+		dir = dirname;
+	else
+		dir = "";
+
+	di.scratch = sector;
+	if (DFS_OpenDir(&vi, (uint8_t *)dir, &di)) {
+		printf("Can't open dir: <%s>\n",dirname);
+		return(CMD_FAILURE);
+	}
+
+	ftot = 0;
+	while (!DFS_GetNext(&vi, &di, &de)) {
+		char tmp[32]; 
+
+		if (de.name[0] && ((de.attr & ATTR_LONG_NAME) != ATTR_LONG_NAME)) {
+			if ((de.attr & ATTR_VOLUME_ID) > 0) {
+				de.name[8] = 0;
+				printf("Volume:     %s\n",de.name);
+				continue;
+            }
+			ftot++;
+
+			printf("%02d/%02d/%4d  %02d:%02d   ",
+				CREATE_MON(de), CREATE_DAY(de), CREATE_YEAR(de),
+				CREATE_HR(de), CREATE_MIN(de));
+
+			if ((de.attr & ATTR_DIRECTORY) > 0) {
+				// truncate the extension
+				de.name[8] = 0;
+
+				printf("<DIR>            %-8s",de.name);
+			}
+			else {
+				DFS_DirToCanonical((uint8_t *)tmp,de.name);
+				printf("       %8d  %-12s",FILESIZE(de), tmp);
+			}
+
+			printf("  %c%c%c%c%c\n",
+				(( de.attr & ATTR_VOLUME_ID) ? 'V' : ' '),
+				(( de.attr & ATTR_READ_ONLY) ? 'R' : ' '),
+				(( de.attr & ATTR_ARCHIVE  ) ? 'A' : ' '),
+				(( de.attr & ATTR_SYSTEM   ) ? 'S' : ' '),
+				(( de.attr & ATTR_HIDDEN   ) ? 'H' : ' '));
+		}
+	}
+	shell_sprintf(FATFS_FTOT_STR,"%d",ftot);
+	return(0);
+}
+
+static int
+fatfsQry(char *fatfspath, int verbose)
+{
+	DIRENT de;
+	DIRINFO di;
+	char *lastslash, *fname, *dir, pathcopy[80], matchname[80];
+	int flen, flen1, fsize, pathlen, match, ftot;
+
+	if (!fatfspath)
+		return(-1);
+
+	/* Prior to each 'ls', clear the content of the name and
+	 * size shell variables...
+	 */
+	setenv(FATFS_FNAME_STR,0);
+	setenv(FATFS_FSIZE_STR,0);
+	setenv(FATFS_FTOT_STR,0);
+
+	pathlen = strlen(fatfspath);
+	if (pathlen > sizeof(pathcopy)) {
+		printf("path too big\n");
+		return(-1);
+	}
+	strcpy(pathcopy, fatfspath);
+	lastslash = strrchr(pathcopy,DIR_SEPARATOR);
+
+	if (lastslash == 0) {
+		dir = "";
+		fname = pathcopy;
+	}
+	else {
+		*lastslash = 0;
+		dir = pathcopy;
+		fname = lastslash+1;
+	}
+
+	flen = strlen(fname);
+	if (verbose > 1)
+		printf("Qry opening dir <%s>, fname <%s>...\n",dir,fname);
+
+	di.scratch = sector;
+	if (DFS_OpenDir(&vi, (uint8_t *)dir, &di)) {
+		printf("error opening subdirectory\n");
+		return(CMD_FAILURE);
+	}
+
+	match = fsize = ftot = flen1 = 0;
+	while (!DFS_GetNext(&vi, &di, &de)) {
+		int i;
+		char dosname[16];
+
+		memset(dosname,0,sizeof(dosname));
+		if (de.name[0] && ((de.attr & ATTR_LONG_NAME) != ATTR_LONG_NAME)) {
+			if ((de.attr & ATTR_VOLUME_ID) || (de.attr & ATTR_DIRECTORY)) {
+				for(i=0;i<8;i++) {
+					if (de.name[i] != ' ') {
+						dosname[i] = de.name[i];
+					}
+					else {
+						dosname[i] = 0;
+						break;
+					}
+				}
+				dosname[8] = 0;
+			}
+			else
+				DFS_DirToCanonical((uint8_t *)dosname,de.name);
+	
+			flen1 = strlen(dosname);
+
+			if ((fname[0] == '*') && (fname[flen-1] == '*')) {
+				fname[flen-1] = 0;
+				if (strstr(dosname,fname+1))
+					match = 1;
+				fname[flen-1] = '*';
+			}
+			else if (fname[0] == '*') {
+				if (!strcmp(dosname+(flen1-flen+1),fname+1))
+					match = 1;
+			}
+			else if (fname[flen-1] == '*') {
+				fname[flen-1] = 0;
+				if (!strncmp(dosname,fname,flen-1))
+					match = 1;
+				fname[flen-1] = '*';
+			}
+			else if (!strcmp(dosname,fname)) {
+				match = 1;
+			}
+			if (match) {
+				strcpy(matchname,dosname);
+				fsize = FILESIZE(de);
+				ftot++;
+				match = 0;
+				if (verbose)
+					printf("  %s (%d)\n",dosname,fsize);
+			}
+		}
+	}
+	shell_sprintf(FATFS_FTOT_STR,"%d",ftot);
+	if (ftot) {
+		shell_sprintf(FATFS_FSIZE_STR,"%d",fsize);
+		setenv(FATFS_FNAME_STR,matchname);
+	}
+	return(0);
+}
+
+
+char *FatfsHelp[] = {
+	"Fat 12|16|32 File System Support",
+	"[r:s:w:v] {operation} [args]...",
+#if INCLUDE_VERBOSEHELP
+	"",
+	"Options:",
+	" -r {addr}   set read-block func ptr (default: FATFS_RD)",
+	" -s {addr}   base of ram scratch space used by fatfs",
+	"             (default is APPRAMBASE)",
+	" -w {addr}   set write-block func ptr (default: FATFS_WR)",
+	" -v          additive verbosity",
+	"",
+	"Operations:",
+	" cat {fname}",
+	" get {fat_file} {tfs_file | addr}",
+	"              (get from fatfs)",
+	" init         initialize internal structures",
+	" put {tfs_file | addr,size} {fat_file}",
+	"              (put to fatfs)",
+	" ls  [dir]    list files within specified directory (or top)",
+	" qry {fltr}   qry for file or directory presence",
+	"              - fltr format: sss, *sss, sss*, *sss* ('sss' is any string)",
+	"              - loads " FATFS_FNAME_STR " & " FATFS_FSIZE_STR " based on most recent match",
+	"              - loads " FATFS_FTOT_STR " with number of files listed",
+	" rm  {fname}",
+#endif
+	0
+};
+
+/* FatfsCmd():
+ * This command provides a front end (command line interface) to the
+ * dosfs.c code.  The intent is that this be a template for other
+ * "fs-ish" commands within uMon (refer to discussion at the top of this
+ * file).
+ */
+int
+FatfsCmd(int argc, char *argv[])
+{
+	uint32_t i, j;
+	int		opt, verbose;
+	char	*cmd, *env, *arg1, *arg2, *arg3;
+
+	/* Establish default read/write functions to access underlying
+	 * storage media.  These defaults can be overridden by the 
+	 * command line options -r & -w below.
+	 */
+	if ((env = getenv("FATFS_RD")) != 0)
+		fatfsRead = (int(*)(int,char*,int,int))strtol(env,0,0);
+
+	if ((env = getenv("FATFS_WR")) != 0)
+		fatfsWrite = (int(*)(int,char*,int,int))strtol(env,0,0);
+
+	verbose = 0;
+	fatfs_tmp_space = (char *)0xffffffff;
+	while ((opt=getopt(argc,argv,"r:s:vw:")) != -1) {
+		switch(opt) {
+			case 'r':
+				fatfsRead = (int(*)(int,char*,int,int))strtoul(optarg,0,0);
+				break;
+			case 's':
+				fatfs_tmp_space = (char *)strtoul(optarg,0,0);
+				break;
+			case 'w':
+				fatfsWrite = (int(*)(int,char*,int,int))strtoul(optarg,0,0);
+				break;
+			case 'v':
+				verbose++;
+				break;
+			default:
+				return(CMD_PARAM_ERROR);
+		}
+	}
+
+	if ((fatfsRead == 0) || (fatfsWrite == 0)) {
+		printf("FATFS access pointers not initialized\n");
+		return(CMD_FAILURE);
+	}
+
+	if (argc < optind + 1)
+		return(CMD_PARAM_ERROR);
+
+	if (fatfs_tmp_space == (char *)0xffffffff)
+		fatfs_tmp_space = (char *)getAppRamStart();
+
+	cmd = argv[optind];
+	arg1 = argv[optind+1];
+	arg2 = argv[optind+2];
+	arg3 = argv[optind+3];
+
+	if (strcmp(cmd,"init") == 0) {
+		if (fatfsInit(1,verbose) < 0)
+			return(CMD_FAILURE);
+	}
+	else if (strcmp(cmd,"cat") == 0) {
+		if (argc != optind + 2) 
+			return(CMD_PARAM_ERROR);
+
+		if (fatfsInit(0,0) < 0)
+			return(CMD_FAILURE);
+
+		for(i=optind+1;i<argc;i++) {
+			if (fatfsCat(argv[i]) < 0)
+				return(CMD_FAILURE);
+		}
+	}
+	else if (strcmp(cmd,"get") == 0) {
+		if (argc != optind + 3) 
+			return(CMD_PARAM_ERROR);
+
+		if (fatfsInit(0,0) < 0)
+			return(CMD_FAILURE);
+
+		if (fatfsGet(arg1,arg2) < 0)
+			return(CMD_FAILURE);
+
+	}
+	else if (strcmp(cmd,"put") == 0) {
+		if (argc != optind + 3) 
+			return(CMD_PARAM_ERROR);
+
+		if (fatfsInit(0,0) < 0)
+			return(CMD_FAILURE);
+
+		if (fatfsPut(arg1,arg2) < 0)
+			return(CMD_FAILURE);
+	}
+	else if (strcmp(cmd,"qry") == 0) {
+		if (argc != optind + 2) 
+			return(CMD_PARAM_ERROR);
+
+		if (fatfsInit(0,0) < 0)
+			return(CMD_FAILURE);
+
+		if (fatfsQry(arg1,verbose) < 0)
+			return(CMD_FAILURE);
+	}
+	else if (strcmp(cmd,"ls") == 0) {
+		if (fatfsInit(0,0) < 0)
+			return(CMD_FAILURE);
+
+		if (fatfsLs(arg1) < 0)
+			return(CMD_FAILURE);
+	}
+	else if (strcmp(cmd,"rm") == 0) {
+		if (fatfsInit(0,0) < 0)
+			return(CMD_FAILURE);
+
+		for(j=optind+1;j<argc;j++) {
+			if (fatfsRm(argv[j]) < 0)
+				return(CMD_FAILURE);
+		}
+	}
+	else {
+		printf("fatfs op <%s> not found\n",cmd);
+		return(CMD_FAILURE);
+	}
+
+	return(CMD_SUCCESS);
+}
+
+/* Hookup between DOSFS and this command...
+ * The dosfs.c code requires that the user provide two functions
+ * (DFS_ReadSector() and DFS_WriteSector()) to hook it up to an
+ * external interface.  These two functions are configured by
+ * the fatfs command to point to whatever driver is to be established
+ * as the FATFS physical interface.  For more information refer to the
+ * discussion at the top of this file.
+ */
+uint32_t
+DFS_ReadSector(uint8_t unit, uint8_t *data, uint32_t sec,uint32_t count)
+{
+	return((uint32_t)fatfsRead((int)unit, (char *)data, sec, count));
+}
+
+uint32_t
+DFS_WriteSector(uint8_t unit, uint8_t *data, uint32_t sec,uint32_t count)
+{
+	return((uint32_t)fatfsWrite((int)unit, (char *)data, sec, count));
+}
+
+#endif
diff --git a/ports/beagleboneblack/Makefile b/ports/beagleboneblack/Makefile
index e0676b1..11956db 100644
--- a/ports/beagleboneblack/Makefile
+++ b/ports/beagleboneblack/Makefile
@@ -39,7 +39,7 @@ endif
 
 LIBABIDIR       = -L $(ABIDIR)
 COMMON_AFLAGS	= -c -D PLATFORM_$(PLATFORM)=1 -D ASSEMBLY_ONLY 
-CUSTOM_CFLAGS	= -mcpu=cortex-a8 -O2 -isystem $(ABIDIR)/include -Wno-char-subscripts
+CUSTOM_CFLAGS	= -mcpu=cortex-a8 -O2 -isystem $(ABIDIR)/include -Wno-char-subscripts -mno-unaligned-access
 
 
 ###############################################################################
@@ -48,7 +48,7 @@ CUSTOM_CFLAGS	= -mcpu=cortex-a8 -O2 -isystem $(ABIDIR)/include -Wno-char-subscri
 # The following variables are used to establish the system's memory map.
 # 
 BOOTROMBASE=0x402F0400
-BOOTROMLEN=0x010000
+BOOTROMLEN=0x01b000
 BOOTRAMBASE=0x80000000
 BOOTRAMLEN=0x010000
 RAMTSTROMBASE=0x80100000
@@ -75,7 +75,7 @@ COMCSRC		= arp.c cast.c cache.c chario.c cmdtbl.c \
 			  reg_cache.c sbrk.c sd.c \
 			  start.c struct.c symtbl.c syslog.c tcpstuff.c tfs.c tfsapi.c \
 			  tfsclean1.c tfscli.c tfsloader.c tfslog.c tftp.c timestuff.c \
-			  tsi.c xmodem.c
+			  tsi.c xmodem.c dosfs.c fatfs.c
 CPUCSRC		= except_arm.c misc_arm.c strace_arm.c 
 IODEVSRC	= uart16550.c
 FLASHSRC	=
diff --git a/ports/beagleboneblack/config.h b/ports/beagleboneblack/config.h
index 2592fdf..b0136c3 100644
--- a/ports/beagleboneblack/config.h
+++ b/ports/beagleboneblack/config.h
@@ -176,7 +176,7 @@
 #define INCLUDE_PROFILER        0
 #define INCLUDE_BBC             0
 #define INCLUDE_STOREMAC        0
-#define INCLUDE_SHELLVARS       0
+#define INCLUDE_SHELLVARS       1
 #define INCLUDE_MALLOC          0
 #define INCLUDE_PORTCMD         0
 #define INCLUDE_SYSLOG          0
@@ -191,6 +191,7 @@
 #define INCLUDE_SD              1
 #define INCLUDE_DNS             0
 #define INCLUDE_BLINKLED        1
+#define INCLUDE_FATFS		1
 #define TARGET_BLINKLED         target_blinkled
 
 /* Inclusion of this next file will make sure that all of the above