d_loader.c

乐高机器人的源码,开发平台是IAR_for_AVR.

            if (((((SECTORSIZE - HEADERFIXEDSIZE)>>1)-1) == SectorTableIndex) || (((SectorTableIndex - ((SECTORSIZE - HEADERFIXEDSIZE)>>1)) & 0x7F) == 127))
            {
              SectorTableIndex++;
            }
            pHeader->FileSectorTable[SectorTableIndex] = (SectorIndex << 5) + Tmp;
            SectorTableIndex++;
            FileBodySectorSize--;
            if (0 == FileBodySectorSize)
            {
              Tmp             = 32;
              SectorIndex     = (NOOFSECTORS/32);
            }
          }
        }
      }
      SectorIndex++;
      Tmp = 0;
    }
  }
  else
  {
    Handle |= ErrorCode;
  }
  return(Handle);
}


UWORD     dLoaderFindFirstSector(UBYTE Type, UWORD SectorCount, UWORD *pSector)
{
  UWORD   CompleteSectorSize;
  UWORD   SectorIndex;
  UBYTE   Tmp;
  UWORD   SectorCnt;
  UWORD   ErrorCode;


  ErrorCode = SUCCESS;

  SectorIndex = SECTORINDEXUSERFLASH;
  Tmp         = SECTORPOINTERUSERFLASH;



  if (LINEAR & Type)
  {
    CompleteSectorSize  = SectorCount;
    ErrorCode           = NOLINEARSPACE;

    /* find linear adress space */
    SectorCnt = CompleteSectorSize;

    while ((SectorCnt  > 0) && (SectorIndex < (NOOFSECTORS>>5)))
    {
      if ((SectorTable[SectorIndex]) & ((ULONG)0x01<<Tmp))
      {
        SectorCnt = CompleteSectorSize;
      }
      else
      {
        SectorCnt--;
        if (0 == SectorCnt)
        {
          *pSector    = ((SectorIndex<<5) + Tmp) - CompleteSectorSize + 1;
          SectorIndex = (NOOFSECTORS>>5);
          ErrorCode   = SUCCESS;
        }
      }

      if (0x1F == Tmp)
      {
        SectorIndex++;
      }
      Tmp = (Tmp + 1) & 0x1F;
    }
  }
  else
  {
    ErrorCode = UNDEFINEDERROR;
    while(SectorIndex < (NOOFSECTORS>>5))
    {
      if (!((SectorTable[SectorIndex]) & ((ULONG)0x01<<Tmp)))
      {
        *pSector    = (SectorIndex<<5) + Tmp;
        SectorIndex = (NOOFSECTORS>>5);
        ErrorCode   = SUCCESS;
      }
      if (0x1F == Tmp)
      {
        SectorIndex++;
      }
      Tmp = (Tmp + 1) & 0x1F;
    }
  }
  return(ErrorCode);
}


UWORD     dLoaderFlashFileHeader(UWORD Handle, ULONG FileStartAdr, FILEHEADER *pHeader, UWORD HeaderByteSize)
{
  ULONG   *pBufPtr;
  ULONG   FlashPtr;
  UWORD   HeaderSectorSize;

  pBufPtr           = (ULONG*)pHeader;
  FlashPtr          = FileStartAdr;
  HeaderSectorSize  = (HeaderByteSize - 1)  >> SECTORSIZESHIFT;

  dLoaderWritePage(FlashPtr, SECTORSIZE, pBufPtr);

  while(HeaderSectorSize)
  {
    pBufPtr  += (SECTORSIZE>>2);
    FlashPtr  = (((*(pBufPtr - 1) & 0xFFFF0000) >> 16) << SECTORSIZESHIFT) | FLASHOFFSET;
    dLoaderWritePage(FlashPtr, SECTORSIZE, pBufPtr);
    HeaderSectorSize--;
  }

  /* Prepare for actual data download */
  memcpy(WriteBuffer[HandleTable[Handle].WriteBufNo].Buf, pBufPtr, SECTORSIZE);
  WriteBuffer[HandleTable[Handle].WriteBufNo].BufIndex = (UWORD)(pHeader->FileStartAdr) & (SECTORSIZE-1);
  HandleTable[Handle].pFlash = (UBYTE *)pHeader->FileStartAdr;

  return(Handle);
}

UWORD     dLoaderGetSectorNumber(ULONG Adr)
{
  UWORD SectorNo;

  SectorNo = (Adr & ~FLASHOFFSET)>>SECTORSIZESHIFT;

  return(SectorNo);
}


