/*********************************************************************
*
* Microchip File System
*
*********************************************************************
* FileName: MPFS.h
* Dependencies: StackTsk.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.
*
* This file provides Microchip File System access calls.
*
* 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 5/31/06 Changed EEPROM addressing to 32 bits
********************************************************************/
#ifndef MPFS_H
#define MPFS_H
#include "..\Include\StackTsk.h"
#if defined(MPFS_USE_PGRM)
typedef ROM BYTE* MPFS;
#define MPFS_INVALID (MPFS)(0xffffff)
typedef WORD MPFS_OFFSET;
#else
// typedef DWORD MPFS; // For 32 bit addressing (use /ll option with MPFS.exe)
// #define MPFS_INVALID (0xffffffff)// For 32 bit addressing (use /ll option with MPFS.exe)
typedef WORD MPFS; // For default 16 bit addressing
#define MPFS_INVALID (0xffff) // For default 16 bit addressing
typedef WORD MPFS_OFFSET;
#endif
#define MPFS_NOT_AVAILABLE (0x0)
#if defined(MPFS_USE_EEPROM)
#define MPFS_WRITE_PAGE_SIZE (64)
#elif defined(MPFS_USE_PGRM)
#define MPFS_WRITE_PAGE_SIZE (8)
#endif
/*********************************************************************
* Function: BOOL MPFSInit(void)
*
* PreCondition: None
*
* Input: None
*
* Output: TRUE, if MPFS Storage access is initialized and
* MPFS is is ready to be used.
* FALSE otherwise
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
BOOL MPFSInit(void);
/*********************************************************************
* Function: MPFS MPFSOpen(BYTE* name)
*
* PreCondition: None
*
* Input: name - NULL terminate file name.
*
* Output: MPFS_INVALID if not found
* != MPFS_INVALID if found ok.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
MPFS MPFSOpen(BYTE* name);
/*********************************************************************
* 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);
/*********************************************************************
* 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);
#else
#define MPFSGetBegin(handle) (_currentHandle = handle)
#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);
/*********************************************************************
* 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);
#else
#define MPFSGetEnd() _currentHandle
#endif
/*********************************************************************
* Macro: BOOL MPFSIsEOF(void)
*
* PreCondition: MPFSGetBegin() must be called.
*
* Input: None
*
* Output: TRUE if current file read has reached end of file.
* FALSE if otherwise.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
#define MPFSIsEOF() (_currentHandle == MPFS_INVALID)
/*********************************************************************
* 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);
/*********************************************************************
* 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);
#else
#define MPFSPutBegin(handle) (_currentHandle = handle)
#endif
/*********************************************************************
* Function: BOOL MPFSPut(BYTE b)
*
* PreCondition: MPFSFormat() or MPFSCreate() must be called
*
* Input: b - byte to be written
*
* Output: TRUE if successful
* !TRUE if otherwise
*
* Side Effects: MPFS handle is updated.
*
* Overview: None
*
* Note: Since this function updates internal MPFS handle
* caller must call MPFSPutEnd() to obtain
* up-to-date handle.
********************************************************************/
BOOL MPFSPut(BYTE b);
/*********************************************************************
* 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);
/*********************************************************************
* Macro: BYTE MPFSInUse(void)
*
* PreCondition: None
*
* Input: None
*
* Output: No. of file currently open.
* If == 0, MPFS is not in use.
*
* Side Effects: None
*
* Overview: None
*
* Note: None
********************************************************************/
#if !defined(THIS_IS_MPFS)
extern BYTE mpfsOpenCount;
#endif
/*********************************************************************
* 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);
/*********************************************************************
* Function: MPFS MPFSTell(void)
*
* PreCondition: MPFSOpen() is already called.
*
* Input: None
*
* Output: current MPFS file pointer
*
* Side Effects: None.
*
* Overview: None
*
* Note: None.
********************************************************************/
#define MPFSTell() (_currentHandle)
#define MPFSIsInUse() (mpfsOpenCount)
#if !defined(THIS_IS_MPFS)
extern MPFS _currentHandle;
extern BYTE _currentCount;
#endif
#endif