/*----------------------------------------------------------------------------
* EAS_HWInit
*
* Initialize host wrapper interface
*
*----------------------------------------------------------------------------
*/
EAS_RESULT EAS_HWInit (EAS_HW_DATA_HANDLE *pHWInstData)
{
#if defined(_DEBUG) && !defined(MSC)
EnableHeapDebug();
#endif
#ifdef BUFFERED_FILE_ACCESS
EAS_ReportX(_EAS_SEVERITY_INFO, "EAS_HWInit: Buffered file access\n");
#else
EAS_ReportX(_EAS_SEVERITY_INFO, "EAS_HWInit: Memory mapped file access\n");
#endif
/* simulate failure */
if (errorConditions[eInitError])
return EAS_FAILURE;
/* need to track file opens for duplicate handles */
*pHWInstData = malloc(sizeof(EAS_HW_INST_DATA));
if (!(*pHWInstData))
return EAS_ERROR_MALLOC_FAILED;
EAS_HWMemSet(*pHWInstData, 0, sizeof(EAS_HW_INST_DATA));
return EAS_SUCCESS;
}
/*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_RESULT EAS_HWFileSeekOfs (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
{
EAS_I32 temp;
#ifdef DEBUG_FILE_IO
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWFileSeekOfs: Seeking to new position %d\n", file->filePos + position);
#endif
/* check handle integrity */
if (file->pFile == NULL)
return EAS_ERROR_INVALID_HANDLE;
/* is new position in current buffer? */
temp = position + file->readIndex;
if ((temp >= 0) && (temp < file->bytesInBuffer))
{
file->readIndex = temp;
file->filePos += position;
return EAS_SUCCESS;
}
/* save new position and reset buffer info so EAS_HWGetByte doesn't fail */
file->filePos += position;
file->bytesInBuffer = 0;
file->readIndex = 0;
return EAS_SUCCESS;
}
/*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_RESULT EAS_HWGetByte (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p)
{
EAS_RESULT result;
/* check handle integrity */
if (file->pFile == NULL)
return EAS_ERROR_INVALID_HANDLE;
/* use local buffer - do we have any data? */
if (file->readIndex >= file->bytesInBuffer)
{
if ((result = EAS_HWFillBuffer(hwInstData, file)) != EAS_SUCCESS)
return result;
/* if nothing to read, return EOF */
if (file->bytesInBuffer == 0)
return EAS_EOF;
}
/* get a character from the buffer */
*((EAS_U8*) p) = file->buffer[file->readIndex++];
#ifdef DEBUG_FILE_IO
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetByte: Reading from position %d, byte = 0x%02x\n", file->filePos, *(EAS_U8*)p);
#endif
file->filePos++;
return EAS_SUCCESS;
}
/*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_RESULT EAS_HWFileSeek (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, EAS_I32 position)
{
EAS_I32 newIndex;
/* check handle integrity */
if (file->pFile == NULL)
return EAS_ERROR_INVALID_HANDLE;
/* check for seek past end */
if ((position < 0) || (position > file->fileSize))
return EAS_ERROR_FILE_SEEK;
#ifdef DEBUG_FILE_IO
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWFileSeek: Seeking to new position %d\n", file->filePos);
#endif
/* is new position in current buffer? */
newIndex = position - file->filePos + file->readIndex;
if ((newIndex >= 0) && (newIndex < file->bytesInBuffer))
{
file->readIndex = newIndex;
file->filePos = position;
return EAS_SUCCESS;
}
/* save new position and reset buffer info so EAS_HWGetByte doesn't fail */
file->filePos = position;
file->bytesInBuffer = 0;
file->readIndex = 0;
return EAS_SUCCESS;
}
/*----------------------------------------------------------------------------
* HeapCheck()
*----------------------------------------------------------------------------
* Check heap status
*----------------------------------------------------------------------------
*/
void HeapCheck (void)
{
int heapStatus;
/* Check heap status */
heapStatus = _heapchk();
if ((heapStatus == _HEAPOK) || (heapStatus == _HEAPEMPTY))
return;
EAS_ReportX(_EAS_SEVERITY_FATAL, "Heap corrupt\n" );
}
/*----------------------------------------------------------------------------
*
* EAS_HWOpenFile
*
* Open a file for read or write
*
*----------------------------------------------------------------------------
*/
EAS_RESULT EAS_HWOpenFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_LOCATOR locator, EAS_FILE_HANDLE *pFile, EAS_FILE_MODE mode)
{
EAS_HW_FILE *file;
int i;
/* set return value to NULL */
*pFile = NULL;
/* only support read mode at this time */
if (mode != EAS_FILE_READ)
return EAS_ERROR_INVALID_FILE_MODE;
/* find an empty entry in the file table */
file = hwInstData->files;
for (i = 0; i < EAS_MAX_FILE_HANDLES; i++)
{
/* is this slot being used? */
if (file->pFile == NULL)
{
EAS_RESULT result;
/* open the file */
file->pFile = fopen((const char*) locator, "rb");
if (file->pFile == NULL)
return EAS_ERROR_FILE_OPEN_FAILED;
/* get file length */
if ((result = EAS_HWFileLength(hwInstData, file, &file->fileSize)) != EAS_SUCCESS)
{
EAS_HWCloseFile(hwInstData, file);
return result;
}
#ifdef DEBUG_FILE_IO
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWOpenFile: Open file %d\n", i);
#endif
/* initialize some values */
file->bytesInBuffer = 0;
file->readIndex = 0;
file->filePos = 0;
file->dup = EAS_FALSE;
*pFile = file;
return EAS_SUCCESS;
}
file++;
}
/* too many open files */
return EAS_ERROR_MAX_FILES_OPEN;
}
/*----------------------------------------------------------------------------
*
* EAS_HWGetDWord
*
* Read a 16-bit value from the file
*----------------------------------------------------------------------------
*/
EAS_RESULT EAS_HWGetDWord (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *p, EAS_BOOL msbFirst)
{
EAS_RESULT result;
EAS_I32 count;
EAS_U8 c[4];
#ifdef DEBUG_FILE_IO
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWGetDWord: Reading 4 bytes from position %d\n", file->filePos);
#endif
/* read 4 bytes from the file */
if ((result = EAS_HWReadFile(hwInstData, file, c, 4, &count)) != EAS_SUCCESS)
return result;
/* order them as requested */
if (msbFirst)
*((EAS_U32*) p) = ((EAS_U32) c[0] << 24) | ((EAS_U32) c[1] << 16) | ((EAS_U32) c[2] << 8) | c[3];
else
*((EAS_U32*) p) = ((EAS_U32) c[3] << 24) | ((EAS_U32) c[2] << 16) | ((EAS_U32) c[1] << 8) | c[0];
return EAS_SUCCESS;
}
/*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_RESULT EAS_HWBackLight (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
{
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "Backlight state: %d\n", state);
return EAS_SUCCESS;
}
/*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_RESULT EAS_HWLED (EAS_HW_DATA_HANDLE hwInstData, EAS_BOOL state)
{
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "LED state: %d\n", state);
return EAS_SUCCESS;
}
/*lint -esym(715, hwInstData) hwInstData available for customer use */
EAS_RESULT EAS_HWReadFile (EAS_HW_DATA_HANDLE hwInstData, EAS_FILE_HANDLE file, void *pBuffer, EAS_I32 n, EAS_I32 *pBytesRead)
{
EAS_RESULT result;
EAS_I32 temp;
EAS_U8 *p = pBuffer;
EAS_I32 bytesLeft = n;
*pBytesRead = 0;
/* check handle integrity */
if (file->pFile == NULL)
return EAS_ERROR_INVALID_HANDLE;
#ifdef DEBUG_FILE_IO
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "EAS_HWReadFile: Reading %d bytes from position %d\n", n, file->filePos);
#endif
/* try to fulfill request from buffer */
for (; bytesLeft > 0;)
{
/* how many bytes can we get from buffer? */
temp = file->bytesInBuffer - file->readIndex;
if (temp > bytesLeft)
temp = bytesLeft;
/* copy data from buffer */
EAS_HWMemCpy(p, &file->buffer[file->readIndex], temp);
*pBytesRead += temp;
file->readIndex += temp;
file->filePos += temp;
bytesLeft -= temp;
p += temp;
/* don't refill buffer if request is bigger than buffer */
if ((bytesLeft == 0) || (bytesLeft >= EAS_FILE_BUFFER_SIZE))
break;
/* refill buffer */
if ((result = EAS_HWFillBuffer(hwInstData, file)) != EAS_SUCCESS)
return result;
}
/* more to read? do unbuffered read directly to target memory */
if (bytesLeft)
{
/* position the file pointer */
if (fseek(file->pFile, file->filePos, SEEK_SET) != 0)
return EAS_ERROR_FILE_SEEK;
/* read data in the buffer */
/*lint -e{826} lint doesn't like this with STATIC_MEMORY defined for some reason */
temp = (EAS_I32) fread(p, 1, (size_t) bytesLeft, file->pFile);
*pBytesRead += temp;
file->filePos += temp;
/* reset buffer info */
file->bytesInBuffer = 0;
file->readIndex = 0;
}
#ifdef DEBUG_FILE_IO
{
#define BYTES_PER_LINE 16
char str[BYTES_PER_LINE * 3 + 1];
EAS_INT i;
for (i = 0; i < (n > BYTES_PER_LINE ? BYTES_PER_LINE : n) ; i ++)
sprintf(&str[i*3], "%02x ", ((EAS_U8*)pBuffer)[i]);
if (i)
EAS_ReportX(_EAS_SEVERITY_NOFILTER, "%s\n", str);
}
#endif
/* were n bytes read? */
if (*pBytesRead != n)
return EAS_EOF;
return EAS_SUCCESS;
}
