fsal.c

最新MTK手机软件源码

}

/*------ file system abstraction layer ------*/

/* The following functions are file-system dependent. */



FSAL_Status FSAL_Direct_Open(STFSAL *pstFSAL, void* szFile, FSAL_FileMode eMode)
{
   FSAL_CHECK_ARG(pstFSAL!=NULL);
   FSAL_CHECK_ARG(szFile!=NULL);
   if ( FSAL_ROMFILE == eMode ) {
      /* uRamFileSize should be set in advance. */
      FSAL_ASSERT(pstFSAL->uRamFileSize!=0);
#if FSAL_PLATFORM_WIN32
      pstFSAL->hFile = (FILE*)-1;
#elif FSAL_PLATFORM_KAL
      pstFSAL->hFile = -1;
#endif
      pstFSAL->pbFile = (kal_uint8*)szFile;
      return FSAL_OK;
   }
   pstFSAL->pbFile = 0;
#if FSAL_PLATFORM_WIN32
   {
      char* szMode;
      switch(eMode) {
      case FSAL_READ:
         szMode = "rb";
         break;
      case FSAL_WRITE:
         szMode = "wb+";
         break;
      case FSAL_APPEND:
         szMode = "ab+";
         break;
      default:
         FSAL_CHECK_ARG(KAL_FALSE);
      }
      if (0 == (pstFSAL->hFile = fopen((char*)szFile, szMode)))
         return FSAL_OPEN_ERROR;
    }
#elif FSAL_PLATFORM_KAL
   {
      kal_uint32 uFlags;
      switch (eMode & ~FSAL_NONBLOCKING) {
      case FSAL_READ:
         uFlags = FS_READ_ONLY | FS_OPEN_NO_DIR;
         break;
      case FSAL_WRITE:
         uFlags = FS_READ_WRITE | FS_CREATE_ALWAYS;
         break;
      case FSAL_APPEND:
         uFlags = FS_READ_WRITE | FS_CREATE;
         break;
      default:
         FSAL_CHECK_ARG(KAL_FALSE);
      }
      if(eMode & FSAL_NONBLOCKING)
         uFlags |= FS_NONBLOCK_MODE;
      if ((pstFSAL->hFile = DRM_open_file((kal_wchar*)szFile, uFlags, 0)) < 0) {
         pstFSAL->iFSErrorCode = pstFSAL->hFile;
         if (pstFSAL->iFSErrorCode==FS_DEVICE_BUSY || pstFSAL->iFSErrorCode==FS_LOCK_MUTEX_FAIL)
            return FSAL_DEVICE_BUSY;
         else {
            kal_prompt_trace(MOD_MED, "[FSAL] FS_Open Error:%d\n", pstFSAL->iFSErrorCode);
            return FSAL_OPEN_ERROR;
         }
      }
   }
#endif
   return FSAL_OK;
}



kal_bool FSAL_IsRamFile(STFSAL *pstFSAL) {
   if (pstFSAL->uRamFileSize != 0) {
      return KAL_TRUE;
   } else {
      return KAL_FALSE;
   }
}



kal_uint8* FSAL_GetRamFilePointer(STFSAL *pstFSAL) {
   if (pstFSAL->uRamFileSize != 0) {
      return (kal_uint8*)pstFSAL->pbFile;
   } else {
      return NULL;  
   }
}



void FSAL_Direct_SetRamFileSize(STFSAL *pstFSAL, kal_uint32 uSize)
{
   FSAL_ASSERT_NO_RET_VAL(pstFSAL!=NULL);
   pstFSAL->uRamFileSize = uSize;
}



void FSAL_Direct_SetMaxRamFileSize(STFSAL *pstFSAL, kal_uint32 uSize)
{
#if FSAL_PLATFORM_MEMORY
   FSAL_CHECK_ARG(pstFSAL!=NULL);
   pstFSAL->uMaxRamFileSize = uSize;
#endif
}



