bfsa_api.c

ATMEL公司的demo程序,USB驱动程序,与识别片上flash,并进行枚举和操作.

  return _dataWritten;
}

/*****************************************************************
*
*
* S U B - R O U T I N E  : BFSA_read
*
*-----------------------------------------------------------------
*
* int BFSA_read(char* filename,char* dataBuffer,ULONG dataSize,ULONG offset)
*
* Object:
*   This function reads data from file from the current directory.
*
* Argument:
*       filename        [IN] : pointer to file name to read.
*       dataBuffer      [OUT]: buffer allocated by caller.
*       dataSize        [IN] : size to read.
*       offset          [IN] : offset in file.
*
* Return value:
*       size read on success,
*       on error:       FILE_NOT_EXIST
*                       ERROR_READING_FAT_ENTRY
*                       MEMORY_ERROR
*                       FLASH_ACCESS_ERROR
*                       BAD_ARGUMENT
*                       OFFSET_OVERFLOW
*
*****************************************************************/
ULONG BFSA_read(char* filename,char* dataBuffer,ULONG dataSize,ULONG offset)
{
  ULONG _dataSizeRead = 0;
  ULONG _sizeToRead;
  USHORT _fileCluster;
  USHORT _offsetCluster = (offset/(BFSA_media.SectPerCluster * BFSA_media.bytesPerSector));
  UCHAR *pucAdd;

  // Check parameters
  if (!filename || !dataBuffer || dataSize == 0)
      return BAD_ARGUMENT;

  // Check filename validity
  if (!isValidFileName(filename))
      return BAD_ARGUMENT;

  // Lock and Load FAT
  po_lock();
  readFAT();

  _fileCluster = findFile(filename);
  if (!_fileCluster)
  {
    po_unlock();
    return FILE_NOT_EXIST;
  }

  // Run through the cluster chain to the offsetCluster
  while (_offsetCluster)
  {
    _fileCluster = getNextCluster(_fileCluster);
    if (_fileCluster == 0)
    {
      // No more cluster in chain, try to read out of bounds offset
      po_unlock();
      return OFFSET_OVERFLOW;
    }
    _offsetCluster--;
  }

  // _fileCluster is the rigth Cluster to start the read
  do
  {
    _sizeToRead = min(dataSize,(BFSA_media.SectPerCluster * BFSA_media.bytesPerSector));
    pucAdd =(UCHAR*)( FIRST_SECTOR_DATACLUSTER(_fileCluster) * BFSA_media.bytesPerSector)
                     + (unsigned int)FlashBaseAdd;
    po_memcpy(dataBuffer,pucAdd,_sizeToRead);  // jcb read flash
    dataSize -= _sizeToRead;
    _dataSizeRead += _sizeToRead;
    // Get the next cluster
    _fileCluster = getNextCluster(_fileCluster);
  }while (dataSize && _fileCluster);

  po_unlock();

  return _dataSizeRead;
}

/*****************************************************************
*
*
* S U B - R O U T I N E  : BFSA_delete
*
*-----------------------------------------------------------------
*
* int BFSA_delete(char* filename)
*
* Object:
*   This function deletes a file or directory from the current directory.
*
* Argument:
*       filename        :[IN] pointer to the file name to delete.
*
* Return value:
*       0 if success,
*       on error:       FILE_NOT_EXIST
*                       ERROR_READING_FAT_ENTRY
*                       FLASH_ACCESS_ERROR
*                       BAD_ARGUMENT
*                       DIRECTORY_NOT_EMPTY
*
*****************************************************************/
ULONG BFSA_delete(char* filename)
{
  ULONG _status = BFSA_SUCCESS;

  // Check parameter
  if (!filename)
  {
    return BAD_ARGUMENT;
  }

  // Check Name validity
  if (!isValidFileName(filename))
  {
    return BAD_ARGUMENT;
  }

  // Lock and Load FAT
  po_lock();
  readFAT();

  _status = deleteFile(filename);
  if (!BFSA_FAILURE(_status))
  {
    // Save and unlock FAT
    _status = writeFAT();
  }
  po_unlock();

  return _status;
}

