/*********************************************************************
 *
 *	Microchip File System (MPFS) File Access API
 *  Module for Microchip TCP/IP Stack
 *	 -Provides single API for accessing web pages and other files 
 *    from internal program memory or an external serial EEPROM memory
 *	 -Reference: AN833
 *
 *********************************************************************
 * FileName:        MPFS.c
 * Dependencies:    SPIEEPROM.c, SPIFlash.c, or MPFSImg2.c/.s
 * Processor:       PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F, PIC32
 * Compiler:        Microchip C32 v1.05 or higher
 *					Microchip C30 v3.12 or higher
 *					Microchip C18 v3.30 or higher
 *					HI-TECH PICC-18 PRO 9.63PL2 or higher
 * Company:         Microchip Technology, Inc.
 *
 * Software License Agreement
 *
 * Copyright (C) 2002-2009 Microchip Technology Inc.  All rights
 * reserved.
 *
 * Microchip licenses to you the right to use, modify, copy, and
 * distribute:
 * (i)  the Software when embedded on a Microchip microcontroller or
 *      digital signal controller product ("Device") which is
 *      integrated into Licensee's product; or
 * (ii) ONLY the Software driver source files ENC28J60.c, ENC28J60.h,
 *		ENCX24J600.c and ENCX24J600.h ported to a non-Microchip device
 *		used in conjunction with a Microchip ethernet controller for
 *		the sole purpose of interfacing with the ethernet controller.
 *
 * You should refer to the license agreement accompanying this
 * Software for additional information regarding your rights and
 * obligations.
 *
 * THE SOFTWARE AND DOCUMENTATION ARE PROVIDED "AS IS" WITHOUT
 * WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
 * LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
 * MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
 * CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
 * PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
 * BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
 * THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
 * SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
 * (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
 *
 *
 * Author               Date        Comment
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * Elliott Wood			07/2007		Complete rewrite as MPFS2
 * E. Wood				04/2008		Updated as MPFS2.1
 ********************************************************************/
#define __MPFS2_C

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_MPFS2)

//Supports long file names to 64 characters
#define MAX_FILE_NAME_LEN   (64u)

/*
 * MPFS Structure:
 *     [M][P][F][S]
 *     [BYTE Ver Hi][BYTE Ver Lo][WORD Number of Files]
 *     [Name Hash 0][Name Hash 1]...[Name Hash N]
 *     [File Record 0][File Record 1]...[File Record N]
 *     [String 0][String 1]...[String N]
 *     [File Data 0][File Data 1]...[File Data N]
 *
 * Name Hash (2 bytes):
 *     hash = 0
 *     for each(byte in name)
 *         hash += byte
 *         hash <<= 1
 *
 *     Technically this means the hash only includes the 
 *     final 15 characters of a name.
 *
 * File Record Structure (22 bytes):
 *     [DWORD String Ptr][DWORD Data Ptr]
 *     [DWORD Len][DWORD Timestamp][DWORD Microtime]
 *     [WORD Flags]
 *
 *     Pointers are absolute addresses within the MPFS image.
 *     Timestamp is the UNIX timestamp
 *     Microtime is currently unimplemented
 *
 * String Structure (1 to 64 bytes):
 *     ["path/to/file.ext"][0x00]
 *
 * File Data Structure (arbitrary length):
 *		[File Data]
 *
 * Unlike previous versions, there are no delimiters.
 *
 * Name hash is calculated as follows:
 *      hash = 0
 *      for each(byte in name)
 *          hash += byte, hash <<= 1
 *
 * When a file has an index, that index file has no file name,
 * but is accessible as the file immediately following in the image.
 *
 * Current version is 2.1
 */

/****************************************************************************
  Section:
	Module-Only Globals and Functions
  ***************************************************************************/
  
// Track the MPFS File Handles
// MPFSStubs[0] is reserved for internal use (FAT access)
static MPFS_STUB MPFSStubs[MAX_MPFS_HANDLES+1];

// Allows the MPFS to be locked, preventing access during updates
static BOOL isMPFSLocked;

// FAT record cache
static MPFS_FAT_RECORD fatCache;

// ID of currently loaded fatCache
static WORD fatCacheID;

// Number of files in this MPFS image
static WORD numFiles;


static void _LoadFATRecord(WORD fatID);
static void _Validate(void);

/****************************************************************************
  Section:
	EEPROM vs Flash Storage Settings
  ***************************************************************************/
  