FSAL_Status FSAL_Direct_Close(STFSAL *pstFSAL)
{
   FSAL_CHECK_ARG(pstFSAL!=NULL);
   if ( pstFSAL->pbFile ) {
      pstFSAL->pbFile = 0;
      pstFSAL->uRamFileSize = 0;
      pstFSAL->uRamFileOffset = 0;
      return FSAL_OK;
   }
#if FSAL_PLATFORM_WIN32
   FSAL_CHECK_ARG(pstFSAL->hFile!=NULL);
   if (fclose((FILE*)pstFSAL->hFile)!=0)
      return FSAL_CLOSE_ERROR;
#elif FSAL_PLATFORM_KAL
   {
      FSAL_CHECK_ARG(pstFSAL->hFile>=0);
      if ((pstFSAL->iFSErrorCode = DRM_close_file(pstFSAL->hFile)) < 0) {
         if (pstFSAL->iFSErrorCode==FS_DEVICE_BUSY || pstFSAL->iFSErrorCode==FS_LOCK_MUTEX_FAIL)
            return FSAL_DEVICE_BUSY;
         else {
            kal_prompt_trace(MOD_MED, "[FSAL] FS_Close Error:%d\n", pstFSAL->iFSErrorCode);
            return FSAL_CLOSE_ERROR;
         }
      }
      pstFSAL->hFile = -1;
      pstFSAL->uFileSize = 0;
      pstFSAL->uFileOffset = 0;
   }
#endif
   return FSAL_OK;
}



FSAL_Status FSAL_Direct_Read(STFSAL *pstFSAL, kal_uint8* pbBuf, kal_uint32 uSize)
{
   FSAL_CHECK_ARG(pstFSAL!=NULL);
   FSAL_CHECK_ARG(uSize>0);
   if( pstFSAL->pbFile )
   {
      kal_mem_cpy(pbBuf, pstFSAL->pbFile + pstFSAL->uRamFileOffset, uSize);
      pstFSAL->uRamFileOffset += uSize;
      if (pstFSAL->uRamFileOffset > pstFSAL->uRamFileSize)
         return FSAL_READ_ERROR;
      return FSAL_OK;
   }
#if FSAL_PLATFORM_WIN32
   FSAL_CHECK_ARG(pstFSAL->hFile!=NULL);
   if (fread(pbBuf, uSize, 1, (FILE*)pstFSAL->hFile)!=1)
     return FSAL_READ_ERROR;
#elif FSAL_PLATFORM_KAL
   FSAL_CHECK_ARG(pstFSAL->hFile>=0);
   {
      kal_uint32 uBytesRead;
      pstFSAL->iFSErrorCode = DRM_read_file(pstFSAL->hFile, (void*)pbBuf, uSize, &uBytesRead);
      if ((pstFSAL->iFSErrorCode<0) || (uBytesRead!=uSize)) {
         if(pstFSAL->iFSErrorCode==FS_DEVICE_BUSY || pstFSAL->iFSErrorCode==FS_LOCK_MUTEX_FAIL)
            return FSAL_DEVICE_BUSY;
         else {
            kal_prompt_trace(MOD_MED, "[FSAL] FS_Read Error:%d\n", pstFSAL->iFSErrorCode);
            return FSAL_READ_ERROR;
         }
      }
   }
#endif
   return FSAL_OK;
}