/*****************************************************************
*
*
* S U B - R O U T I N E  : BFSA_mkdir
*
*-----------------------------------------------------------------
*
* int BFSA_mkdir(char *filename)
*
* Object:
*   This function creates a new directory in current directory.
*
* Argument:
*       fileName        [IN]: pointer to the new directory name.
*
* Return value:
*       0 if success,
*       on error:       DIRECTORY_ALREADY_EXIST
*                       NOT_A_VALID_DIRECTORY
*                       FLASH_ACCESS_ERROR
*                       BAD_ARGUMENT
*                       DISK_FULL
*
*****************************************************************/
ULONG BFSA_mkdir(char* filename)
{
  ULONG  _status = BFSA_SUCCESS;
  USHORT _newDirStartCluster;
  USHORT _CurrentDirCluster = BFSA_current_dir.DirStart;
  UCHAR  _newEntry[32];
  UCHAR  i;

  if (!filename)
  {
      _status = BAD_ARGUMENT;
      goto END;
  }

  // Check Name validity
  if (!isValidFileName(filename))
      return NOT_A_VALID_DIRECTORY;

  // Lock and Load FAT
  po_lock();
  readFAT();

  // Look for already existing file name and find a free entry in directory
  if (findFile(filename))
  {
      // File already exists
      po_unlock();
      return DIRECTORY_ALREADY_EXIST;
  }

  // Get a free cluster
  _newDirStartCluster = findFreeCluster();
  if (!_newDirStartCluster)
  {
      po_unlock();
      return DISK_FULL;
  }

  // Populate the new directory
  padFileName(filename,(char*)_newEntry);
  _newEntry[11] = BFSA_ATTR_DIRECTORY; // for DIR
  _newEntry[12] = 0;                  // reserved
  _newEntry[13] = 0;                  // ms
  _newEntry[14] = _newEntry[15] = 0;  // Time
  _newEntry[16] = 0x11;               // Date
  _newEntry[17] = 0x00;
  _newEntry[18] = _newEntry[19] = 0;  // Last acc
  _newEntry[20] = _newEntry[21] = 0;  // Hi Cluster
  _newEntry[22] = _newEntry[23] = 0;  // WrtTime
  _newEntry[24] = _newEntry[25] = 0;  // WrDate
  _newEntry[26] = LOW_BYTE(_newDirStartCluster);   // Cluster LO
  _newEntry[27] = HIGH_BYTE(_newDirStartCluster);  // Cluster LO
  _newEntry[28] = _newEntry[29] = 0;  // Size always 0 for directory
  _newEntry[30] = _newEntry[31] = 0;  // Size always 0 for directory

  _status = addNewEntry(_newEntry,_CurrentDirCluster,BFSA_current_dir.IsRoot);
  if (BFSA_FAILURE(_status))
  {
      // Can't add a new entry
      writeFatEntry(_newDirStartCluster,FREE);
      po_unlock();
      return _status;
  }

  // Create . directory
  for( i=0; i<8+3; i++ )
  {
    _newEntry[i] = 0x20;
  }
  _newEntry[0] = '.';
  _status = addNewEntry(_newEntry,_newDirStartCluster,FALSE);
  if (BFSA_FAILURE(_status))
  {
      // Can't add a new entry
      writeFatEntry(_newDirStartCluster,FREE);
      deleteEntry(filename);
      po_unlock();
      return _status;
  }

  // Create .. directory
  _newEntry[1] = '.';
  if (BFSA_current_dir.IsRoot)
  {
      _newEntry[26] = 0x00;   // Cluster LO
      _newEntry[27] = 0x00;   // Cluster LO
  }
  else
  {
      _newEntry[26] = LOW_BYTE(_CurrentDirCluster);   // Cluster LO
      _newEntry[27] = HIGH_BYTE(_CurrentDirCluster);  // Cluster LO
  }
  _status = addNewEntry(_newEntry,_newDirStartCluster,FALSE);
  if (BFSA_FAILURE(_status))
  {
      // Can't add a new entry
      writeFatEntry(_newDirStartCluster,FREE);
      deleteEntry(filename);
      po_unlock();
      return _status;
  }

  // Save and unlock FAT
  _status = writeFAT();
   po_unlock();

  END:
  return _status;
}