#if defined(MPFS_USE_EEPROM)

	// Beginning address of MPFS Image
	#define MPFS_HEAD		MPFS_RESERVE_BLOCK

	// Track the last read address to prevent unnecessary
	// data overhead to switch locations.
	MPFS_PTR lastRead;


#elif defined(MPFS_USE_SPI_FLASH)

	// Beginning address of MPFS Image
	#define MPFS_HEAD		MPFS_RESERVE_BLOCK
	
#else

	// An address where MPFS data starts in program memory.
    #if defined(__18CXX) || defined(__C32__)
  		extern ROM BYTE MPFS_Start[];
	    #define MPFS_HEAD		((DWORD)(&MPFS_Start[0]))
    #else
	  	extern DWORD MPFS_Start;
	  	#define MPFS_HEAD		MPFS_Start;
    #endif
    
#endif

/****************************************************************************
  Section:
	Stack-Level Functions
  ***************************************************************************/

/*****************************************************************************
  Function:
	void MPFSInit(void)

  Summary:
	Initializes the MPFS module.

  Description:
	Sets all MPFS handles to closed, and initializes access to the EEPROM
	if necessary.

  Precondition:
	None

  Parameters:
	None

  Returns:
	None
	
  Remarks:
	This function is called only one during lifetime of the application.
  ***************************************************************************/
void MPFSInit(void)
{
	BYTE i;
	
	for(i = 1; i <= MAX_MPFS_HANDLES; i++)
	{
		MPFSStubs[i].addr = MPFS_INVALID;
	}
	
	#if defined(MPFS_USE_EEPROM)
    // Initialize the EEPROM access routines.
    XEEInit();
	lastRead = MPFS_INVALID;
	#endif

	// Validate the image and load numFiles
	_Validate();

	isMPFSLocked = FALSE;

}

/****************************************************************************
  Section:
	Handle Management Functions
  ***************************************************************************/

/*****************************************************************************
  Function:
	MPFS_HANDLE MPFSOpen(BYTE* cFile)

  Description:
	Opens a file in the MPFS2 file system.
	
  Precondition:
	None

  Parameters:
	cFile - a null terminated file name to open

  Returns:
	An MPFS_HANDLE to the opened file if found, or MPFS_INVALID_HANDLE
	if the file could not be found or no free handles exist.
  ***************************************************************************/
MPFS_HANDLE MPFSOpen(BYTE* cFile)
{
	MPFS_HANDLE hMPFS;
	WORD nameHash, i;
	WORD hashCache[8];
	BYTE *ptr, c;
	
	// Initialize c to avoid "may be used uninitialized" compiler warning
	c = 0;
	
	// Make sure MPFS is unlocked and we got a filename
	if(*cFile == '\0' || isMPFSLocked == TRUE)
		return MPFS_INVALID_HANDLE;

	// Calculate the name hash to speed up searching
	for(nameHash = 0, ptr = cFile; *ptr != '\0'; ptr++)
	{
		nameHash += *ptr;
		nameHash <<= 1;
	}
	
	// Find a free file handle to use
	for(hMPFS = 1; hMPFS <= MAX_MPFS_HANDLES; hMPFS++)
		if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
			break;
	if(hMPFS == MAX_MPFS_HANDLES)
		return MPFS_INVALID_HANDLE;
		
	// Read in hashes, and check remainder on a match.  Store 8 in cache for performance
	for(i = 0; i < numFiles; i++)
	{
		// For new block of 8, read in data
		if((i & 0x07) == 0u)
		{
			MPFSStubs[0].addr = 8 + i*2;
			MPFSStubs[0].bytesRem = 16;
			MPFSGetArray(0, (BYTE*)hashCache, 16);
		}
		
		// If the hash matches, compare the full filename
		if(hashCache[i&0x07] == nameHash)
		{
			_LoadFATRecord(i);
			MPFSStubs[0].addr = fatCache.string;
			MPFSStubs[0].bytesRem = 255;
			
			// Loop over filename to perform comparison
			for(ptr = cFile; *ptr != '\0'; ptr++)
			{
				MPFSGet(0, &c);
				if(*ptr != c)
					break;
			}
			
			MPFSGet(0, &c);

			if(c == '\0' && *ptr == '\0')
			{// Filename matches, so return true
				MPFSStubs[hMPFS].addr = fatCache.data;
				MPFSStubs[hMPFS].bytesRem = fatCache.len;
				MPFSStubs[hMPFS].fatID = i;
				return hMPFS;
			}
		}
	}
	
	// No file name matched, so return nothing
	return MPFS_INVALID_HANDLE;
}