FSAL_Status FSAL_Direct_Write(STFSAL *pstFSAL, kal_uint8* pbBuf, kal_uint32 uSize)
{
   FSAL_CHECK_ARG(pstFSAL!=NULL);
   FSAL_CHECK_ARG(pbBuf!=NULL);
   FSAL_CHECK_ARG(uSize>0);
#if FSAL_PLATFORM_WIN32
   FSAL_CHECK_ARG(pstFSAL->hFile!=NULL);
   if (fwrite(pbBuf, uSize, 1, (FILE*)pstFSAL->hFile)!=1)
     return FSAL_WRITE_ERROR;
#elif FSAL_PLATFORM_KAL
   FSAL_CHECK_ARG(pstFSAL->hFile>=0);
   {
      kal_uint32 uBytesWritten;
      pstFSAL->iFSErrorCode = FS_Write(pstFSAL->hFile, (void*)pbBuf, uSize, &uBytesWritten);
      if ((pstFSAL->iFSErrorCode<0) || (uBytesWritten!=uSize)) {
         if(pstFSAL->iFSErrorCode==FS_DEVICE_BUSY || pstFSAL->iFSErrorCode==FS_LOCK_MUTEX_FAIL)
            return FSAL_DEVICE_BUSY;
         else {
            kal_prompt_trace(MOD_MED, "[FSAL] FS_Write Error:%d\n", pstFSAL->iFSErrorCode);
            return FSAL_WRITE_ERROR;
         }
      }
   }
#elif FSAL_PLATFORM_MEMORY
   FSAL_CHECK_ARG(pstFSAL->pbFile!=NULL);
   {
      kal_mem_cpy(pstFSAL->pbFile + pstFSAL->uRamFileOffset, pbBuf, uSize);
      pstFSAL->uRamFileOffset += uSize;
      if (pstFSAL->uRamFileOffset > pstFSAL->uRamFileSize) {
         pstFSAL->uRamFileSize = pstFSAL->uRamFileOffset;
      }
      FSAL_CHECK_ARG(pstFSAL->uRamFileOffset <= pstFSAL->uMaxRamFileSize);
   }
#endif
   return FSAL_OK;
}



FSAL_Status FSAL_Direct_Seek(STFSAL *pstFSAL, kal_uint32 uOffset)
{
   FSAL_CHECK_ARG(pstFSAL!=NULL);
   if( pstFSAL->pbFile )
   {
      pstFSAL->uRamFileOffset = uOffset;
      if (pstFSAL->uRamFileOffset > pstFSAL->uRamFileSize)
         return FSAL_SEEK_ERROR;
      return FSAL_OK;
   }
#if FSAL_PLATFORM_WIN32
   FSAL_CHECK_ARG(pstFSAL->hFile!=NULL);
   {
      kal_uint32 uCurOffset;
      FSAL_Status eFSALRet;
      static kal_uint32 uHit=0;
      static kal_uint32 uMiss=0;
      printf("uHit=%d, uMiss=%d\n", uHit, uMiss);
      if ((eFSALRet=FSAL_Direct_GetCurPos(pstFSAL, &uCurOffset))!=FSAL_OK)
         return eFSALRet;
      if (uCurOffset == uOffset) {
         uHit++;
         return FSAL_OK;
      } else {
         uMiss++;
         if (fseek((FILE*)pstFSAL->hFile, uOffset, SEEK_SET)!=0)
           return FSAL_SEEK_ERROR;
      }
   }
#elif FSAL_PLATFORM_KAL
   {
      FSAL_CHECK_ARG(pstFSAL->hFile>=0);
      {
         kal_uint32 uCurOffset;
         FSAL_Status eFSALRet;
         if ((eFSALRet=FSAL_Direct_GetCurPos(pstFSAL, &uCurOffset))!=FSAL_OK)
            return eFSALRet;
         /* Because FS_Seek has performance issue, avoid to call FS_Seek
            whenever possible. */
         if (uCurOffset == uOffset)
            return FSAL_OK;
         else
         {
            pstFSAL->iFSErrorCode = DRM_seek_file(pstFSAL->hFile, uOffset, FS_FILE_BEGIN);
            if ((pstFSAL->iFSErrorCode<0) || (pstFSAL->iFSErrorCode!=(kal_int32)uOffset)) {
               if (pstFSAL->iFSErrorCode==FS_DEVICE_BUSY || pstFSAL->iFSErrorCode==FS_LOCK_MUTEX_FAIL)
                  return FSAL_DEVICE_BUSY;
               else {
                  kal_prompt_trace(MOD_MED, "[FSAL] FS_Seek Error:%d\n", pstFSAL->iFSErrorCode);
                  return FSAL_SEEK_ERROR;
               }
            }
         }
      }
   }
#endif
   return FSAL_OK;
}



