size_t FileWrite(const void *ptr, size_t size, size_t n, FILE_HANDLE stream)
{
#if defined STACK_USE_MPFS2
WORD length;
length = size * n;
return MPFSPutArray(stream, (BYTE*)ptr, length);
#elif defined STACK_USE_MDD
return FSfwrite(ptr, size, n, stream);
#endif
}
//////////////////////////////////////////////////////////////////////////////////////////
// NOTE: The following XMODEM code has been upgarded to MPFS2 from MPFS Classic.
// Upgrading to HTTP2 and MPFS2 is *strongly* recommended for all new designs.
// MPFS2 images can be uploaded directly using the MPFS2.exe tool.
//////////////////////////////////////////////////////////////////////////////////////////
static BOOL DownloadMPFS(void)
{
enum SM_MPFS
{
SM_MPFS_SOH,
SM_MPFS_BLOCK,
SM_MPFS_BLOCK_CMP,
SM_MPFS_DATA,
} state;
BYTE c;
MPFS_HANDLE handle;
BOOL lbDone;
BYTE blockLen=0;
BYTE lResult;
BYTE tempData[XMODEM_BLOCK_LEN];
DWORD lastTick;
DWORD currentTick;
state = SM_MPFS_SOH;
lbDone = FALSE;
handle = MPFSFormat();
// Notify the host that we are ready to receive...
lastTick = TickGet();
do
{
currentTick = TickGet();
if ( currentTick - lastTick >= (TICK_SECOND/2) )
{
lastTick = TickGet();
while(BusyUART());
WriteUART(XMODEM_NAK);
/*
* Blink LED to indicate that we are waiting for
* host to send the file.
*/
LED6_IO ^= 1;
}
} while(!DataRdyUART());
while(!lbDone)
{
if(DataRdyUART())
{
// Toggle LED as we receive the data from host.
LED6_IO ^= 1;
c = ReadUART();
}
else
{
// Real application should put some timeout to make sure
// that we do not wait forever.
continue;
}
switch(state)
{
default:
if ( c == XMODEM_SOH )
{
state = SM_MPFS_BLOCK;
}
else if ( c == XMODEM_EOT )
{
// Turn off LED when we are done.
LED6_IO = 1;
MPFSClose(handle);
while(BusyUART());
WriteUART(XMODEM_ACK);
lbDone = TRUE;
}
else
{
while(BusyUART());
WriteUART(XMODEM_NAK);
}
break;
case SM_MPFS_BLOCK:
// We do not use block information.
lResult = XMODEM_ACK;
blockLen = 0;
state = SM_MPFS_BLOCK_CMP;
break;
case SM_MPFS_BLOCK_CMP:
// We do not use 1's comp. block value.
state = SM_MPFS_DATA;
break;
case SM_MPFS_DATA:
// Buffer block data until it is over.
tempData[blockLen++] = c;
if ( blockLen > XMODEM_BLOCK_LEN )
{
lResult = XMODEM_ACK;
for ( c = 0; c < XMODEM_BLOCK_LEN; c++ )
MPFSPutArray(handle,&tempData[c],1);
MPFSPutEnd(handle);
while(BusyUART());
WriteUART(lResult);
state = SM_MPFS_SOH;
}
break;
}
}
return TRUE;
}
static HTTP_IO_RESULT HTTPMPFSUpload(void)
{
BYTE c[16];
WORD lenA, lenB;
switch(curHTTP.httpStatus)
{
// New upload, so look for the CRLFCRLF
case HTTP_MPFS_UP:
lenA = TCPFindROMArray(sktHTTP, (ROM BYTE*)"\r\n\r\n", 4, 0, FALSE);
if(lenA != 0xffff)
{// Found it, so remove all data up to and including
lenA = TCPGetArray(sktHTTP, NULL, lenA);
curHTTP.byteCount -= lenA;
// Make sure first 6 bytes are also in
if(TCPIsGetReady(sktHTTP) < (4 + 6) )
{
lenA++;
return HTTP_IO_NEED_DATA;
}
// Make sure it's an MPFS of the correct version
lenA = TCPGetArray(sktHTTP, c, 10);
curHTTP.byteCount -= lenA;
if(memcmppgm2ram(c, (ROM void*)"\r\n\r\nMPFS\x02\x00", 10) == 0)
{// Read as Ver 2.0
curHTTP.httpStatus = HTTP_MPFS_OK;
// Format MPFS storage and put 6 byte tag
curHTTP.file = MPFSFormat();
MPFSPutArray(curHTTP.file, &c[4], 6);
}
else
{// Version is wrong
curHTTP.httpStatus = HTTP_MPFS_ERROR;
}
}
else
{// Otherwise, remove as much as possible
lenA = TCPGetArray(sktHTTP, NULL, TCPIsGetReady(sktHTTP) - 4);
curHTTP.byteCount -= lenA;
}
break;
// Received file is invalid
case HTTP_MPFS_ERROR:
curHTTP.byteCount -= TCPIsGetReady(sktHTTP);
TCPDiscard(sktHTTP);
if(curHTTP.byteCount < 100 || curHTTP.byteCount > 0x80000000)
{// If almost all data was read, or if we overflowed, then return
smHTTP = SM_HTTP_SERVE_HEADERS;
return HTTP_IO_DONE;
}
break;
// File is verified, so write the data
case HTTP_MPFS_OK:
// Determine how much to read
lenA = TCPIsGetReady(sktHTTP);
if(lenA > curHTTP.byteCount)
lenA = curHTTP.byteCount;
while(lenA > 0)
{
lenB = TCPGetArray(sktHTTP, c, mMIN(lenA,16));
curHTTP.byteCount -= lenB;
lenA -= lenB;
MPFSPutArray(curHTTP.file, c, lenB);
}
// If we've read all the data
if(curHTTP.byteCount == 0)
{
MPFSPutEnd();
smHTTP = SM_HTTP_SERVE_HEADERS;
return HTTP_IO_DONE;
}
}
// Ask for more data
return HTTP_IO_NEED_DATA;
}