/*****************************************************************************
  Function:
	MPFS_HANDLE MPFSOpenROM(ROM BYTE* cFile) 

  Description:
	Opens a file in the MPFS2 file system.
	
  Precondition:
	None

  Parameters:
	cFile - a null terminated file name to open

  Returns:
	An MPFS_HANDLE to the opened file if found, or MPFS_INVALID_HANDLE
	if the file could not be found or no free handles exist.

  Remarks:
	This function is aliased to MPFSOpen on non-PIC18 platforms.
  ***************************************************************************/
#if defined(__18CXX)
MPFS_HANDLE MPFSOpenROM(ROM BYTE* cFile) 
{
	MPFS_HANDLE hMPFS;
	WORD nameHash, i;
	WORD hashCache[8];
	ROM BYTE *ptr;
	BYTE c;
	
	// Make sure MPFS is unlocked and we got a filename
	if(*cFile == '\0' || isMPFSLocked == TRUE)
		return MPFS_INVALID_HANDLE;

	// Calculate the name hash to speed up searching
	for(nameHash = 0, ptr = cFile; *ptr != '\0'; ptr++)
	{
		nameHash += *ptr;
		nameHash <<= 1;
	}
	
	// Find a free file handle to use
	for(hMPFS = 1; hMPFS <= MAX_MPFS_HANDLES; hMPFS++)
		if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
			break;
	if(hMPFS == MAX_MPFS_HANDLES)
		return MPFS_INVALID_HANDLE;
		
	// Read in hashes, and check remainder on a match.  Store 8 in cache for performance
	for(i = 0; i < numFiles; i++)
	{
		// For new block of 8, read in data
		if((i & 0x07) == 0u)
		{
			MPFSStubs[0].addr = 8 + i*2;
			MPFSStubs[0].bytesRem = 16;
			MPFSGetArray(0, (BYTE*)hashCache, 16);
		}
		
		// If the hash matches, compare the full filename
		if(hashCache[i&0x07] == nameHash)
		{
			_LoadFATRecord(i);
			MPFSStubs[0].addr = fatCache.string;
			MPFSStubs[0].bytesRem = 255;
			
			// Loop over filename to perform comparison
			for(ptr = cFile; *ptr != '\0'; ptr++)
			{
				MPFSGet(0, &c);
				if(*ptr != c)
					break;
			}
			
			MPFSGet(0, &c);

			if(c == '\0' && *ptr == '\0')
			{// Filename matches, so return true
				MPFSStubs[hMPFS].addr = fatCache.data;
				MPFSStubs[hMPFS].bytesRem = fatCache.len;
				MPFSStubs[hMPFS].fatID = i;
				return hMPFS;
			}
		}
	}
	
	// No file name matched, so return nothing
	return MPFS_INVALID_HANDLE;
}
#endif

/*****************************************************************************
  Function:
	MPFS_HANDLE MPFSOpenID(WORD hFatID)

  Summary:
	Quickly re-opens a file.

  Description:
	Quickly re-opens a file in the MPFS2 file system.  Use this function
	along with MPFSGetID() to quickly re-open a file without tying up
	a permanent MPFSStub.
	
  Precondition:
	None

  Parameters:
	hFatID - the ID of a previous opened file in the FAT

  Returns:
	An MPFS_HANDLE to the opened file if found, or MPFS_INVALID_HANDLE
	if the file could not be found or no free handles exist.
  ***************************************************************************/
MPFS_HANDLE MPFSOpenID(WORD hFatID)
{
	MPFS_HANDLE hMPFS;
	
	// Make sure MPFS is unlocked and we got a valid id
	if(isMPFSLocked == TRUE || hFatID > numFiles)
		return MPFS_INVALID_HANDLE;

	// Find a free file handle to use
	for(hMPFS = 1; hMPFS <= MAX_MPFS_HANDLES; hMPFS++)
		if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
			break;
	if(hMPFS == MAX_MPFS_HANDLES)
		return MPFS_INVALID_HANDLE;
	
	// Load the FAT record
	_LoadFATRecord(hFatID);
		
	// Set up the file handle
	MPFSStubs[hMPFS].fatID = hFatID;
	MPFSStubs[hMPFS].addr = fatCache.data;
	MPFSStubs[hMPFS].bytesRem = fatCache.len;
	
	return hMPFS;
}

/*****************************************************************************
  Function:
	void MPFSClose(MPFS_HANDLE hMPFS)

  Summary:
	Closes a file.

  Description:
	Closes a file and releases its stub back to the pool of available 
	handles.
	
  Precondition:
	None

  Parameters:
	hMPFS - the file handle to be closed

  Returns:
	None
  ***************************************************************************/