UWORD     dLoaderAllocateWriteBuffer(UWORD  Handle)
{
  UBYTE   Tmp;
  UWORD   ErrorCode;

  ErrorCode = NOWRITEBUFFERS;
  for (Tmp = 0; Tmp < MAX_WRITE_BUFFERS; Tmp++)
  {
    if (FREE == WriteBuffer[Tmp].Status)
    {
      WriteBuffer[Tmp].Status = BUSY;
      memset(WriteBuffer[Tmp].Buf, 0xFF, sizeof(WriteBuffer[Tmp].Buf));
      WriteBuffer[Tmp].BufIndex = 0;
      HandleTable[Handle].WriteBufNo = Tmp;
      ErrorCode = SUCCESS;
      Tmp = MAX_WRITE_BUFFERS;
    }
  }
  Handle |= ErrorCode;
  return(Handle);
}

UWORD     dLoaderCheckFiles(UBYTE Handle)
{
  UBYTE   Tmp;
  UBYTE   Index;
  UWORD   ErrorCode;

  ErrorCode = SUCCESS;
  Index = HandleTable[Handle].FileIndex;
  for (Tmp = 0; Tmp < MAX_HANDLES; Tmp++)
  {
    if ((BUSY == HandleTable[Tmp].Status) && (Index == HandleTable[Tmp].FileIndex) && (Tmp != Handle))
    {
      ErrorCode = FILEISBUSY;
    }
  }
  return(Handle | ErrorCode);
}

void     dLoaderCopyFileName(UBYTE *pDst, UBYTE *pSrc)
{
  UBYTE  Tmp;

  for(Tmp = 0; Tmp < FILENAME_SIZE; Tmp++, pDst++)
  {
    if ('\0' != *pSrc)
    {
      *pDst = *pSrc;
      pSrc++;
    }
    else
    {
      *pDst = '\0';
    }
  }
}

void      dLoaderCheckVersion(void)
{
  ULONG   Version;

  Version  = *(const ULONG*)(STARTOFFILETABLE + (MAX_FILES * 4));
  if (Version != FILEVERSION)
  {
    dLoaderDeleteAllFiles();
  }
}

UWORD     dLoaderOpenAppend(UBYTE *pFileName, ULONG *pAvailSize)
{
  UWORD       Handle;
  ULONG       FileSize, DataSize;
  UBYTE       Name[FILENAME_SIZE];
  FILEHEADER  *pHeader;

  *pAvailSize = 0;

  Handle = dLoaderFind(pFileName, Name, &FileSize, &DataSize, (UBYTE)BUSY);
  if (0x8000 > Handle)
  {

    /* Check for an append in progress for this file */
    if (0x8000 > dLoaderCheckDownload(pFileName))
    {

      /* File has bee found - check for then correct filetype (Datafile) */
      pHeader = (FILEHEADER *)Files[HandleTable[Handle].FileIndex];
      if (DATAFILE & pHeader->FileType)
      {
        if (FileSize > DataSize)
        {
          /* Append is possible */
          Handle = dLoaderAllocateWriteBuffer(Handle);
          if (Handle < 0x8000)
          {
            dLoaderSetFilePointer(Handle, DataSize, &(HandleTable[Handle].pFlash));
            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 );
            HandleTable[Handle].FileDlPtr  = Files[HandleTable[Handle].FileIndex];
            HandleTable[Handle].Status     = (UBYTE)DOWNLOADING;
            *pAvailSize                    = FileSize - DataSize;
            HandleTable[Handle].DataLength = *pAvailSize;
            HandleTable[Handle].FileType   = pHeader->FileType;
          }
        }
        else
        {
          Handle |= FILEISFULL;
        }
      }
      else
      {
        Handle |= APPENDNOTPOSSIBLE;
      }
    }
    else
    {
      Handle |= FILEISBUSY;
    }
  }

  return(Handle);
}


UWORD     dLoaderSetFilePointer(UWORD Handle, ULONG BytePtr, const UBYTE **pData)
{
  ULONG       AdrOffset;
  const UBYTE *Adr;
  UWORD       SectorNo;
  UWORD       Tmp;
  FILEHEADER  *pHeader;


  pData = pData;
  pHeader = (FILEHEADER*)Files[HandleTable[Handle].FileIndex];
  HandleTable[Handle].pSectorNo = pHeader->FileSectorTable;

  /* Get the sector offset */
  AdrOffset = SECTORSIZE - ((pHeader->FileStartAdr) & (SECTORSIZE - 1));

  if (BytePtr > AdrOffset)
  {
    BytePtr  = BytePtr - AdrOffset;
    SectorNo = ((BytePtr >> SECTORSIZESHIFT) + 1);

    for (Tmp = 0; Tmp < SectorNo; Tmp++)
    {
      Adr = dLoaderGetNextSectorPtr(Handle);
      if (BytePtr > SECTORSIZE)
      {
        BytePtr -= SECTORSIZE;
      }
    }
    *pData = (const UBYTE *)((ULONG)Adr + BytePtr);
  }
  else
  {

    /* Pointer reside in the first sector of the file body */
    *pData = (const UBYTE *)((ULONG)(pHeader->FileStartAdr) + BytePtr);
  }
  return(Handle);
}