FSAL_Status FSAL_Direct_GetCurPos(STFSAL *pstFSAL, kal_uint32* puPosition)
{
   FSAL_CHECK_ARG(pstFSAL!=NULL);
   FSAL_CHECK_ARG(puPosition!=NULL);
   if ( pstFSAL->pbFile ) {
      *puPosition = pstFSAL->uRamFileOffset;
      return FSAL_OK;
   }
#if FSAL_PLATFORM_WIN32
   FSAL_CHECK_ARG(pstFSAL->hFile!=NULL);
   *puPosition = ftell((FILE*)pstFSAL->hFile);
#elif FSAL_PLATFORM_KAL
   {
      FSAL_CHECK_ARG(pstFSAL->hFile>=0);
      pstFSAL->iFSErrorCode = FS_GetFilePosition(pstFSAL->hFile, puPosition);
      if (pstFSAL->iFSErrorCode < 0) {
         if (pstFSAL->iFSErrorCode==FS_DEVICE_BUSY || pstFSAL->iFSErrorCode==FS_LOCK_MUTEX_FAIL)
            return FSAL_DEVICE_BUSY;
         else {
            kal_prompt_trace(MOD_MED, "[FSAL] FS_GetFilePosition Error:%d\n", pstFSAL->iFSErrorCode);
            return FSAL_FATAL_ERROR;
         }
      }
   }
#endif
   return FSAL_OK;
}



FSAL_Status FSAL_Direct_GetFileSize(STFSAL *pstFSAL, kal_uint32 *puFileSize)
{
   FSAL_CHECK_ARG(pstFSAL!=NULL);
   FSAL_CHECK_ARG(puFileSize!=NULL);
   if ( pstFSAL->pbFile ) {
      *puFileSize = pstFSAL->uRamFileSize;
      return FSAL_OK;
   }
#if FSAL_PLATFORM_WIN32
   FSAL_CHECK_ARG(pstFSAL->hFile!=NULL);
   {
      kal_uint32 uCurPos;
      uCurPos = ftell((FILE*)pstFSAL->hFile);
      if (fseek((FILE*)pstFSAL->hFile, 0, SEEK_END)!=0)
        return FSAL_SEEK_ERROR;
      *puFileSize = ftell((FILE*)pstFSAL->hFile);
      if (fseek((FILE*)pstFSAL->hFile, uCurPos, SEEK_SET)!=0)
        return FSAL_SEEK_ERROR;
   }
#elif FSAL_PLATFORM_KAL
   {
      FSAL_CHECK_ARG(pstFSAL->hFile>=0);
      pstFSAL->iFSErrorCode = DRM_file_size(pstFSAL->hFile, puFileSize);
      if (pstFSAL->iFSErrorCode<0) {
         if (pstFSAL->iFSErrorCode==FS_DEVICE_BUSY || pstFSAL->iFSErrorCode==FS_LOCK_MUTEX_FAIL)
            return FSAL_DEVICE_BUSY;
         else {
         	kal_prompt_trace(MOD_MED, "[FSAL] FS_GetFileSize Error:%d\n", pstFSAL->iFSErrorCode);
            return FSAL_FATAL_ERROR;
         }
      }
   }
#endif
   return FSAL_OK;
}



/* Return the last file system error for error handling */
int FSAL_GetLastError(STFSAL *pstFSAL)
{
   FSAL_CHECK_ARG(pstFSAL != NULL);

#if FSAL_PLATFORM_WIN32
   return FSAL_FATAL_ERROR;
#elif FSAL_PLATFORM_KAL
   return pstFSAL->iFSErrorCode;
#elif FSAL_PLATFORM_MEMORY
   return FSAL_FATAL_ERROR;
#endif
}