Microchip%20TCP_IP%20stack/TCPIP%20Stack/MPFS.c

/*********************************************************************
 *
 *      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:    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
 *
 * Copyright © 2002-2007 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 and 
 *      ENC28J60.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
 *~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * 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 __MPFS_C

#include "TCPIP Stack/TCPIP.h"

#if defined(STACK_USE_MPFS)

// 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.
 */
#if defined(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;
#else   //Use program memory
        typedef struct  _MPFS_ENTRY
        {
            BYTE Flag;
            MPFS Address;
            BYTE Name[MAX_FILE_NAME_LEN];
        } MPFS_ENTRY;
        #if defined(__C30__)
                static DWORD ReadProgramMemory(DWORD address);
        #endif
#endif

static union
{
    struct
    {
        unsigned char bNotAvailable : 1;
    } bits;
    BYTE Val;
} mpfsFlags;

BYTE mpfsOpenCount;

#if !defined(MPFS_USE_EEPROM)
        // 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_EEPROM)
    // Initialize the EEPROM access routines.
    XEEInit();
#endif

    return TRUE;
}


/*********************************************************************
 * 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_EEPROM)
    FAT = MPFS_Start;
#else
    FAT = (MPFS)&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)
    {
        // Bring current FAT entry into RAM.
                #if defined(MPFS_USE_EEPROM)
                XEEReadArray(FAT, (unsigned char*)&entry, sizeof(entry));
                #else
                        #if defined(__C30__)
                        memcpypgm2ram(&entry, (ROM void*)(WORD)FAT, sizeof(entry));
                        #else
                        memcpypgm2ram(&entry, (ROM void*)FAT, sizeof(entry));
                        #endif
                #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 hFile)
 *
 * PreCondition:    MPFSOpen() != MPFS_INVALID &&
 *
 * Input:           hFile      - 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 hFile)
{
    _currentHandle = hFile;
    return (XEEBeginRead(hFile) == 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_EEPROM)
            t = XEERead();
            _currentHandle++;
        #else
                #if defined(__C30__)
                        {
                                DWORD_VAL i;
        
                                // The uppermost byte, ((DWORD_VAL*)&_currentHandle)->v[3]), is the byte lane to read from.
                                // 16 bit PICs have a 24 bit wide Flash program word.  Bytes 0-2 are the actual address, but 
                                // odd addresses aren't implemented.
                                i.Val = ReadProgramMemory(_currentHandle & 0x00FFFFFF);
                                t = i.v[((DWORD_VAL*)&_currentHandle)->v[3]++];
                                if(((DWORD_VAL*)&_currentHandle)->v[3] >= 3)
                                {
                                        _currentHandle = (_currentHandle + 2) & 0x00FFFFFF;
                                }
                        }
                #else
                t = (BYTE)*_currentHandle;
                    _currentHandle++;
                #endif
        #endif

    if(t == MPFS_DLE)
    {
                #if defined(MPFS_USE_EEPROM)
                    t = XEERead();
                    _currentHandle++;
                #else
                        #if defined(__C30__)
                                {
                                        DWORD_VAL i;
                
                                // The uppermost byte, ((DWORD_VAL*)&_currentHandle)->v[3]), is the byte lane to read from.
                                // 16 bit PICs have a 24 bit wide Flash program word.  Bytes 0-2 are the actual address, but 
                                // odd addresses aren't implemented.
                                i.Val = ReadProgramMemory(_currentHandle & 0x00FFFFFF);
                                t = i.v[((DWORD_VAL*)&_currentHandle)->v[3]++];
                                if(((DWORD_VAL*)&_currentHandle)->v[3] >= 3)
                                {
                                        _currentHandle = (_currentHandle + 2) & 0x00FFFFFF;
                                }
                                }
                        #else
                        t = (BYTE)*_currentHandle;
                            _currentHandle++;
                        #endif
                #endif
    }
    else if(t == MPFS_ETX)
    {
        _currentHandle = MPFS_INVALID;
    }

    return t;
}


#if defined(__C30__) && !defined(MPFS_USE_EEPROM)
/*********************************************************************
 * Function:        static DWORD ReadProgramMemory(DWORD address)
 *
 * PreCondition:    None
 *
 * Input:           Program memory address to read from.  Should be 
 *                                      an even number.
 *
 * Output:          Program word at the specified address.  For the 
 *                                      PIC24, dsPIC, etc. which have a 24 bit program 
 *                                      word size, the upper byte is 0x00.
 *
 * Side Effects:    None
 *
 * Overview:        Modifies and restores TBLPAG.  Make sure that if 
 *                                      using interrupts and the PSV feature of the CPU 
 *                                      in an ISR that the TBLPAG register is preloaded 
 *                                      with the correct value (rather than assuming 
 *                                      TBLPAG is always pointing to the .const section.
 *
 * Note:            None
 ********************************************************************/