void MPFSClose(MPFS_HANDLE hMPFS)
{
	if(hMPFS != 0u && hMPFS <= MAX_MPFS_HANDLES)
	    MPFSStubs[hMPFS].addr = MPFS_INVALID;
}


/****************************************************************************
  Section:
	Data Reading Functions
  ***************************************************************************/

/*****************************************************************************
  Function:
	BOOL MPFSGet(MPFS_HANDLE hMPFS, BYTE* c)

  Description:
	Reads a byte from a file.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read
	c - Where to store the byte that was read

  Return Values:
	TRUE - The byte was successfully read
	FALSE - No byte was read because either the handle was invalid or
	        the end of the file has been reached.
  ***************************************************************************/
BOOL MPFSGet(MPFS_HANDLE hMPFS, BYTE* c)
{
	// Make sure we're reading a valid address
	if(hMPFS > MAX_MPFS_HANDLES)
		return FALSE;
	if(	MPFSStubs[hMPFS].addr == MPFS_INVALID ||
		MPFSStubs[hMPFS].bytesRem == 0u)
		return FALSE;

	if(c == NULL)
	{
		MPFSStubs[hMPFS].addr++;
		MPFSStubs[hMPFS].bytesRem--;
		return TRUE;
	}


    // Read function for EEPROM
    #if defined(MPFS_USE_EEPROM)
	    // For performance, cache the last read address
		if(MPFSStubs[hMPFS].addr != lastRead+1)
			XEEBeginRead(MPFSStubs[hMPFS].addr + MPFS_HEAD);
		*c = XEERead();
		lastRead = MPFSStubs[hMPFS].addr;
		MPFSStubs[hMPFS].addr++;
	#else
		#if defined(__C30__)
		{
			DWORD addr;
			DWORD_VAL read;
			BYTE i;
	
			// MPFS Images are addressed by the byte; Program memory by the word.
			//
			// Flash program memory is 24 bits wide and only even words are
			// implemented.  The upper byte of the upper word is read as 0x00.
			// Address in program memory of any given byte is (MPFSAddr * 2) / 3
			//
			// We will read 24 bits at a time, but need to support using only 
			// fractions of the first and last byte.
			
			// Find the beginning address in program memory.
			addr = (MPFSStubs[hMPFS].addr / 3) << 1;
			
			// Find where to start in that first 3 bytes
			read.Val = (addr * 3) >> 1;
			if(read.Val == MPFSStubs[hMPFS].addr)
				i = 0;
			else if(read.Val+1 == MPFSStubs[hMPFS].addr)
				i = 1;
			else
				i = 2;
	
			// Add in the MPFS starting address offset
			addr += MPFS_HEAD;
			
			// Update the MPFS Handle
			MPFSStubs[hMPFS].addr++;
			
			// Read the DWORD 
			read.Val = ReadProgramMemory(addr & 0x00FFFFFF);
			*c = read.v[i];
			
		}
		#else
		{
			DWORD dwHITECHWorkaround = MPFS_HEAD;
	  	*c = *((ROM BYTE*)(MPFSStubs[hMPFS].addr+dwHITECHWorkaround));
		    MPFSStubs[hMPFS].addr++;
		}
		#endif
	#endif
	
	MPFSStubs[hMPFS].bytesRem--;
	return TRUE;
}

/*****************************************************************************
  Function:
	WORD MPFSGetArray(MPFS_HANDLE hMPFS, BYTE* cData, WORD wLen)

  Description:
	Reads a series of bytes from a file.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read
	cData - where to store the bytes that were read
	wLen - how many bytes to read

  Returns:
	The number of bytes successfully read.  If this is less than wLen, 
	an EOF occurred while attempting to read.
  ***************************************************************************/
