/*********************************************************************
*
* Microchip File System Implementaion on PIC18
*
*********************************************************************
* FileName: MPFS.c
* Dependencies: StackTsk.h
* MPFS.h
* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
* Complier: Microchip C18 v3.02 or higher
* Microchip C30 v2.01 or higher
* Company: Microchip Technology, Inc.
*
* Software License Agreement
*
* This software is owned by Microchip Technology Inc. ("Microchip")
* and is supplied to you for use exclusively as described in the
* associated software agreement. This software is protected by
* software and other intellectual property laws. Any use in
* violation of the software license may subject the user to criminal
* sanctions as well as civil liability. Copyright 2006 Microchip
* Technology Inc. All rights reserved.
*
* This software is provided "AS IS." MICROCHIP DISCLAIMS ALL
* WARRANTIES, EXPRESS, IMPLIED, STATUTORY OR OTHERWISE, NOT LIMITED
* TO MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
* INFRINGEMENT. Microchip shall in no event be liable for special,
* incidental, or consequential damages.
*
*
* Author Date Comment
*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* Nilesh Rajbharti 8/14/01 Original (Rev. 1.0)
* Nilesh Rajbharti 2/9/02 Cleanup
* Nilesh Rajbharti 5/22/02 Rev 2.0 (See version.log for detail)
* Howard Schlunder 3/31/05 Changed MPFS_ENTRY and mpfs_Flags for C30
********************************************************************/
#define THIS_IS_MPFS
#include <string.h>
#include <stdlib.h>
#include "..\Include\MPFS.h"
#include "..\Include\Helpers.h"
#if defined(MPFS_USE_EEPROM)
#include "..\Include\XEEPROM.h"
#endif
// This file system supports short file names i.e. 8 + 3.
#define MAX_FILE_NAME_LEN (12u)
#define MPFS_DATA (0x00u)
#define MPFS_DELETED (0x01u)
#define MPFS_DLE (0x03u)
#define MPFS_ETX (0x04u)
/*
* MPFS Structure:
*
* MPFS_Start:
* <MPFS_DATA><Address1><FileName1>
* <MPFS_DATA><Address2><FileName2>
* ...
* <MPFS_ETX><Addressn><FileNamen>
* Address1:
* <Data1>[<Data2>...<Datan>]<MPFS_ETX><MPFS_INVALID>
* ...
*
* Note: If File data contains either MPFS_DLE or MPFS_ETX
* extra MPFS_DLE is stuffed before that byte.
*/
#ifdef MPFS_USE_PGRM
typedef struct _MPFS_ENTRY
{
BYTE Flag;
MPFS Address;
BYTE Name[MAX_FILE_NAME_LEN];
} MPFS_ENTRY;
#else //MPFS_USE_EEPROM
typedef struct _MPFS_ENTRY
{
BYTE Flag __attribute__((__packed__));
MPFS Address __attribute__((__packed__));
BYTE Name[MAX_FILE_NAME_LEN] __attribute__((__packed__));
} MPFS_ENTRY;
#endif
static union
{
struct
{
unsigned char bNotAvailable : 1;
} bits;
BYTE Val;
} mpfsFlags;
BYTE mpfsOpenCount;
#if defined(MPFS_USE_PGRM)
// An address where MPFS data starts in program memory.
extern MPFS MPFS_Start;
#else
#define MPFS_Start MPFS_RESERVE_BLOCK
#endif
MPFS _currentHandle;
MPFS _currentFile;
BYTE _currentCount;
/*********************************************************************
* Function: BOOL MPFSInit(void)
*
* PreCondition: None
*
* Input: None
*
* Output: TRUE, if MPFS Storage access is initialized and
* MPFS is ready to be used.
* FALSE otherwise
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
BOOL MPFSInit(void)
{
mpfsOpenCount = 0;
mpfsFlags.Val = 0;
#if defined(MPFS_USE_PGRM)
return TRUE;
#else
/*
* Initialize the EEPROM access routines.
* Use ~ 400 Khz.
*/
XEEInit(EE_BAUD(CLOCK_FREQ, 400000));
return TRUE;
#endif
}
/*********************************************************************
* Function: MPFS MPFSOpen(BYTE* file)
*
* PreCondition: None
*
* Input: file - NULL terminated file name.
*
* Output: A handle if file is found
* MPFS_INVALID if file is not found.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
MPFS MPFSOpen(BYTE* file)
{
MPFS_ENTRY entry;
MPFS FAT;
BYTE fileNameLen;
if( mpfsFlags.bits.bNotAvailable )
return MPFS_NOT_AVAILABLE;
#if defined(MPFS_USE_PGRM)
FAT = (MPFS)&MPFS_Start;
#else
FAT = MPFS_Start;
#endif
// If string is empty, do not attempt to find it in FAT.
if ( *file == '\0' )
return MPFS_INVALID;
file = (BYTE*)strupr((char*)file);
while(1)
{
#if defined(MPFS_USE_PGRM)
// Bring current FAT entry into RAM.
memcpypgm2ram(&entry, (ROM void*)FAT, sizeof(entry));
#else
XEEReadArray(EEPROM_CONTROL, FAT, (unsigned char*)&entry, sizeof(entry));
#endif
// Make sure that it is a valid entry.
if (entry.Flag == MPFS_DATA)
{
// Does the file name match ?
fileNameLen
= strlen((char*)file
); if ( fileNameLen > MAX_FILE_NAME_LEN )
fileNameLen = MAX_FILE_NAME_LEN;
if( memcmp((void*)file
, (void*)entry.
Name, fileNameLen
) == 0 ) {
_currentFile = (MPFS)entry.Address;
mpfsOpenCount++;
return entry.Address;
}
// File does not match. Try next entry...
FAT += sizeof(entry);
}
else if ( entry.Flag == MPFS_ETX )
{
if ( entry.Address != (MPFS)MPFS_INVALID )
FAT = (MPFS)entry.Address;
else
break;
}
else
return (MPFS)MPFS_INVALID;
}
return (MPFS)MPFS_INVALID;
}
/*********************************************************************
* Function: void MPFSClose(void)
*
* PreCondition: None
*
* Input: handle - File handle to be closed
*
* Output: None
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
void MPFSClose(void)
{
_currentCount = 0;
mpfsFlags.bits.bNotAvailable = FALSE;
if ( mpfsOpenCount )
mpfsOpenCount--;
}
/*********************************************************************
* Function: BOOL MPFSGetBegin(MPFS handle)
*
* PreCondition: MPFSOpen() != MPFS_INVALID &&
*
* Input: handle - handle of file that is to be read
*
* Output: TRUE if successful
* !TRUE otherwise
*
* Side Effects: None
*
* Overview: Prepares MPFS storage media for subsequent reads.
*
* Note: None
********************************************************************/
#if defined(MPFS_USE_EEPROM)
BOOL MPFSGetBegin(MPFS handle)
{
_currentHandle = handle;
return (XEEBeginRead(EEPROM_CONTROL, handle) == XEE_SUCCESS);
}
#endif
/*********************************************************************
* Function: BYTE MPFSGet(void)
*
* PreCondition: MPFSOpen() != MPFS_INVALID &&
* MPFSGetBegin() == TRUE
*
* Input: None
*
* Output: Data byte from current address.
*
* Side Effects: None
*
* Overview: Reads a byte from current address.
*
* Note: Caller must call MPFSIsEOF() to check for end of
* file condition
********************************************************************/
BYTE MPFSGet(void)
{
BYTE t;
#if defined(MPFS_USE_PGRM)
t = (BYTE)*_currentHandle;
#else
t = XEERead();
#endif
_currentHandle++;
if ( t == MPFS_DLE )
{
#if defined(MPFS_USE_PGRM)
t = (BYTE)*_currentHandle;
#else
t = XEERead();
#endif
_currentHandle++;
}
else if ( t == MPFS_ETX )
{
_currentHandle = MPFS_INVALID;
}
return t;
}
/*********************************************************************
* Function: MPFS MPFSGetEnd(void)
*
* PreCondition: MPFSOpen() != MPFS_INVALID &&
* MPFSGetBegin() = TRUE
*
* Input: None
*
* Output: Current mpfs handle.
*
* Side Effects: None
*
* Overview: Ends on-going read cycle.
* MPFS handle that is returned must be used
* for subsequent begin gets..
*
* Note: None
********************************************************************/
#if defined(MPFS_USE_EEPROM)
MPFS MPFSGetEnd(void)
{
XEEEndRead();
return _currentHandle;
}
#endif
/*********************************************************************
* Function: MPFS MPFSFormat(void)
*
* PreCondition: None
*
* Input: None
*
* Output: A valid MPFS handle that can be used for MPFSPut
*
* Side Effects: None
*
* Overview: Prepares MPFS image to get re-written
* Declares MPFS as in use.
*
* Note: MPFS will be unaccessible until MPFSClose is
* called.
********************************************************************/
MPFS MPFSFormat(void)
{
mpfsFlags.bits.bNotAvailable = TRUE;
return (MPFS)MPFS_RESERVE_BLOCK;
}
/*********************************************************************
* Function: BOOL MPFSPutBegin(MPFS handle)
*
* PreCondition: MPFSInit() and MPFSFormat() are already called.
*
* Input: handle - handle to where put to begin
*
* Output: TRUE if successful
* !TRUE otherwise
*
* Side Effects: None
*
* Overview: Prepares MPFS image to get re-written
*
* Note: MPFS will be unaccessible until MPFSClose is
* called.
********************************************************************/
#if defined(MPFS_USE_EEPROM)
BOOL MPFSPutBegin(MPFS handle)
{
//_currentCount = 0;
_currentHandle = handle;
_currentCount = (BYTE)handle;
_currentCount &= (MPFS_WRITE_PAGE_SIZE-1);
return (XEEBeginWrite(EEPROM_CONTROL, handle) == XEE_SUCCESS);
}
#endif
/*********************************************************************
* Function: BOOL MPFSPut(BYTE b)
*
* PreCondition: MPFSFormat() or MPFSCreate() must be called
* MPFSPutBegin() is already called.
*
* Input: b - data to write.
*
* Output: TRUE if successfull
* !TRUE if failed.
*
* Side Effects: Original MPFS handle is no longer valid.
* Updated MPFS handle must be obtained by calling
* MPFSPutEnd().
*
* Overview: None
*
* Note: Actual write may not get started until internal
* write page is full. To ensure that previously
* data gets written, caller must call MPFSPutEnd()
* after last call to MPFSPut().
********************************************************************/
BOOL MPFSPut(BYTE b)
{
#if defined(MPFS_USE_EEPROM)
if ( XEEWrite(b) )
return FALSE;
_currentCount++;
_currentHandle++;
if ( _currentCount >= MPFS_WRITE_PAGE_SIZE )
{
MPFSPutEnd();
XEEBeginWrite(EEPROM_CONTROL, _currentHandle);
}
#endif
return TRUE;
}
/*********************************************************************
* Function: MPFS MPFSPutEnd(void)
*
* PreCondition: MPFSPutBegin() is already called.
*
* Input: None
*
* Output: Up-to-date MPFS handle
*
* Side Effects: Original MPFS handle is no longer valid.
* Updated MPFS handle must be obtained by calling
* MPFSPutEnd().
*
* Overview: None
*
* Note: Actual write may not get started until internal
* write page is full. To ensure that previously
* data gets written, caller must call MPFSPutEnd()
* after last call to MPFSPut().
********************************************************************/
MPFS MPFSPutEnd(void)
{
#if defined(MPFS_USE_EEPROM)
_currentCount = 0;
XEEEndWrite();
while( XEEIsBusy(EEPROM_CONTROL) );
#endif
return _currentHandle;
}
/*********************************************************************
* Function: MPFS MPFSSeek(MPFS_OFFSET offset)
*
* PreCondition: MPFSGetBegin() is already called.
*
* Input: offset - Offset from current pointer
*
* Output: New MPFS handle located to given offset
*
* Side Effects: None.
*
* Overview: None
*
* Note: None.
********************************************************************/
MPFS MPFSSeek(MPFS_OFFSET offset)
{
WORD i;
MPFSGetBegin(_currentFile);
i = 0;
while(i++ != offset)
MPFSGet();
MPFSGetEnd();
return _currentHandle;
}