void      dLoaderCpyToLower(UBYTE *pDst, UBYTE *pSrc, UBYTE Length)
{
  UBYTE   Tmp;

  for(Tmp = 0; Tmp < Length; Tmp++)
  {
    pDst[Tmp] =(UBYTE)toupper((UWORD)pSrc[Tmp]);
  }

  /* The requried length has been copied - now fill with zeros */
  for(Tmp = Length; Tmp < FILENAME_SIZE; Tmp++)
  {
    pDst[Tmp] = '\0';
  }
}

UWORD     dLoaderCheckName(UBYTE *pName, UBYTE *pSearchStr, UBYTE SearchType)
{
  UBYTE   TmpName[FILENAME_SIZE];
  UWORD   RtnVal;

  RtnVal  = UNDEFINEDERROR;

  dLoaderCpyToLower(TmpName, pName, (UBYTE)FILENAME_SIZE);

  RtnVal = SUCCESS;
  switch (SearchType)
  {
    case FULLNAME:
    {
      if (0 != strcmp((const char*)TmpName, (const char *)pSearchStr))
      {
        RtnVal = UNDEFINEDERROR;
      }
    }
    break;
    case NAME:
    {
      if (0 != memcmp(TmpName, pSearchStr, strlen((const char *)pSearchStr)))
      {
        RtnVal = UNDEFINEDERROR;
      }
    }
    break;
    case EXTENTION:
    {
      if (0 == strstr((const char *)TmpName, (const char*)pSearchStr))
      {
        RtnVal = UNDEFINEDERROR;
      }
    }
    break;
    case WILDCARD:
    {
      RtnVal = SUCCESS;
    }
    break;
    default:
    {
    }
    break;
  }
  return(RtnVal);
}

void      dLoaderInsertSearchStr(UBYTE *pDst, UBYTE *pSrc, UBYTE *pSearchType)
{
  UBYTE  Tmp;

  *pSearchType = WILDCARD;
  if (0 != strstr((char const *)pSrc, "*.*"))
  {

    /* find all */
    strcpy ((PSZ)pDst, (PSZ)pSrc);
    *pSearchType = WILDCARD;
  }
  else
  {

    /* Using other wild cards? */
    Tmp =  strlen((char const *)pSrc);
    if (0 != strstr((PSZ)(pSrc), ".*"))
    {

      /* Extention wildcard */
      dLoaderCpyToLower(pDst, pSrc, (Tmp-1));
      *pSearchType = NAME;
    }
    else
    {
      if (0 != strstr((PSZ)(pSrc), "*."))
      {

        /* Filename wildcard */
        dLoaderCpyToLower(pDst, &pSrc[1], (UBYTE)4);
        *pSearchType = EXTENTION;
      }
      else
      {

        /* no wildcards used */
        dLoaderCpyToLower(pDst, pSrc, Tmp);
        *pSearchType = FULLNAME;
      }
    }
  }
}

UWORD     dLoaderCheckHandle(UWORD Handle, UBYTE Operation)
{

  if (MAX_HANDLES > Handle)
  {
    if (Operation != HandleTable[(UBYTE)Handle].Status)
    {
      Handle |= ILLEGALHANDLE;
    }
  }
  else
  {
    Handle |= ILLEGALHANDLE;
  }
  return(Handle);
}

ULONG     dLoaderReturnFreeUserFlash(void)
{
  return(FreeUserFlash);
}

UWORD     dLoaderRenameFile(UBYTE Handle, UBYTE *pNewName)
{
  ULONG       SectorBuf[SECTORSIZE/4];
  ULONG       *pFile;
  UBYTE       Tmp;
  FILEHEADER  *pHeader;

  pFile = (ULONG *)Files[HandleTable[Handle].FileIndex];
  for (Tmp = 0; Tmp < (SECTORSIZE/4); Tmp++)
  {
    SectorBuf[Tmp] = pFile[Tmp];
  }

  pHeader = (FILEHEADER *) SectorBuf;

  dLoaderCopyFileName((pHeader->FileName), pNewName);
  dLoaderWritePage((ULONG)pFile, SECTORSIZE, SectorBuf);
  return(SUCCESS);
}


UWORD     dLoaderCheckDownload(UBYTE *pName)
{
  UBYTE   Tmp;
  UWORD   ErrorCode;

  ErrorCode = SUCCESS;
  for(Tmp = 0; Tmp < MAX_HANDLES; Tmp ++)
  {
    if (DOWNLOADING == HandleTable[Tmp].Status)
    {
      if (SUCCESS == dLoaderCheckName(pName, HandleTable[Tmp].SearchStr, FULLNAME))
      {
        Tmp = MAX_HANDLES;
        ErrorCode = FILEEXISTS;
      }
    }
  }
  return(ErrorCode);
}


void      dLoaderExit(void)
{
}