WORD MPFSGetArray(MPFS_HANDLE hMPFS, BYTE* cData, WORD wLen)
{	
	// Make sure we're reading a valid address
	if(hMPFS > MAX_MPFS_HANDLES)
		return 0;
		
	// Determine how many we can actually read
	if(wLen > MPFSStubs[hMPFS].bytesRem)
		wLen = MPFSStubs[hMPFS].bytesRem;

	// Make sure we're reading a valid address
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID || wLen == 0u)
		return 0;
		
	if(cData == NULL)
	{
		MPFSStubs[hMPFS].addr += wLen;
		MPFSStubs[hMPFS].bytesRem -= wLen;
		return wLen;
	}
	
	// Read the data
	#if defined(MPFS_USE_EEPROM)
		XEEReadArray(MPFSStubs[hMPFS].addr+MPFS_HEAD, cData, wLen);
		MPFSStubs[hMPFS].addr += wLen;
		MPFSStubs[hMPFS].bytesRem -= wLen;
		lastRead = MPFS_INVALID;
	#else
		#if defined(__C30__)
		{
			DWORD addr;
			DWORD_VAL read;
			WORD count;
			BYTE i;
	
			// MPFS Images are addressed by the byte; Program memory by the word.
			//
			// Flash program memory is 24 bits wide and only even words are
			// implemented.  The upper byte of the upper word is read as 0x00.
			// Address in program memory of any given byte is (MPFSAddr * 2) / 3
			//
			// We will read 24 bits at a time, but need to support using only 
			// fractions of the first and last byte.
			
			// Find the beginning address in program memory.
			addr = (MPFSStubs[hMPFS].addr / 3) << 1;
			
			// Find where to start in that first 3 bytes
			read.Val = (addr * 3) >> 1;
			if(read.Val == MPFSStubs[hMPFS].addr)
				i = 0;
			else if(read.Val+1 == MPFSStubs[hMPFS].addr)
				i = 1;
			else
				i = 2;
	
			// Add in the MPFS starting address offset
			addr += MPFS_HEAD;
			
			// Update the MPFS Handle
			MPFSStubs[hMPFS].addr += wLen;
			MPFSStubs[hMPFS].bytesRem -= wLen;
	
			// Read the first DWORD 
			read.Val = ReadProgramMemory(addr & 0x00FFFFFF);
			addr += 2;
	
			// Copy values as needed
			for(count = wLen; count > 0; cData++, count--)
			{
				// Copy the next value in
				*cData = read.v[i++];
				
				// Check if a new DWORD is needed
				if(i == 3 && count != 1)
				{// Read in a new DWORD
					read.Val = ReadProgramMemory(addr & 0x00FFFFFF);
					addr += 2;
					i = 0;
				}
			}
			
		}
		#else
		{
			DWORD dwHITECHWorkaround = MPFS_HEAD;
			memcpypgm2ram(cData, (ROM void*)(MPFSStubs[hMPFS].addr + dwHITECHWorkaround), wLen);
			MPFSStubs[hMPFS].addr += wLen;
			MPFSStubs[hMPFS].bytesRem -= wLen;
		}
		#endif
	#endif
	
	return wLen;
}

/*****************************************************************************
  Function:
	BOOL MPFSGetLong(MPFS_HANDLE hMPFS, DWORD* ul)

  Description:
	Reads a DWORD or Long value from the MPFS.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read
	ul - where to store the DWORD or long value that was read

  Returns:
	TRUE - The byte was successfully read
	FALSE - No byte was read because either the handle was invalid or
	        the end of the file has been reached.
  ***************************************************************************/
BOOL MPFSGetLong(MPFS_HANDLE hMPFS, DWORD* ul)
{
	return ( MPFSGetArray(hMPFS, (BYTE*)ul, 4) == 4u );
}

/*****************************************************************************
  Function:
	BOOL MPFSSeek(MPFS_HANDLE hMPFS, DWORD dwOffset, MPFS_SEEK_MODE tMode)

  Description:
	Moves the current read pointer to a new location.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle to seek with
	dwOffset - offset from the specified position in the specified direction
	tMode - one of the MPFS_SEEK_MODE constants

  Returns:
	TRUE - the seek was successful
	FALSE - either the new location or the handle itself was invalid
  ***************************************************************************/
BOOL MPFSSeek(MPFS_HANDLE hMPFS, DWORD dwOffset, MPFS_SEEK_MODE tMode)
{
	DWORD temp;
	
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return FALSE;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return FALSE;

	switch(tMode)
	{
		// Seek offset bytes from start
		case MPFS_SEEK_START:
			temp = MPFSGetSize(hMPFS);
			if(dwOffset > temp)
				return FALSE;
			
			MPFSStubs[hMPFS].addr = MPFSGetStartAddr(hMPFS) + dwOffset;
			MPFSStubs[hMPFS].bytesRem = temp - dwOffset;
			return TRUE;
		
		// Seek forwards offset bytes
		case MPFS_SEEK_FORWARD:
			if(dwOffset > MPFSStubs[hMPFS].bytesRem)
				return FALSE;
			
			MPFSStubs[hMPFS].addr += dwOffset;
			MPFSStubs[hMPFS].bytesRem -= dwOffset;
			return TRUE;
		
		// Seek backwards offset bytes
		case MPFS_SEEK_REWIND:
			temp = MPFSGetStartAddr(hMPFS);
			if(MPFSStubs[hMPFS].addr < temp + dwOffset)
				return FALSE;
			
			MPFSStubs[hMPFS].addr -= dwOffset;
			MPFSStubs[hMPFS].bytesRem += dwOffset;
			return TRUE;
		
		// Seek so that offset bytes remain in file
		case MPFS_SEEK_END:
			temp = MPFSGetSize(hMPFS);
			if(dwOffset > temp)
				return FALSE;
			
			MPFSStubs[hMPFS].addr = MPFSGetEndAddr(hMPFS) - dwOffset;
			MPFSStubs[hMPFS].bytesRem = dwOffset;
			return TRUE;
		
		default:
			return FALSE;
	}
}