/*****************************************************************
*
*
* S U B - R O U T I N E  : BFSA_rename
*
*-----------------------------------------------------------------
*
* int BFSA_rename(char* curFilename, char* newFilename)
*
* Object:
*   This function rename a file or directory in the current directory.
*
* Argument:
*       curFilename     [IN]: pointer to the file name.
*       newFilename     [IN]: pointer to the new file name
*
* Return value:
*       0 if success,
*       on error:       FILE_ALREADY_EXIST
*                       FILE_NOT_EXIST
*                       FLASH_ACCESS_ERROR
*                       BAD_ARGUMENT
*
****************************************************************/
ULONG BFSA_rename(char* curFilename, char* newFilename)
{
  UCHAR *_pucEntry;
  char strFileName[8+3] = {'\0'};

  // Check parameters
  if (!curFilename || ! newFilename)
  {
    return BAD_ARGUMENT;
  }
  // Check Name validity
  if (!isValidFileName(curFilename) || !isValidFileName(newFilename))
    return BAD_ARGUMENT;

  // Lock and Load FAT
  po_lock();

  // Look for already existing file name
  if (findFile(newFilename))
  {
    // File already exists
    po_unlock();
    return FILE_ALREADY_EXIST;
  }

  // Look for the file to rename
  _pucEntry = (UCHAR*)findEntry (curFilename);
  if (!_pucEntry)
  {
    // File not found
    po_unlock();
    return FILE_NOT_EXIST;
  }

  padFileName(newFilename,strFileName);
  if( FALSE == AT91F_Flash_Write_Address((unsigned int)_pucEntry,sizeof strFileName,(UCHAR*)strFileName, FALSE) )
  {
    po_unlock();
    return FLASH_ACCESS_ERROR;
  }

  // Save and unlock FAT
  po_unlock();

  return BFSA_SUCCESS;
}

#ifdef BSFA_CHMOD
/*****************************************************************
*
*
* S U B - R O U T I N E  : BFSA_chmod
*
*-----------------------------------------------------------------
*
* int BFSA_chmod(char* filename,unsigned char newAttrib)
*
* Object:
*   This function changes the properties of the file in the current
*   directory.
*
* Argument:
*       filename        [IN]: pointer to the file name.
*       newAttrib       [IN]: new properties value.
*
* Return value:
*       0 if success,
*       on error:       FILE_NOT_EXIST
*                       FLASH_ACCESS_ERROR
*                       BAD_ARGUMENT
*
****************************************************************/
ULONG BFSA_chmod(char* filename,unsigned char newAttrib)
{
  UCHAR *_pucEntry;

  // Check parameters
  if (!filename)
  {
      return BAD_ARGUMENT;
  }
  // Check Name validity
  if (!isValidFileName(filename))
      return BAD_ARGUMENT;

  // Lock and Load FAT
  po_lock();

  // Look for the file
  _pucEntry = (UCHAR*)findEntry (filename);
  if (!_pucEntry)
  {
      // File not found
      po_unlock();
      return FILE_NOT_EXIST;
  }

  if( FALSE == AT91F_Flash_Write_Address((unsigned int)&_pucEntry[11],1,&newAttrib, FALSE) )
  {
    po_unlock();
    return FLASH_ACCESS_ERROR;
  }

  // Save and unlock FAT
  po_unlock();

  return BFSA_SUCCESS;
}
#endif /* BSFA_CHMOD */