static DWORD ReadProgramMemory(DWORD address)
{
        asm("mov        TBLPAG, W2      ; Save TBLPAG\r\n"
            "mov        W1, TBLPAG      ; TBLPAG = HIGHWORD(address)\r\n"
                "tblrdh [W0], W1        ; W1:W0 = *address\r\n"
                "tblrdl [W0], W0\r\n"
                "mov    W2, TBLPAG      ; Restore TBLPAG\r\n");
}
#endif

/*********************************************************************
 * 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(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(_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());
#endif

    return _currentHandle;
}

/*********************************************************************
 * Function:        MPFS MPFSSeek(MPFS 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)
{
    MPFS i;

    MPFSGetBegin(_currentFile);

    i = (MPFS)0;
    while(i++ != offset)
        MPFSGet();

    MPFSGetEnd();

    return _currentHandle;
}

#endif //#if defined(STACK_USE_MPFS)
1	hedin	15	/*********************************************************************
2			*
3			* Microchip File System (MPFS) File Access API
4			* Module for Microchip TCP/IP Stack
5			* -Provides single API for accessing web pages and other files
6			* from internal program memory or an external serial EEPROM memory
7			* -Reference: AN833
8			*
9			*********************************************************************
10			* FileName: MPFS.c
11			* Dependencies: StackTsk.h
12			* MPFS.h
13			* Processor: PIC18, PIC24F, PIC24H, dsPIC30F, dsPIC33F
14			* Complier: Microchip C18 v3.02 or higher
15			* Microchip C30 v2.01 or higher
16			* Company: Microchip Technology, Inc.
17			*
18			* Software License Agreement
19			*
20			* Copyright © 2002-2007 Microchip Technology Inc. All rights
21			* reserved.
22			*
23			* Microchip licenses to you the right to use, modify, copy, and
24			* distribute:
25			* (i) the Software when embedded on a Microchip microcontroller or
26			* digital signal controller product (“Device”) which is
27			* integrated into Licensee’s product; or
28			* (ii) ONLY the Software driver source files ENC28J60.c and
29			* ENC28J60.h ported to a non-Microchip device used in
30			* conjunction with a Microchip ethernet controller for the
31			* sole purpose of interfacing with the ethernet controller.
32			*
33			* You should refer to the license agreement accompanying this
34			* Software for additional information regarding your rights and
35			* obligations.
36			*
37			* THE SOFTWARE AND DOCUMENTATION ARE PROVIDED “AS IS” WITHOUT
38			* WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT
39			* LIMITATION, ANY WARRANTY OF MERCHANTABILITY, FITNESS FOR A
40			* PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL
41			* MICROCHIP BE LIABLE FOR ANY INCIDENTAL, SPECIAL, INDIRECT OR
42			* CONSEQUENTIAL DAMAGES, LOST PROFITS OR LOST DATA, COST OF
43			* PROCUREMENT OF SUBSTITUTE GOODS, TECHNOLOGY OR SERVICES, ANY CLAIMS
44			* BY THIRD PARTIES (INCLUDING BUT NOT LIMITED TO ANY DEFENSE
45			* THEREOF), ANY CLAIMS FOR INDEMNITY OR CONTRIBUTION, OR OTHER
46			* SIMILAR COSTS, WHETHER ASSERTED ON THE BASIS OF CONTRACT, TORT
47			* (INCLUDING NEGLIGENCE), BREACH OF WARRANTY, OR OTHERWISE.
48			*
49			*
50			* Author Date Comment
51			*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
52			* Nilesh Rajbharti 8/14/01 Original (Rev. 1.0)
53			* Nilesh Rajbharti 2/9/02 Cleanup
54			* Nilesh Rajbharti 5/22/02 Rev 2.0 (See version.log for detail)
55			* Howard Schlunder 3/31/05 Changed MPFS_ENTRY and mpfs_Flags for C30
56			********************************************************************/
57			#define __MPFS_C
58
59			#include "TCPIP Stack/TCPIP.h"
60
61			#if defined(STACK_USE_MPFS)
62
63			// This file system supports short file names i.e. 8 + 3.
64			#define MAX_FILE_NAME_LEN (12u)
65
66			#define MPFS_DATA (0x00u)
67			#define MPFS_DELETED (0x01u)
68			#define MPFS_DLE (0x03u)
69			#define MPFS_ETX (0x04u)
70
71			/*
72			* MPFS Structure:
73			*
74			* MPFS_Start:
75			* <MPFS_DATA><Address1><FileName1>
76			* <MPFS_DATA><Address2><FileName2>
77			* ...
78			* <MPFS_ETX><Addressn><FileNamen>
79			* Address1:
80			* <Data1>[<Data2>...<Datan>]<MPFS_ETX><MPFS_INVALID>
81			* ...
82			*
83			* Note: If File data contains either MPFS_DLE or MPFS_ETX
84			* extra MPFS_DLE is stuffed before that byte.
85			*/
86			#if defined(MPFS_USE_EEPROM)
87			typedef struct _MPFS_ENTRY
88			{
89			BYTE Flag __attribute__((__packed__));
90			MPFS Address __attribute__((__packed__));
91			BYTE Name[MAX_FILE_NAME_LEN] __attribute__((__packed__));
92			} MPFS_ENTRY;
93			#else //Use program memory
94			typedef struct _MPFS_ENTRY
95			{
96			BYTE Flag;
97			MPFS Address;
98			BYTE Name[MAX_FILE_NAME_LEN];
99			} MPFS_ENTRY;
100			#if defined(__C30__)
101			static DWORD ReadProgramMemory(DWORD address);
102			#endif
103			#endif
104
105			static union
106			{
107			struct
108			{
109			unsigned char bNotAvailable : 1;
110			} bits;
111			BYTE Val;
112			} mpfsFlags;
113
114			BYTE mpfsOpenCount;
115
116			#if !defined(MPFS_USE_EEPROM)
117			// An address where MPFS data starts in program memory.
118			extern MPFS MPFS_Start;
119			#else
120			#define MPFS_Start MPFS_RESERVE_BLOCK
121			#endif
122
123			MPFS _currentHandle;
124			MPFS _currentFile;
125			BYTE _currentCount;
126
127
128			/*********************************************************************
129			* Function: BOOL MPFSInit(void)
130			*
131			* PreCondition: None
132			*
133			* Input: None
134			*
135			* Output: TRUE, if MPFS Storage access is initialized and
136			* MPFS is ready to be used.
137			* FALSE otherwise
138			*
139			* Side Effects: None
140			*
141			* Overview: None
142			*
143			* Note: None
144			********************************************************************/
145			BOOL MPFSInit(void)
146			{
147			mpfsOpenCount = 0;
148			mpfsFlags.Val = 0;
149
150			#if defined(MPFS_USE_EEPROM)
151			// Initialize the EEPROM access routines.
152			XEEInit();
153			#endif
154
155			return TRUE;
156			}
157
158
159			/*********************************************************************
160			* Function: MPFS MPFSOpen(BYTE* file)
161			*
162			* PreCondition: None
163			*
164			* Input: file - NULL terminated file name.
165			*
166			* Output: A handle if file is found
167			* MPFS_INVALID if file is not found.
168			*
169			* Side Effects: None
170			*
171			* Overview: None
172			*
173			* Note: None
174			********************************************************************/
175			MPFS MPFSOpen(BYTE* file)
176			{
177			MPFS_ENTRY entry;
178			MPFS FAT;
179			BYTE fileNameLen;
180
181			if( mpfsFlags.bits.bNotAvailable )
182			return MPFS_NOT_AVAILABLE;
183
184			#if defined(MPFS_USE_EEPROM)
185			FAT = MPFS_Start;
186			#else
187			FAT = (MPFS)&MPFS_Start;
188			#endif
189
190			// If string is empty, do not attempt to find it in FAT.
191			if ( *file == '\0' )
192			return MPFS_INVALID;
193
194			file = (BYTE)strupr((char)file);
195
196			while(1)
197			{
198			// Bring current FAT entry into RAM.
199			#if defined(MPFS_USE_EEPROM)
200			XEEReadArray(FAT, (unsigned char*)&entry, sizeof(entry));
201			#else
202			#if defined(__C30__)
203			memcpypgm2ram(&entry, (ROM void*)(WORD)FAT, sizeof(entry));
204			#else
205			memcpypgm2ram(&entry, (ROM void*)FAT, sizeof(entry));
206			#endif
207			#endif
208
209			// Make sure that it is a valid entry.
210			if (entry.Flag == MPFS_DATA)
211			{
212			// Does the file name match ?
213			fileNameLen = strlen((char*)file);
214			if ( fileNameLen > MAX_FILE_NAME_LEN )
215			fileNameLen = MAX_FILE_NAME_LEN;
216
217			if( memcmp((void)file, (void)entry.Name, fileNameLen) == 0 )
218			{
219			_currentFile = (MPFS)entry.Address;
220			mpfsOpenCount++;
221			return entry.Address;
222			}
223
224			// File does not match. Try next entry...
225			FAT += sizeof(entry);
226			}
227			else if ( entry.Flag == MPFS_ETX )
228			{
229			if ( entry.Address != (MPFS)MPFS_INVALID )
230			FAT = (MPFS)entry.Address;
231			else
232			break;
233			}
234			else
235			return (MPFS)MPFS_INVALID;
236			}
237			return (MPFS)MPFS_INVALID;
238			}
239
240
241			/*********************************************************************
242			* Function: void MPFSClose(void)
243			*
244			* PreCondition: None
245			*
246			* Input: handle - File handle to be closed
247			*
248			* Output: None
249			*
250			* Side Effects: None
251			*
252			* Overview: None
253			*
254			* Note: None
255			********************************************************************/
256			void MPFSClose(void)
257			{
258			_currentCount = 0;
259			mpfsFlags.bits.bNotAvailable = FALSE;
260			if ( mpfsOpenCount )
261			mpfsOpenCount--;
262			}
263
264
265			/*********************************************************************
266			* Function: BOOL MPFSGetBegin(MPFS hFile)
267			*
268			* PreCondition: MPFSOpen() != MPFS_INVALID &&
269			*
270			* Input: hFile - handle of file that is to be read
271			*
272			* Output: TRUE if successful
273			* !TRUE otherwise
274			*
275			* Side Effects: None
276			*
277			* Overview: Prepares MPFS storage media for subsequent reads.
278			*
279			* Note: None
280			********************************************************************/
281			#if defined(MPFS_USE_EEPROM)
282			BOOL MPFSGetBegin(MPFS hFile)
283			{
284			_currentHandle = hFile;
285			return (XEEBeginRead(hFile) == XEE_SUCCESS);
286			}
287			#endif
288
289			/*********************************************************************
290			* Function: BYTE MPFSGet(void)
291			*
292			* PreCondition: MPFSOpen() != MPFS_INVALID &&
293			* MPFSGetBegin() == TRUE
294			*
295			* Input: None
296			*
297			* Output: Data byte from current address.
298			*
299			* Side Effects: None
300			*
301			* Overview: Reads a byte from current address.
302			*
303			* Note: Caller must call MPFSIsEOF() to check for end of
304			* file condition
305			********************************************************************/
306			BYTE MPFSGet(void)
307			{
308			BYTE t;
309
310			#if defined(MPFS_USE_EEPROM)
311			t = XEERead();
312			_currentHandle++;
313			#else
314			#if defined(__C30__)
315			{
316			DWORD_VAL i;
317
318			// The uppermost byte, ((DWORD_VAL*)&_currentHandle)->v[3]), is the byte lane to read from.
319			// 16 bit PICs have a 24 bit wide Flash program word. Bytes 0-2 are the actual address, but
320			// odd addresses aren't implemented.
321			i.Val = ReadProgramMemory(_currentHandle & 0x00FFFFFF);
322			t = i.v[((DWORD_VAL*)&_currentHandle)->v[3]++];
323			if(((DWORD_VAL*)&_currentHandle)->v[3] >= 3)
324			{
325			_currentHandle = (_currentHandle + 2) & 0x00FFFFFF;
326			}
327			}
328			#else
329			t = (BYTE)*_currentHandle;
330			_currentHandle++;
331			#endif
332			#endif
333
334			if(t == MPFS_DLE)
335			{
336			#if defined(MPFS_USE_EEPROM)
337			t = XEERead();
338			_currentHandle++;
339			#else
340			#if defined(__C30__)
341			{
342			DWORD_VAL i;
343
344			// The uppermost byte, ((DWORD_VAL*)&_currentHandle)->v[3]), is the byte lane to read from.
345			// 16 bit PICs have a 24 bit wide Flash program word. Bytes 0-2 are the actual address, but
346			// odd addresses aren't implemented.
347			i.Val = ReadProgramMemory(_currentHandle & 0x00FFFFFF);
348			t = i.v[((DWORD_VAL*)&_currentHandle)->v[3]++];
349			if(((DWORD_VAL*)&_currentHandle)->v[3] >= 3)
350			{
351			_currentHandle = (_currentHandle + 2) & 0x00FFFFFF;
352			}
353			}
354			#else
355			t = (BYTE)*_currentHandle;
356			_currentHandle++;
357			#endif
358			#endif
359			}
360			else if(t == MPFS_ETX)
361			{
362			_currentHandle = MPFS_INVALID;
363			}
364
365			return t;
366			}
367
368
369			#if defined(__C30__) && !defined(MPFS_USE_EEPROM)
370			/*********************************************************************
371			* Function: static DWORD ReadProgramMemory(DWORD address)
372			*
373			* PreCondition: None
374			*
375			* Input: Program memory address to read from. Should be
376			* an even number.
377			*
378			* Output: Program word at the specified address. For the
379			* PIC24, dsPIC, etc. which have a 24 bit program
380			* word size, the upper byte is 0x00.
381			*
382			* Side Effects: None
383			*
384			* Overview: Modifies and restores TBLPAG. Make sure that if
385			* using interrupts and the PSV feature of the CPU
386			* in an ISR that the TBLPAG register is preloaded
387			* with the correct value (rather than assuming
388			* TBLPAG is always pointing to the .const section.
389			*
390			* Note: None
391			********************************************************************/
392			static DWORD ReadProgramMemory(DWORD address)
393			{
394			asm("mov TBLPAG, W2 ; Save TBLPAG\r\n"
395			"mov W1, TBLPAG ; TBLPAG = HIGHWORD(address)\r\n"
396			"tblrdh [W0], W1 ; W1:W0 = *address\r\n"
397			"tblrdl [W0], W0\r\n"
398			"mov W2, TBLPAG ; Restore TBLPAG\r\n");
399			}
400			#endif
401
402			/*********************************************************************
403			* Function: MPFS MPFSGetEnd(void)
404			*
405			* PreCondition: MPFSOpen() != MPFS_INVALID &&
406			* MPFSGetBegin() = TRUE
407			*
408			* Input: None
409			*
410			* Output: Current mpfs handle.
411			*
412			* Side Effects: None
413			*
414			* Overview: Ends on-going read cycle.
415			* MPFS handle that is returned must be used
416			* for subsequent begin gets..
417			*
418			* Note: None
419			********************************************************************/
420			#if defined(MPFS_USE_EEPROM)
421			MPFS MPFSGetEnd(void)
422			{
423			XEEEndRead();
424			return _currentHandle;
425			}
426			#endif
427
428
429			/*********************************************************************
430			* Function: MPFS MPFSFormat(void)
431			*
432			* PreCondition: None
433			*
434			* Input: None
435			*
436			* Output: A valid MPFS handle that can be used for MPFSPut
437			*
438			* Side Effects: None
439			*
440			* Overview: Prepares MPFS image to get re-written
441			* Declares MPFS as in use.
442			*
443			* Note: MPFS will be unaccessible until MPFSClose is
444			* called.
445			********************************************************************/
446			MPFS MPFSFormat(void)
447			{
448			mpfsFlags.bits.bNotAvailable = TRUE;
449			return (MPFS)MPFS_RESERVE_BLOCK;
450			}
451
452
453			/*********************************************************************
454			* Function: BOOL MPFSPutBegin(MPFS handle)
455			*
456			* PreCondition: MPFSInit() and MPFSFormat() are already called.
457			*
458			* Input: handle - handle to where put to begin
459			*
460			* Output: TRUE if successful
461			* !TRUE otherwise
462			*
463			* Side Effects: None
464			*
465			* Overview: Prepares MPFS image to get re-written
466			*
467			* Note: MPFS will be unaccessible until MPFSClose is
468			* called.
469			********************************************************************/
470			#if defined(MPFS_USE_EEPROM)
471			BOOL MPFSPutBegin(MPFS handle)
472			{
473			//_currentCount = 0;
474			_currentHandle = handle;
475			_currentCount = (BYTE)handle;
476			_currentCount &= (MPFS_WRITE_PAGE_SIZE-1);
477			return (XEEBeginWrite(handle) == XEE_SUCCESS);
478			}
479			#endif
480
481
482			/*********************************************************************
483			* Function: BOOL MPFSPut(BYTE b)
484			*
485			* PreCondition: MPFSFormat() or MPFSCreate() must be called
486			* MPFSPutBegin() is already called.
487			*
488			* Input: b - data to write.
489			*
490			* Output: TRUE if successfull
491			* !TRUE if failed.
492			*
493			* Side Effects: Original MPFS handle is no longer valid.
494			* Updated MPFS handle must be obtained by calling
495			* MPFSPutEnd().
496			*
497			* Overview: None
498			*
499			* Note: Actual write may not get started until internal
500			* write page is full. To ensure that previously
501			* data gets written, caller must call MPFSPutEnd()
502			* after last call to MPFSPut().
503			********************************************************************/
504			BOOL MPFSPut(BYTE b)
505			{
506			#if defined(MPFS_USE_EEPROM)
507			if ( XEEWrite(b) )
508			return FALSE;
509
510			_currentCount++;
511			_currentHandle++;
512			if ( _currentCount >= MPFS_WRITE_PAGE_SIZE )
513			{
514			MPFSPutEnd();
515			XEEBeginWrite(_currentHandle);
516			}
517			#endif
518			return TRUE;
519			}
520
521			/*********************************************************************
522			* Function: MPFS MPFSPutEnd(void)
523			*
524			* PreCondition: MPFSPutBegin() is already called.
525			*
526			* Input: None
527			*
528			* Output: Up-to-date MPFS handle
529			*
530			* Side Effects: Original MPFS handle is no longer valid.
531			* Updated MPFS handle must be obtained by calling
532			* MPFSPutEnd().
533			*
534			* Overview: None
535			*
536			* Note: Actual write may not get started until internal
537			* write page is full. To ensure that previously
538			* data gets written, caller must call MPFSPutEnd()
539			* after last call to MPFSPut().
540			********************************************************************/
541			MPFS MPFSPutEnd(void)
542			{
543			#if defined(MPFS_USE_EEPROM)
544			_currentCount = 0;
545			XEEEndWrite();
546			while(XEEIsBusy());
547			#endif
548
549			return _currentHandle;
550			}
551
552			/*********************************************************************
553			* Function: MPFS MPFSSeek(MPFS offset)
554			*
555			* PreCondition: MPFSGetBegin() is already called.
556			*
557			* Input: offset - Offset from current pointer
558			*
559			* Output: New MPFS handle located to given offset
560			*
561			* Side Effects: None.
562			*
563			* Overview: None
564			*
565			* Note: None.
566			********************************************************************/
567			MPFS MPFSSeek(MPFS offset)
568			{
569			MPFS i;
570
571			MPFSGetBegin(_currentFile);
572
573			i = (MPFS)0;
574			while(i++ != offset)
575			MPFSGet();
576
577			MPFSGetEnd();
578
579			return _currentHandle;
580			}
581
582			#endif //#if defined(STACK_USE_MPFS)