/****************************************************************************
  Section:
	Data Writing Functions
  ***************************************************************************/

/*****************************************************************************
  Function:
	MPFS_HANDLE MPFSFormat(void)
	
  Summary:
	Prepares the MPFS image for writing.

  Description:
	Prepares the MPFS image for writing and locks the image so that other
	processes may not access it.
	
  Precondition:
	None

  Parameters:
	None

  Returns:
	An MPFS handle that can be used for MPFSPut commands, or 
	MPFS_INVALID_HANDLE when the EEPROM failed to initialize for writing.

  Remarks:
	In order to prevent misreads, the MPFS will be inaccessible until 
	MPFSClose is called.  This function is not available when the MPFS 
	is stored in internal Flash program memory.
  ***************************************************************************/
#if defined(MPFS_USE_EEPROM) || defined(MPFS_USE_SPI_FLASH)
MPFS_HANDLE MPFSFormat(void)
{

	BYTE i;
	
	// Close all files
	for(i = 0; i < MAX_MPFS_HANDLES; i++)
		MPFSStubs[i].addr = MPFS_INVALID;
	
	// Lock the image
	isMPFSLocked = TRUE;
	
	#if defined(MPFS_USE_EEPROM)
		// Set FAT ptr for writing
		MPFSStubs[0].addr = 0;
		MPFSStubs[0].fatID = 0xffff;
		MPFSStubs[0].bytesRem = MPFS_WRITE_PAGE_SIZE - ( ((BYTE)MPFSStubs[0].addr+MPFS_HEAD) & (MPFS_WRITE_PAGE_SIZE-1) );
		
		// Set up EEPROM for writing
		if( XEEBeginWrite(MPFSStubs[0].addr+MPFS_HEAD) == XEE_SUCCESS )
			return 0x00;
	
		return MPFS_INVALID_HANDLE;
	#else
		return 0x00;
	#endif
}
#endif
	
/*****************************************************************************
  Function:
	WORD MPFSPutArray(MPFS_HANDLE hMPFS, BYTE *cData, WORD wLen)

  Description:
	Writes an array of data to the MPFS image.
	
  Precondition:
	MPFSFormat was sucessfully called.

  Parameters:
	hMPFS - the file handle for writing
	cData - the array of bytes to write
	wLen - how many bytes to write

  Returns:
	The number of bytes successfully written.

  Remarks:
	For EEPROM, the actual write may not initialize until the internal write 
	page is full.  To ensure that previously written data gets stored, 
	MPFSPutEnd must be called after the last call to MPFSPutArray.
  ***************************************************************************/
#if defined(MPFS_USE_EEPROM) || defined(MPFS_USE_SPI_FLASH)
WORD MPFSPutArray(MPFS_HANDLE hMPFS, BYTE* cData, WORD wLen)
{
	#if defined(MPFS_USE_EEPROM)
		// Write to the EEPROM
		WORD count;
		
		for(count = 0; count < wLen; count++)
		{
			XEEWrite(cData[count]);
			
			MPFSStubs[hMPFS].addr++;
			MPFSStubs[hMPFS].bytesRem--;
			
			if(MPFSStubs[hMPFS].bytesRem == 0u)
			{
				MPFSPutEnd(FALSE);
				isMPFSLocked = TRUE;
				XEEBeginWrite(MPFSStubs[hMPFS].addr+MPFS_HEAD);
				MPFSStubs[hMPFS].bytesRem = MPFS_WRITE_PAGE_SIZE;
			}
		}
		
		return count;
	
	#else
		// Write to the SPI Flash
	#endif
}
#endif

