aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--AT91SAM7S256/Source/c_cmd.c24
-rw-r--r--AT91SAM7S256/Source/c_cmd.h1
-rw-r--r--AT91SAM7S256/Source/c_loader.c6
-rw-r--r--AT91SAM7S256/Source/c_loader.iom3
-rw-r--r--AT91SAM7S256/Source/d_loader.c169
-rw-r--r--AT91SAM7S256/Source/d_loader.h1
6 files changed, 142 insertions, 62 deletions
diff --git a/AT91SAM7S256/Source/c_cmd.c b/AT91SAM7S256/Source/c_cmd.c
index 0e79d08..53a274f 100644
--- a/AT91SAM7S256/Source/c_cmd.c
+++ b/AT91SAM7S256/Source/c_cmd.c
@@ -257,8 +257,8 @@ static pSysCall SysCallFuncs[SYSCALL_COUNT] =
cCmdWrapDrawFont, // 95
cCmdWrapMemoryManager,
cCmdWrapReadLastResponse,
- cCmdWrapUndefinedSysCall,
- cCmdWrapUndefinedSysCall // 99 --> 100 system call slots
+ cCmdWrapFileTell,
+ cCmdWrapUndefinedSysCall // 100 system call slots
// don't forget to update SYSCALL_COUNT in c_cmd.h
};
@@ -504,7 +504,8 @@ UBYTE CMD_RESPONSE_LENGTH[256] =
0, // SEEKFROMSTART = 0xD1,
0, // SEEKFROMCURRENT = 0xD2,
0, // SEEKFROMEND = 0xD3
- 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // (xD4-xDF)
+ 0, // FILEPOSITION = 0xD4
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // (xD5-xDF)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // (xE0-xEF)
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // (xF0-xFF)
};
@@ -2206,9 +2207,6 @@ NXT_STATUS cCmdActivateProgram(UBYTE * pFileName)
VarsCmd.Debugging = FALSE;
VarsCmd.PauseClump = NOT_A_CLUMP;
VarsCmd.PausePC = 0xFFFF;
- // restore default data mode values
- pMapComm->BtDataMode = DATA_MODE_NXT|DATA_MODE_UPDATE;
- pMapComm->HsDataMode = DATA_MODE_RAW|DATA_MODE_UPDATE;
return (Status);
}
@@ -9664,6 +9662,20 @@ NXT_STATUS cCmdWrapReadLastResponse(UBYTE * ArgV[])
return (NO_ERR);
}
+//cCmdWrapFileTell
+//ArgV[0]: (Function return) Loader status, U16 return
+//ArgV[1]: File Handle, U8 in/out
+//ArgV[2]: File Position, U32 out
+NXT_STATUS cCmdWrapFileTell(UBYTE * ArgV[])
+{
+ LOADER_STATUS LStatus = pMapLoader->pFunc(FILEPOSITION, ArgV[1], NULL, (ULONG *)ArgV[2]);
+ //Status code in high byte of LStatus
+ *((UWORD *)ArgV[0]) = LOADER_ERR(LStatus);
+ //File handle in low byte of LStatus
+ *(ArgV[1]) = LOADER_HANDLE(LStatus);
+ return (NO_ERR);
+}
+
NXT_STATUS cCmdWrapUndefinedSysCall(UBYTE * ArgV[])
{
return (NO_ERR);
diff --git a/AT91SAM7S256/Source/c_cmd.h b/AT91SAM7S256/Source/c_cmd.h
index b23e9f6..0486b1c 100644
--- a/AT91SAM7S256/Source/c_cmd.h
+++ b/AT91SAM7S256/Source/c_cmd.h
@@ -909,6 +909,7 @@ NXT_STATUS cCmdWrapDrawEllipse(UBYTE * ArgV[]);
NXT_STATUS cCmdWrapDrawFont(UBYTE * ArgV[]);
NXT_STATUS cCmdWrapMemoryManager(UBYTE * ArgV[]);
NXT_STATUS cCmdWrapReadLastResponse(UBYTE * ArgV[]);
+NXT_STATUS cCmdWrapFileTell(UBYTE * ArgV[]);
NXT_STATUS cCmdWrapUndefinedSysCall(UBYTE * ArgV[]);
diff --git a/AT91SAM7S256/Source/c_loader.c b/AT91SAM7S256/Source/c_loader.c
index b9f290f..b6e6436 100644
--- a/AT91SAM7S256/Source/c_loader.c
+++ b/AT91SAM7S256/Source/c_loader.c
@@ -279,6 +279,12 @@ UWORD cLoaderFileRq(UBYTE Cmd, UBYTE *pFileName, UBYTE *pBuffer, ULONG *pLen
ReturnState = dLoaderSeek(*pFileName, *(SLONG*)pLength, Cmd-SEEKFROMSTART);
}
break;
+ case FILEPOSITION:
+ {
+ // *pFileName is the handle, pLength is the returned file position
+ ReturnState = dLoaderTell(*pFileName, pLength);
+ }
+ break;
case READ:
{
ReturnState = dLoaderRead(*pFileName, pBuffer, pLength);
diff --git a/AT91SAM7S256/Source/c_loader.iom b/AT91SAM7S256/Source/c_loader.iom
index c0549b1..afc6523 100644
--- a/AT91SAM7S256/Source/c_loader.iom
+++ b/AT91SAM7S256/Source/c_loader.iom
@@ -68,7 +68,8 @@ enum
RESIZEDATAFILE = 0xD0,
SEEKFROMSTART = 0xD1,
SEEKFROMCURRENT = 0xD2,
- SEEKFROMEND = 0xD3
+ SEEKFROMEND = 0xD3,
+ FILEPOSITION = 0xD4
};
typedef UWORD LOADER_STATUS;
diff --git a/AT91SAM7S256/Source/d_loader.c b/AT91SAM7S256/Source/d_loader.c
index 99624e8..c9ed747 100644
--- a/AT91SAM7S256/Source/d_loader.c
+++ b/AT91SAM7S256/Source/d_loader.c
@@ -35,8 +35,9 @@ typedef struct
{
const UBYTE *pFlash;
const UWORD *pSectorNo;
- ULONG ReadLength;
- ULONG DataLength;
+ ULONG FilePosition;
+ ULONG DataSize;
+ ULONG RemainingLength;
ULONG FileDlPtr;
UBYTE SearchStr[FILENAME_SIZE];
UWORD FileIndex;
@@ -72,6 +73,7 @@ UWORD dLoaderAllocateWriteBuffer(UWORD Handle);
UWORD dLoaderSetFilePointer(UWORD Handle, ULONG BytePtr, const UBYTE **pData);
UWORD dLoaderGetSectorNumber(ULONG Adr);
void dLoaderCheckVersion(void);
+UWORD dLoaderCheckHandleForReadWrite(UWORD Handle);
UWORD dLoaderCheckHandle(UWORD Handle, UBYTE Operation);
ULONG dLoaderCalcFreeFileSpace(UWORD NosOfFreeSectors);
UWORD dLoaderCheckDownload(UBYTE *pName);
@@ -330,8 +332,8 @@ UWORD dLoaderCreateFileHeader(ULONG FileSize, UBYTE *pName, UBYTE LinearStat
ULONG CompleteFileByteSize;
UWORD Handle;
UBYTE Name[FILENAME_SIZE];
- ULONG FileLength;
- ULONG DataLength;
+ ULONG TmpFileSize;
+ ULONG DataSize;
UWORD ErrorCode;
UWORD CompleteSectorNo;
UWORD Tmp;
@@ -339,7 +341,7 @@ UWORD dLoaderCreateFileHeader(ULONG FileSize, UBYTE *pName, UBYTE LinearStat
memset(&(Header.FileName), 0, sizeof(Header.FileName));
memset(&(Header.FileSectorTable), 0xFF, sizeof(Header.FileSectorTable));
- ErrorCode = dLoaderFind(pName, Name, &FileLength, &DataLength, (UBYTE)BUSY);
+ ErrorCode = dLoaderFind(pName, Name, &TmpFileSize, &DataSize, (UBYTE)BUSY);
Handle = ErrorCode & 0x00FF;
if (SUCCESS == (ErrorCode & 0xFF00))
{
@@ -367,8 +369,8 @@ UWORD dLoaderCreateFileHeader(ULONG FileSize, UBYTE *pName, UBYTE LinearStat
dLoaderCopyFileName((Header.FileName), pName);
HandleTable[Handle].pSectorNo = 0;
- HandleTable[Handle].DataLength = FileSize; /* used for end of file detection */
- Header.FileSize = FileSize; /* used to program into flash */
+ HandleTable[Handle].RemainingLength = FileSize; /* used for end of file detection */
+ Header.FileSize = FileSize; /* used to program into flash */
if (DATAFILE == FileType)
{
Header.DataSize = 0;
@@ -377,6 +379,8 @@ UWORD dLoaderCreateFileHeader(ULONG FileSize, UBYTE *pName, UBYTE LinearStat
{
Header.DataSize = FileSize;
}
+ HandleTable[Handle].DataSize = Header.DataSize;
+ HandleTable[Handle].FilePosition = 0;
HandleTable[Handle].FileType = FileType | LinearState; /* if it is a datafile it can be stopped */
Header.FileType = FileType | LinearState; /* FileType included for future appending */
@@ -450,17 +454,23 @@ UWORD dLoaderCreateFileHeader(ULONG FileSize, UBYTE *pName, UBYTE LinearStat
UWORD dLoaderWriteData(UWORD Handle, UBYTE *pBuf, UWORD *pLen)
{
UWORD Tmp;
+ ULONG NewFP, TmpLen;
UBYTE *pSectorBuf;
Handle = dLoaderCheckHandle(Handle, DOWNLOADING);
if (0x8000 > Handle)
{
-
- if (*pLen > HandleTable[Handle].DataLength)
+ // will we write past the current DataSize value?
+ NewFP = HandleTable[Handle].FilePosition + *pLen;
+ if (NewFP > HandleTable[Handle].DataSize)
+ TmpLen = NewFP - HandleTable[Handle].DataSize;
+ else
+ TmpLen = 0;
+ if (TmpLen > HandleTable[Handle].RemainingLength)
{
/* Write request exceeds filesize - only flash up to filesize*/
- *pLen = HandleTable[Handle].DataLength;
+ *pLen = HandleTable[Handle].RemainingLength;
WriteBuffer[HandleTable[Handle].WriteBufNo].Status = DLERROR; /* save error untill close handle */
}
@@ -480,10 +490,18 @@ UWORD dLoaderWriteData(UWORD Handle, UBYTE *pBuf, UWORD *pLen)
(WriteBuffer[HandleTable[Handle].WriteBufNo].BufIndex)++;
}
}
- HandleTable[Handle].DataLength -= *pLen;
+ // did we write past the current DataSize value?
+ NewFP = HandleTable[Handle].FilePosition + *pLen;
+ if (NewFP > HandleTable[Handle].DataSize)
+ {
+ TmpLen = NewFP - HandleTable[Handle].DataSize;
+ HandleTable[Handle].RemainingLength -= TmpLen;
+ HandleTable[Handle].DataSize = NewFP;
+ }
+ HandleTable[Handle].FilePosition = NewFP;
/* Check for correct end of file */
- if (0 == HandleTable[Handle].DataLength)
+ if (0 == HandleTable[Handle].RemainingLength)
{
if ((WriteBuffer[HandleTable[Handle].WriteBufNo].BufIndex) != 0)
{
@@ -581,7 +599,7 @@ UWORD dLoaderCloseHandle(UWORD Handle)
/* This is a Datafile that should be closed and this is a legal action */
/* 1. Write the data from the writebuffer into flash */
- /* 2. Update the Datalength in the file header */
+ /* 2. Update the RemainingLength in the file header */
/* This takes minimum 8 mS (2 page writes into flash) */
if (WriteBuffer[HandleTable[Handle].WriteBufNo].BufIndex)
@@ -594,14 +612,14 @@ UWORD dLoaderCloseHandle(UWORD Handle)
/* Now the databuffer is free now use if for a buffer for the fileheader*/
memcpy(WriteBuffer[HandleTable[Handle].WriteBufNo].Buf, (void const*)HandleTable[Handle].FileDlPtr, SECTORSIZE);
TmpFileHeader = (FILEHEADER *) WriteBuffer[HandleTable[Handle].WriteBufNo].Buf;
- TmpFileHeader->DataSize = TmpFileHeader->FileSize - HandleTable[Handle].DataLength;
+ TmpFileHeader->DataSize = TmpFileHeader->FileSize - HandleTable[Handle].RemainingLength;
dLoaderWritePage(((ULONG)HandleTable[Handle].FileDlPtr & ~(SECTORSIZE - 1)), SECTORSIZE, WriteBuffer[HandleTable[Handle].WriteBufNo].Buf);
}
else
{
/* This is a system file being closed now update the file pointer table if no error and complete file written */
- if ((DLERROR != WriteBuffer[HandleTable[Handle].WriteBufNo].Status) && (0 == HandleTable[Handle].DataLength))
+ if ((DLERROR != WriteBuffer[HandleTable[Handle].WriteBufNo].Status) && (0 == HandleTable[Handle].RemainingLength))
{
/* no error durig download - add the file pointer to the file pointer table */
@@ -630,22 +648,23 @@ UWORD dLoaderCloseHandle(UWORD Handle)
UWORD dLoaderOpenRead(UBYTE *pFileName, ULONG *pLength)
{
UWORD Handle;
- UBYTE Name[16];
+ UBYTE Name[FILENAME_SIZE];
const FILEHEADER *TmpHeader;
- ULONG FileLength;
- ULONG DataLength;
+ ULONG FileSize;
+ ULONG DataSize;
- Handle = dLoaderFind(pFileName, Name, &FileLength, &DataLength, (UBYTE)BUSY);
+ Handle = dLoaderFind(pFileName, Name, &FileSize, &DataSize, (UBYTE)BUSY);
if (0x8000 > Handle)
{
- if (FileLength)
+ if (FileSize)
{
TmpHeader = (FILEHEADER const *)(FILEPTRTABLE[HandleTable[Handle].FileIndex]);
HandleTable[Handle].pFlash = (const UBYTE *)TmpHeader->FileStartAdr;
- HandleTable[Handle].pSectorNo = TmpHeader->FileSectorTable;
- HandleTable[Handle].DataLength = TmpHeader->DataSize;
- HandleTable[Handle].ReadLength = 0;
- *pLength = TmpHeader->DataSize;
+ HandleTable[Handle].pSectorNo = TmpHeader->FileSectorTable;
+ HandleTable[Handle].DataSize = DataSize;
+ HandleTable[Handle].FilePosition = 0;
+ HandleTable[Handle].RemainingLength = FileSize - DataSize;
+ *pLength = DataSize;
}
else
{
@@ -657,16 +676,16 @@ UWORD dLoaderOpenRead(UBYTE *pFileName, ULONG *pLength)
UWORD dLoaderSeek(UBYTE Handle, SLONG offset, UBYTE from)
{
- // move the ReadLength file pointer for this handle to the new offset
+ // move the FilePosition file pointer for this handle to the new offset
// and update pFlash appropriately
UWORD Status;
SLONG distFromStart;
const FILEHEADER *TmpHeader;
- Status = dLoaderCheckHandle(Handle, BUSY);
+ Status = dLoaderCheckHandleForReadWrite(Handle);
if (0x8000 > Status)
{
- Status = Handle;
+ Status = Handle;
// calculate distance from start regardless of "from"
// and start from there going forward unless distance > current
// in which case start from current going forward
@@ -675,41 +694,62 @@ UWORD dLoaderSeek(UBYTE Handle, SLONG offset, UBYTE from)
distFromStart = offset;
break;
case SEEK_FROMCURRENT:
- distFromStart = (SLONG)HandleTable[Handle].ReadLength + offset;
+ distFromStart = (SLONG)HandleTable[Handle].FilePosition + offset;
break;
case SEEK_FROMEND:
- distFromStart = (SLONG)HandleTable[Handle].DataLength + offset;
+ distFromStart = (SLONG)HandleTable[Handle].DataSize + offset;
break;
}
- if (distFromStart != HandleTable[Handle].ReadLength) {
- if ((distFromStart < 0) || (distFromStart > HandleTable[Handle].DataLength))
+ if (distFromStart != HandleTable[Handle].FilePosition) {
+ if ((distFromStart < 0) || (distFromStart > HandleTable[Handle].DataSize))
return (Status | INVALIDSEEK);
- if (distFromStart < HandleTable[Handle].ReadLength) {
+ if (distFromStart < HandleTable[Handle].FilePosition) {
// start from the beginning in this case
TmpHeader = (FILEHEADER const *)(FILEPTRTABLE[HandleTable[Handle].FileIndex]);
- HandleTable[Handle].pFlash = (const UBYTE *)TmpHeader->FileStartAdr;
- HandleTable[Handle].ReadLength = 0;
+ HandleTable[Handle].pFlash = (const UBYTE *)TmpHeader->FileStartAdr;
+ HandleTable[Handle].pSectorNo = TmpHeader->FileSectorTable;
+ HandleTable[Handle].FilePosition = 0;
}
else
- distFromStart -= HandleTable[Handle].ReadLength; // dist from current
+ distFromStart -= HandleTable[Handle].FilePosition; // dist from current
// now move forward from the current location
while (distFromStart > 0) {
distFromStart--;
// move to next byte in the flash
HandleTable[Handle].pFlash++;
// update our file pointer
- HandleTable[Handle].ReadLength++;
+ HandleTable[Handle].FilePosition++;
// if we reach a flash sector boundary then find the next sector pointer
if (!((ULONG)(HandleTable[Handle].pFlash) & (SECTORSIZE-1)))
{
HandleTable[Handle].pFlash = dLoaderGetNextSectorPtr(Handle);
}
}
+ // if we are open for writing then we need to do a little more work
+ if (HandleTable[Handle].Status == DOWNLOADING)
+ {
+ // open for writing
+ WriteBuffer[HandleTable[Handle].WriteBufNo].BufIndex = (ULONG)(HandleTable[Handle].pFlash) & (SECTORSIZE - 1);
+ memcpy(WriteBuffer[HandleTable[Handle].WriteBufNo].Buf, (const UBYTE *)((ULONG)(HandleTable[Handle].pFlash) & ~(SECTORSIZE - 1)), WriteBuffer[HandleTable[Handle].WriteBufNo].BufIndex );
+ }
}
}
return(Status);
}
+UWORD dLoaderTell(UBYTE Handle, ULONG* filePos)
+{
+ UWORD Status;
+
+ Status = dLoaderCheckHandleForReadWrite(Handle);
+ if (0x8000 > Status)
+ {
+ Status = Handle;
+ *filePos = HandleTable[Handle].FilePosition;
+ }
+ return(Status);
+}
+
UWORD dLoaderRead(UBYTE Handle, UBYTE *pBuffer, ULONG *pLength)
{
UWORD ByteCnt, Status;
@@ -721,9 +761,9 @@ UWORD dLoaderRead(UBYTE Handle, UBYTE *pBuffer, ULONG *pLength)
ByteCnt = 0;
while (ByteCnt < *pLength)
{
- if (HandleTable[Handle].DataLength <= HandleTable[Handle].ReadLength)
+ if (HandleTable[Handle].DataSize <= HandleTable[Handle].FilePosition)
{
- // if the file pointer (ReadLength) is >= file size then return EOF
+ // if the file pointer (FilePosition) is >= file size then return EOF
*pLength = ByteCnt;
Status |= ENDOFFILE;
}
@@ -736,7 +776,7 @@ UWORD dLoaderRead(UBYTE Handle, UBYTE *pBuffer, ULONG *pLength)
// move to next byte in the flash
HandleTable[Handle].pFlash++;
// update our file pointer
- HandleTable[Handle].ReadLength++;
+ HandleTable[Handle].FilePosition++;
// if we reach a flash sector boundary then find the next sector pointer
if (!((ULONG)(HandleTable[Handle].pFlash) & (SECTORSIZE-1)))
{
@@ -751,11 +791,11 @@ UWORD dLoaderRead(UBYTE Handle, UBYTE *pBuffer, ULONG *pLength)
UWORD dLoaderDelete(UBYTE *pFile)
{
UWORD LStatus;
- ULONG FileLength;
- ULONG DataLength;
- UBYTE Name[FILENAME_LENGTH + 1];
+ ULONG FileSize;
+ ULONG DataSize;
+ UBYTE Name[FILENAME_SIZE];
- LStatus = dLoaderFind(pFile, Name, &FileLength, &DataLength, (UBYTE)BUSY);
+ LStatus = dLoaderFind(pFile, Name, &FileSize, &DataSize, (UBYTE)BUSY);
if (!IS_LOADER_ERR(LStatus))
{
@@ -767,7 +807,7 @@ UWORD dLoaderDelete(UBYTE *pFile)
return(LStatus);
}
-UWORD dLoaderFind(UBYTE *pFind, UBYTE *pFound, ULONG *pFileLength, ULONG *pDataLength, UBYTE Session)
+UWORD dLoaderFind(UBYTE *pFind, UBYTE *pFound, ULONG *pFileSize, ULONG *pDataSize, UBYTE Session)
{
UWORD Handle;
@@ -783,20 +823,20 @@ UWORD dLoaderFind(UBYTE *pFind, UBYTE *pFound, ULONG *pFileLength, ULONG *pD
HandleTable[Handle].FileIndex = 0xFFFF;
HandleTable[Handle].Status = Session;
dLoaderInsertSearchStr((HandleTable[Handle].SearchStr), pFind, &(HandleTable[Handle].SearchType));
- Handle = dLoaderFindNext(Handle, pFound, pFileLength, pDataLength);
+ Handle = dLoaderFindNext(Handle, pFound, pFileSize, pDataSize);
}
}
return(Handle);
}
-UWORD dLoaderFindNext(UWORD Handle, UBYTE *pFound, ULONG *pFileLength, ULONG *pDataLength)
+UWORD dLoaderFindNext(UWORD Handle, UBYTE *pFound, ULONG *pFileSize, ULONG *pDataSize)
{
UBYTE Tmp;
UWORD ReturnVal;
FILEHEADER *pHeader;
- *pFileLength = 0;
+ *pFileSize = 0;
ReturnVal = Handle | FILENOTFOUND;
@@ -815,13 +855,13 @@ UWORD dLoaderFindNext(UWORD Handle, UBYTE *pFound, ULONG *pFileLength, ULONG
if (0x8000 > ReturnVal)
{
pHeader = (FILEHEADER *)FILEPTRTABLE[HandleTable[Handle].FileIndex];
- if (NULL != pFileLength)
+ if (NULL != pFileSize)
{
- *pFileLength = pHeader->FileSize;
+ *pFileSize = pHeader->FileSize;
}
- if (NULL != pDataLength)
+ if (NULL != pDataSize)
{
- *pDataLength = pHeader->DataSize;
+ *pDataSize = pHeader->DataSize;
}
if (NULL != pFound)
{
@@ -893,15 +933,15 @@ ULONG dLoaderCalcFreeFileSpace(UWORD NosOfFreeSectors)
}
-UWORD dLoaderGetFilePtr(UBYTE *pFileName, UBYTE *pPtrToFile, ULONG *pFileLength)
+UWORD dLoaderGetFilePtr(UBYTE *pFileName, UBYTE *pPtrToFile, ULONG *pFileSize)
{
UWORD RtnVal;
UBYTE FoundFile[16];
FILEHEADER *File;
- ULONG DataLength;
+ ULONG DataSize;
- RtnVal = dLoaderFind(pFileName, FoundFile, pFileLength, &DataLength, (UBYTE)BUSY);
+ RtnVal = dLoaderFind(pFileName, FoundFile, pFileSize, &DataSize, (UBYTE)BUSY);
if (0x8000 > RtnVal)
{
@@ -1265,7 +1305,9 @@ UWORD dLoaderOpenAppend(UBYTE *pFileName, ULONG *pAvailSize)
HandleTable[Handle].FileDlPtr = FILEPTRTABLE[HandleTable[Handle].FileIndex];
HandleTable[Handle].Status = (UBYTE)DOWNLOADING;
*pAvailSize = FileSize - DataSize;
- HandleTable[Handle].DataLength = *pAvailSize;
+ HandleTable[Handle].RemainingLength = *pAvailSize;
+ HandleTable[Handle].FilePosition = DataSize;
+ HandleTable[Handle].DataSize = DataSize;
HandleTable[Handle].FileType = pHeader->FileType;
}
}
@@ -1438,6 +1480,23 @@ void dLoaderInsertSearchStr(UBYTE *pDst, UBYTE *pSrc, UBYTE *pSearchType)
}
}
+UWORD dLoaderCheckHandleForReadWrite(UWORD Handle)
+{
+ if (MAX_HANDLES > Handle)
+ {
+ if ((DOWNLOADING != HandleTable[(UBYTE)Handle].Status) &&
+ (BUSY != HandleTable[(UBYTE)Handle].Status))
+ {
+ Handle |= ILLEGALHANDLE;
+ }
+ }
+ else
+ {
+ Handle |= ILLEGALHANDLE;
+ }
+ return(Handle);
+}
+
UWORD dLoaderCheckHandle(UWORD Handle, UBYTE Operation)
{
diff --git a/AT91SAM7S256/Source/d_loader.h b/AT91SAM7S256/Source/d_loader.h
index e5ecb82..a86283e 100644
--- a/AT91SAM7S256/Source/d_loader.h
+++ b/AT91SAM7S256/Source/d_loader.h
@@ -86,6 +86,7 @@ UWORD dLoaderWriteData(UWORD Handle, UBYTE *pBuf, UWORD *pLen);
UWORD dLoaderCloseHandle(UWORD Handle);
UWORD dLoaderOpenRead(UBYTE *pFileName, ULONG *pLength);
UWORD dLoaderSeek(UBYTE Handle, SLONG offset, UBYTE from);
+UWORD dLoaderTell(UBYTE Handle, ULONG* filePos);
UWORD dLoaderRead(UBYTE Handle, UBYTE *pBuf, ULONG *pLength);
UWORD dLoaderDelete(UBYTE *pFile);
UWORD dLoaderFind(UBYTE *pFind, UBYTE *pFound, ULONG *pFileLength, ULONG *pDataLength, UBYTE Session);