From 35881fb1c31cc215a64991b877913e519123fec9 Mon Sep 17 00:00:00 2001 From: tcsadmin Date: Fri, 21 Jan 2011 22:09:53 +0000 Subject: Added support for seeking in files that are open for both reading and writing. Added FileTell system call function. git-svn-id: https://mindboards.svn.sourceforge.net/svnroot/mindboards/lms_nbcnxc/branches/version_131@32 c9361245-7fe8-9947-84e8-057757c4e366 --- AT91SAM7S256/Source/c_cmd.c | 24 ++++-- AT91SAM7S256/Source/c_cmd.h | 1 + AT91SAM7S256/Source/c_loader.c | 6 ++ AT91SAM7S256/Source/c_loader.iom | 3 +- AT91SAM7S256/Source/d_loader.c | 169 ++++++++++++++++++++++++++------------- AT91SAM7S256/Source/d_loader.h | 1 + 6 files changed, 142 insertions(+), 62 deletions(-) (limited to 'AT91SAM7S256/Source') 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); -- cgit v1.2.3