/*****************************************************************************
  Function:
	void MPFSPutEnd(void)

  Description:
	Finalizes an MPFS writing operation.
	
  Precondition:
	MPFSFormat and MPFSPutArray were sucessfully called.

  Parameters:
	final - TRUE if the application is done writing, FALSE if MPFS2 called
		this function locally.

  Returns:
	None
  ***************************************************************************/
#if defined(MPFS_USE_EEPROM) || defined(MPFS_USE_SPI_FLASH)
void MPFSPutEnd(BOOL final)
{
	isMPFSLocked = FALSE;
	
	#if defined(MPFS_USE_EEPROM)
	    XEEEndWrite();
    	while(XEEIsBusy());
    #endif
    
	if(final)
		_Validate();
}
#endif


/****************************************************************************
  Section:
	Meta Data Accessors
  ***************************************************************************/

/*****************************************************************************
  Function:
	static void _LoadFATRecord(WORD fatID)

  Description:
	Loads the FAT record for a specified handle.
	
  Precondition:
	None

  Parameters:
	fatID - the ID of the file whose FAT is to be loaded

  Returns:
	None

  Remarks:
	The FAT record will be stored in fatCache.
  ***************************************************************************/
static void _LoadFATRecord(WORD fatID)
{
	if(fatID == fatCacheID || fatID >= numFiles)
		return;
	
	// Read the FAT record to the cache
	MPFSStubs[0].bytesRem = 22;
	MPFSStubs[0].addr = 8 + numFiles*2 + fatID*22;
	MPFSGetArray(0, (BYTE*)&fatCache, 22);
	fatCacheID = fatID;
}

/*****************************************************************************
  Function:
	DWORD MPFSGetTimestamp(MPFS_HANDLE hMPFS)

  Description:
	Reads the timestamp for the specified file.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read the metadata

  Returns:
	The timestamp that was read as a DWORD
  ***************************************************************************/
DWORD MPFSGetTimestamp(MPFS_HANDLE hMPFS)
{
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return 0x00000000;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return 0x00000000;
	
	// Move to the point for reading
	_LoadFATRecord(MPFSStubs[hMPFS].fatID);
	return fatCache.timestamp;
}

/*****************************************************************************
  Function:
	DWORD MPFSGetMicrotime(MPFS_HANDLE hMPFS)

  Description:
	Reads the microtime portion of a file's timestamp.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read the metadata

  Returns:
	The microtime that was read as a DWORD
  ***************************************************************************/
DWORD MPFSGetMicrotime(MPFS_HANDLE hMPFS)
{
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return 0x00000000;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return 0x00000000;
	
	// Move to the point for reading
	_LoadFATRecord(MPFSStubs[hMPFS].fatID);
	return fatCache.microtime;
}

/*****************************************************************************
  Function:
	WORD MPFSGetFlags(MPFS_HANDLE hMPFS)

  Description:
	Reads a file's flags.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read the metadata

  Returns:
	The flags that were associated with the file
  ***************************************************************************/
WORD MPFSGetFlags(MPFS_HANDLE hMPFS)
{
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return 0x0000;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return 0x0000;
	
	//move to the point for reading
	_LoadFATRecord(MPFSStubs[hMPFS].fatID);
	return fatCache.flags;
}

/*****************************************************************************
  Function:
	DWORD MPFSGetSize(MPFS_HANDLE hMPFS)

  Description:
	Reads the size of a file.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read the metadata

  Returns:
	The size that was read as a DWORD
  ***************************************************************************/
DWORD MPFSGetSize(MPFS_HANDLE hMPFS)
{
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return 0x00000000;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return 0x00000000;
	
	// Move to the point for reading
	_LoadFATRecord(MPFSStubs[hMPFS].fatID);
	return fatCache.len;
}

/*****************************************************************************
  Function:
	DWORD MPFSGetBytesRem(MPFS_HANDLE hMPFS)

  Description:
	Determines how many bytes remain to be read.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read the metadata

  Returns:
	The number of bytes remaining in the file as a DWORD
  ***************************************************************************/
DWORD MPFSGetBytesRem(MPFS_HANDLE hMPFS)
{
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return 0x00000000;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return 0x00000000;
		
	return MPFSStubs[hMPFS].bytesRem;	
}

/*****************************************************************************
  Function:
	MPFS_PTR MPFSGetStartAddr(MPFS_HANDLE hMPFS)

  Description:
	Reads the starting address of a file.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read the metadata

  Returns:
	The starting address of the file in the MPFS image
  ***************************************************************************/
MPFS_PTR MPFSGetStartAddr(MPFS_HANDLE hMPFS)
{
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return 0;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return MPFS_INVALID;
	
	// Move to the point for reading
	_LoadFATRecord(MPFSStubs[hMPFS].fatID);
	return fatCache.data;
}

/*****************************************************************************
  Function:
	MPFS_PTR MPFSGetEndAddr(MPFS_HANDLE hMPFS)

  Description:
	Determines the ending address of a file.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read the metadata

  Returns:
	The address just after the file ends (start address of next file)
  ***************************************************************************/
MPFS_PTR MPFSGetEndAddr(MPFS_HANDLE hMPFS)
{
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return MPFS_INVALID;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return MPFS_INVALID;
	
	// Move to the point for reading
	_LoadFATRecord(MPFSStubs[hMPFS].fatID);
	return fatCache.data + fatCache.len;
}

/*****************************************************************************
  Function:
	BOOL MPFSGetFilename(MPFS_HANDLE hMPFS, BYTE* cName, WORD wLen)

  Description:
	Reads the file name of a file that is already open.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to determine the file name
	cName - where to store the name of the file
	wLen - the maximum length of data to store in cName

  Return Values:
	TRUE - the file name was successfully located
	FALSE - the file handle provided is not currently open
  ***************************************************************************/
BOOL MPFSGetFilename(MPFS_HANDLE hMPFS, BYTE* cName, WORD wLen)
{
	DWORD addr;
	
	// Make sure a valid file is open
	if(hMPFS > MAX_MPFS_HANDLES)
		return FALSE;
	if(MPFSStubs[hMPFS].addr == MPFS_INVALID)
		return FALSE;
	
	// Move to the point for reading
	_LoadFATRecord(MPFSStubs[hMPFS].fatID);
	addr = fatCache.string;
	MPFSStubs[0].addr = addr;
	MPFSStubs[0].bytesRem = 255;
	
	// Read the value and return
	MPFSGetArray(0, cName, wLen);
	return TRUE;
}

/*****************************************************************************
  Function:
	DWORD MPFSGetPosition(MPFS_HANDLE hMPFS)

  Description:
	Determines the current position in the file
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle for which to determine position

  Returns:
	The position in the file as a DWORD (or MPFS_PTR)

  Remarks:
	Calling MPFSSeek(hMPFS, pos, MPFS_SEEK_START) will return the pointer
	to this position at a later time.  (Where pos is the value returned by
	this function.)
  ***************************************************************************/
DWORD MPFSGetPosition(MPFS_HANDLE hMPFS)
{
	return MPFSStubs[hMPFS].addr - MPFSGetStartAddr(hMPFS);
}

/*****************************************************************************
  Function:
	WORD MPFSGetID(MPFS_HANDLE hMPFS)

  Description:
	Determines the ID in the FAT for a file.
	
  Precondition:
	The file handle referenced by hMPFS is already open.

  Parameters:
	hMPFS - the file handle from which to read the metadata

  Returns:
	The ID in the FAT for this file

  Remarks:
	Use this function in association with MPFSOpenID to quickly access file
	without permanently reserving a file handle.
  ***************************************************************************/
WORD MPFSGetID(MPFS_HANDLE hMPFS)
{
	return MPFSStubs[hMPFS].fatID;
}


/****************************************************************************
  Section:
	Utility Functions
  ***************************************************************************/

/*****************************************************************************
  Function:
	void _Validate(void)

  Summary:
	Validates the MPFS Image

  Description:
	Verifies that the MPFS image is valid, and reads the number of 
	available files from the image header.  This function is called on
	boot, and again after any image is written.

  Precondition:
	None

  Parameters:
	None

  Returns:
	None
  ***************************************************************************/
static void _Validate(void)
{
	// If this function causes an Address Error Exception on 16-bit
	// platforms with code stored in internal Flash, make sure your
	// compiler memory model settings are correct.
	//
	// In MPLAB, choose Project Menu > Build Options > Project.
	// Select the MPLAB C30 tab and change Cagetory to Memory Model.
	// Ensure that Large Code Model is selected, and that the remaining
	//   options are set to Default.
	
	// Validate the image and update numFiles
	MPFSStubs[0].addr = 0;
	MPFSStubs[0].bytesRem = 8;
	MPFSGetArray(0, (BYTE*)&fatCache, 6);
	if(!memcmppgm2ram((void*)&fatCache, (ROM void*)"MPFS\x02\x01", 6))
		MPFSGetArray(0, (BYTE*)&numFiles, 2);
	else
		numFiles = 0;
	fatCacheID = MPFS_INVALID_FAT;
}	
#endif //#if defined(STACK_USE_MPFS2)
