diff options
Diffstat (limited to 'FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_fat.c')
| -rw-r--r-- | FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_fat.c | 1546 |
1 files changed, 1546 insertions, 0 deletions
diff --git a/FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_fat.c b/FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_fat.c new file mode 100644 index 000000000..258c2a40b --- /dev/null +++ b/FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/ff_fat.c @@ -0,0 +1,1546 @@ +/*
+ * FreeRTOS+FAT build 191128 - Note: FreeRTOS+FAT is still in the lab!
+ * Copyright (C) 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * Authors include James Walmsley, Hein Tibosch and Richard Barry
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * https://www.FreeRTOS.org
+ *
+ */
+
+/**
+ * @file ff_fat.c
+ * @ingroup FAT
+ *
+ * @defgroup FAT Fat File-System
+ * @brief Handles FAT access and traversal.
+ *
+ * Provides file-system interfaces for the FAT file-system.
+ **/
+
+#include "ff_headers.h"
+#include <string.h>
+
+
+#if ffconfigFAT_USES_STAT
+ /* This module make use of a buffer caching called 'FF_FATBuffers_t'.
+ * The struct below may gather statistics about its usage: hits/misses.
+ */
+ struct SFatStat fatStat;
+#endif /* ffconfigFAT_USES_STAT */
+
+
+/* prvGetFromFATBuffers() will see if the FF_Buffer_t pointed to by ppxBuffer contains the
+ * buffer that is needed, i.e. opened for the same sector and with the correct R/W mode.
+ * If ppxBuffer is NULL or if it can not be used, a new buffer will be created.
+ * The buffer pointed to by ppxBuffer will either be released or its pointer will be returned.
+ */
+FF_Buffer_t *prvGetFromFATBuffers( FF_IOManager_t *pxIOManager, FF_FATBuffers_t *pxFATBuffers, BaseType_t xBufferIndex, uint32_t ulFATSector,
+ FF_Error_t *pxError, uint8_t ucMode );
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ /* A very special case for FAT12: an entry is stored in two sectors.
+ * Read the two sectors and merge the two values found.
+ */
+ static uint32_t prvGetFAT12Entry( FF_IOManager_t *pxIOManager, FF_Error_t *pxError, FF_FATBuffers_t *pxFATBuffers, uint32_t ulFATSector );
+#endif
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ /* Same as above: put a FAT12 entry that is spread-out over two sectors.
+ * Read the current value first to preserve and merge the earlier 4 bits
+ * of an adjacent FAT12 entry.
+ */
+ static FF_Error_t prvPutFAT12Entry( FF_IOManager_t *pxIOManager, uint32_t ulCluster, uint32_t ulValue, FF_FATBuffers_t *pxFATBuffers,
+ uint32_t ulFATSector );
+#endif
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ /* A generic less-optimised way of finding the first free cluster.
+ * Used for FAT12 only.
+ */
+ static uint32_t prvFindFreeClusterSimple( FF_IOManager_t *pxIOManager, FF_Error_t *pxError );
+#endif /* ffconfigFAT12_SUPPORT */
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ /* A generic less-optimised way of counting free clusters.
+ * Used for FAT12 only.
+ */
+ static uint32_t prvCountFreeClustersSimple( FF_IOManager_t *pxIOManager, FF_Error_t *pxError );
+#endif /* ffconfigFAT12_SUPPORT */
+
+
+
+/* Have a cluster number and translate it to an LBA (Logical Block Address).
+'ulSectorsPerCluster' should be seen as 'blocks per cluster', where the length of one
+block is defined in the PBR (Partition Boot Record) at FF_FAT_BYTES_PER_SECTOR (offset 0x0B).
+*/
+uint32_t FF_Cluster2LBA( FF_IOManager_t *pxIOManager, uint32_t ulCluster )
+{
+uint32_t ulLBA = 0;
+FF_Partition_t *pxPartition;
+
+ if( pxIOManager != NULL )
+ {
+ pxPartition = &( pxIOManager->xPartition );
+
+ if( ulCluster >= 2 )
+ {
+ ulLBA = ( ( ulCluster - 2 ) * pxPartition->ulSectorsPerCluster ) + pxPartition->ulFirstDataSector;
+ }
+ else
+ {
+ ulLBA = pxPartition->ulClusterBeginLBA;
+ }
+ }
+
+ return ulLBA;
+}
+/*-----------------------------------------------------------*/
+
+/*
+ * Major and Minor sectors/blocks:
+ *
+ * A cluster is defined as N "sectors". Those sectors in fact are "major blocks"
+ * whose size is defined in a field called 'FF_FAT_BYTES_PER_SECTOR' in the PBR.
+ *
+ * I/O to the disk takes place in "minor block" of usually 512 byte and the addressing
+ * is also based on "minor block" sector numbers.
+ *
+ * In most cases, Major == Minor == 512 bytes.
+ *
+ * Here below some translations are done for 'entries', which can be 1-byte entries
+ * as well as the 32-byte directory entries.
+ *
+ */
+
+/* Translate an 'entry number' (ulEntry) to a relative cluster number,
+where e.g. 'ulEntry' may be a sequence number of a directory entry for
+which ulEntrySize = 32 bytes.
+*/
+uint32_t FF_getClusterChainNumber( FF_IOManager_t *pxIOManager, uint32_t ulEntry, uint32_t ulEntrySize )
+{
+uint32_t ulBytesPerCluster = pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster;
+uint32_t ulEntriesPerCluster = ( ulBytesPerCluster / ulEntrySize );
+
+ /* E.g. ulBytesPerCluster = 16384, ulEntrySize = 32: 16384 / 32 = 512 entries per cluster. */
+ return ulEntry / ulEntriesPerCluster;
+}
+/*-----------------------------------------------------------*/
+
+/* If the above function returns a cluster number, this function
+returns a BYTE position within that cluster. */
+uint32_t FF_getClusterPosition( FF_IOManager_t *pxIOManager, uint32_t ulEntry, uint32_t ulEntrySize )
+{
+uint32_t ulBytesPerCluster = pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster;
+uint32_t ulEntriesPerCluster = ( ulBytesPerCluster / ulEntrySize );
+
+ /* Return the block offset within the current cluster: */
+ return ( ulEntry % ulEntriesPerCluster ) * ulEntrySize;
+}
+/*-----------------------------------------------------------*/
+
+/* Return the block offset (= number of major blocks) within the current cluster: */
+uint32_t FF_getMajorBlockNumber( FF_IOManager_t *pxIOManager, uint32_t ulEntry, uint32_t ulEntrySize )
+{
+uint32_t ulBytesPerCluster = pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster;
+uint32_t ulEntriesPerCluster = ( ulBytesPerCluster / ulEntrySize );
+uint32_t ulRelClusterEntry;
+
+ /* Calculate the entry number within a cluster: */
+ ulRelClusterEntry = ulEntry % ulEntriesPerCluster;
+
+ /* Return the block offset within the current cluster: */
+ return ulRelClusterEntry / ( pxIOManager->xPartition.usBlkSize / ulEntrySize );
+}
+/*-----------------------------------------------------------*/
+
+/* Return the minor block number within the current major block */
+uint32_t FF_getMinorBlockNumber( FF_IOManager_t *pxIOManager, uint32_t ulEntry, uint32_t ulEntrySize )
+{
+uint32_t ulBytesPerCluster = pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster;
+uint32_t ulEntriesPerCluster = ( ulBytesPerCluster / ulEntrySize );
+uint32_t ulRelClusterEntry;
+uint32_t ulRelMajorBlockEntry;
+
+ /* Calculate the entry number within a cluster: */
+ ulRelClusterEntry = ulEntry % ulEntriesPerCluster;
+
+ ulRelMajorBlockEntry = ulRelClusterEntry % ( pxIOManager->xPartition.usBlkSize / ulEntrySize );
+
+ return ulRelMajorBlockEntry / ( pxIOManager->usSectorSize / ulEntrySize );
+}
+/*-----------------------------------------------------------*/
+
+/* Get the entry number within the minor block */
+uint32_t FF_getMinorBlockEntry( FF_IOManager_t *pxIOManager, uint32_t ulEntry, uint32_t ulEntrySize )
+{
+uint32_t ulBytesPerCluster = pxIOManager->xPartition.usBlkSize * pxIOManager->xPartition.ulSectorsPerCluster;
+uint32_t ulEntriesPerCluster = ( ulBytesPerCluster / ulEntrySize );
+uint32_t ulRelClusterEntry;
+uint32_t ulRelMajorBlockEntry;
+
+ /* Calculate the entry number within a cluster: */
+ ulRelClusterEntry = ulEntry % ulEntriesPerCluster;
+
+ ulRelMajorBlockEntry = ulRelClusterEntry % ( pxIOManager->xPartition.usBlkSize / ulEntrySize );
+
+ return ulRelMajorBlockEntry % ( pxIOManager->usSectorSize / ulEntrySize );
+}
+/*-----------------------------------------------------------*/
+
+FF_Error_t FF_ReleaseFATBuffers( FF_IOManager_t *pxIOManager, FF_FATBuffers_t *pxFATBuffers )
+{
+BaseType_t xIndex;
+FF_Error_t xError = FF_ERR_NONE;
+FF_Buffer_t *pxBuffer;
+#if ffconfigBUF_STORE_COUNT != 2
+ #warning Only maintaining one FAT table
+#endif
+ /* 'ffconfigBUF_STORE_COUNT' equals to the number of FAT tables. */
+ for( xIndex = 0; xIndex < ffconfigBUF_STORE_COUNT; xIndex++ )
+ {
+ pxBuffer = pxFATBuffers->pxBuffers[ xIndex ];
+ if( pxBuffer != NULL )
+ {
+ FF_Error_t xTempError = FF_ERR_NONE;
+
+ pxFATBuffers->pxBuffers[ xIndex ] = NULL;
+ xTempError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ /* as everywhere, this function will return
+ the first error that occurred, if any. */
+ xError = xTempError;
+ }
+ }
+ }
+ #if ffconfigFAT_USES_STAT
+ {
+ fatStat.clearCount++;
+ }
+ #endif /* ffconfigFAT_USES_STAT */
+
+ return xError;
+}
+/*-----------------------------------------------------------*/
+
+FF_Buffer_t *prvGetFromFATBuffers( FF_IOManager_t *pxIOManager, FF_FATBuffers_t *pxFATBuffers, BaseType_t xBufferIndex,
+ uint32_t ulFATSector, FF_Error_t *pxError, uint8_t ucMode )
+{
+FF_Error_t xError = FF_ERR_NONE;
+FF_Buffer_t *pxBuffer = NULL;
+
+ if( pxFATBuffers != NULL )
+ {
+ /* See if the same buffer can be reused. */
+ pxBuffer = pxFATBuffers->pxBuffers[ xBufferIndex ];
+
+ if( pxBuffer != NULL )
+ {
+ /* Now the buffer is either owned by pxBuffer,
+ or it has been released, so put it to NULL. */
+ pxFATBuffers->pxBuffers[ xBufferIndex ] = NULL;
+
+ if(
+ ( pxBuffer->ulSector == ulFATSector ) &&
+ ( ( ( ucMode & FF_MODE_WRITE ) == 0 ) ||
+ ( ( pxBuffer->ucMode & FF_MODE_WRITE ) != 0 ) )
+ )
+ {
+ /* Same sector, AND
+ write-permission is not required OR the buffer has write permission:
+ it can be reused. */
+ #if ffconfigFAT_USES_STAT
+ {
+ fatStat.reuseCount[ ( ucMode & FF_MODE_WRITE ) ? 1 : 0 ]++;
+ }
+ #endif /* ffconfigFAT_USES_STAT */
+ }
+ else
+ {
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ pxBuffer = NULL;
+ #if ffconfigFAT_USES_STAT
+ {
+ fatStat.missCount[ ( ucMode & FF_MODE_WRITE ) ? 1 : 0 ]++;
+ }
+ #endif /* ffconfigFAT_USES_STAT */
+ }
+ }
+ else
+ {
+ #if ffconfigFAT_USES_STAT
+ {
+ fatStat.getCount[ ( ucMode & FF_MODE_WRITE ) ? 1 : 0 ]++;
+ }
+ #endif /* ffconfigFAT_USES_STAT */
+ }
+ }
+
+ if( ( pxBuffer == NULL ) && ( FF_isERR( xError ) == pdFALSE ) )
+ {
+ pxBuffer = FF_GetBuffer( pxIOManager, ulFATSector, ucMode );
+ if( pxBuffer == NULL )
+ {
+ /* Setting an error code without the Module/Function,
+ will be filled-in by the caller. */
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_ERRFLAG );
+ }
+ }
+ *pxError = xError;
+
+ return pxBuffer;
+}
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ /* A very special case for FAT12: an entry is stored in two sectors.
+ Read the two sectors and merge the two values found. */
+ static uint32_t prvGetFAT12Entry( FF_IOManager_t *pxIOManager, FF_Error_t *pxError, FF_FATBuffers_t *pxFATBuffers,
+ uint32_t ulFATSector )
+ {
+ FF_Error_t xError = FF_ERR_NONE;
+ FF_Buffer_t *pxBuffer = NULL;
+ /* preferred buffer access mode, user might want to update this entry
+ and set it to FF_MODE_WRITE. */
+ uint8_t ucMode = pxFATBuffers ? pxFATBuffers->ucMode : FF_MODE_READ;
+ /* Collect the two bytes in an array. */
+ uint8_t ucBytes[ 2 ];
+ /* The function return value. */
+ uint32_t ulFATEntry = 0UL;
+
+ pxBuffer = prvGetFromFATBuffers( pxIOManager, pxFATBuffers, 0, ulFATSector, &xError, ucMode );
+
+ if( FF_isERR( xError ) )
+ {
+ xError = FF_GETERROR( xError ) | FF_GETFATENTRY;
+ }
+ else
+ {
+ /* Fetch the very last byte of this segment. */
+ ucBytes[ 0 ] = FF_getChar( pxBuffer->pucBuffer, ( uint16_t ) ( pxIOManager->usSectorSize - 1 ) );
+
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+
+ /* release the other buffer as well. */
+ if( ( FF_isERR( xError ) == pdFALSE ) && ( pxFATBuffers != NULL ) )
+ {
+ xError = FF_ReleaseFATBuffers( pxIOManager, pxFATBuffers );
+ }
+
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ /* Second Buffer get the first Byte in buffer (second byte of out address)! */
+ pxBuffer = FF_GetBuffer( pxIOManager, ulFATSector + 1, ucMode );
+ if( pxBuffer == NULL )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_GETFATENTRY );
+ }
+ else
+ {
+ /* Read the first byte from the subsequent sector. */
+ ucBytes[ 1 ] = FF_getChar( pxBuffer->pucBuffer, 0 );
+ /* And release that buffer. */
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ /* Join the two bytes: */
+ ulFATEntry = ( uint32_t ) FF_getShort( ( uint8_t * )ucBytes, 0 );
+ }
+ }
+ }
+ }
+ *pxError = xError;
+
+ return ( int32_t ) ulFATEntry;
+ }
+#endif /* ffconfigFAT12_SUPPORT */
+/*-----------------------------------------------------------*/
+
+
+/* Get a FAT entry, which is nothing more than a number referring to a sector. */
+uint32_t FF_getFATEntry( FF_IOManager_t *pxIOManager, uint32_t ulCluster, FF_Error_t *pxError, FF_FATBuffers_t *pxFATBuffers )
+{
+FF_Buffer_t *pxBuffer = NULL;
+uint32_t ulFATOffset;
+uint32_t ulFATSector = 0;
+uint32_t ulFATSectorEntry;
+/* The function result. */
+uint32_t ulFATEntry = 0;
+uint32_t ulLBAAdjust;
+uint32_t ulRelClusterEntry = 0;
+FF_Error_t xError = FF_ERR_NONE;
+/* preferred mode, user might want to update this entry. */
+uint8_t ucMode = pxFATBuffers ? pxFATBuffers->ucMode : FF_MODE_READ;
+
+ FF_Assert_Lock( pxIOManager, FF_FAT_LOCK );
+
+ if( ulCluster >= pxIOManager->xPartition.ulNumClusters )
+ {
+ /* _HT_ find a more specific error code.
+ Probably not really important as this is a function internal to the library. */
+ xError = ( FF_Error_t ) ( FF_ERR_IOMAN_NOT_ENOUGH_FREE_SPACE | FF_GETFATENTRY );
+ }
+ else
+ {
+ if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
+ {
+ ulFATOffset = ulCluster * 4;
+ }
+ else if( pxIOManager->xPartition.ucType == FF_T_FAT16 )
+ {
+ ulFATOffset = ulCluster * 2;
+ }
+ else /* pxIOManager->xPartition.ucType == FF_T_FAT12 */
+ {
+ ulFATOffset = ulCluster + ( ulCluster / 2 );
+ }
+
+ ulFATSector = pxIOManager->xPartition.ulFATBeginLBA + ( ulFATOffset / pxIOManager->xPartition.usBlkSize );
+ ulFATSectorEntry = ulFATOffset % pxIOManager->xPartition.usBlkSize;
+
+ ulLBAAdjust = ulFATSectorEntry / ( ( uint32_t ) pxIOManager->usSectorSize );
+ ulRelClusterEntry = ulFATSectorEntry % pxIOManager->usSectorSize;
+
+ ulFATSector = FF_getRealLBA( pxIOManager, ulFATSector );
+ ulFATSector += ulLBAAdjust;
+ }
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ if( ( pxIOManager->xPartition.ucType == FF_T_FAT12 ) &&
+ ( FF_isERR( xError ) == pdFALSE ) &&
+ ( ulRelClusterEntry == ( uint32_t ) ( ( pxIOManager->usSectorSize - 1 ) ) ) )
+ {
+ /* Fat Entry SPANS a Sector!
+ It has 4 bits on one sector and 8 bits on the other sector.
+ Handle this in a separate function prvGetFAT12Entry(). */
+ ulFATEntry = prvGetFAT12Entry( pxIOManager, &xError, pxFATBuffers, ulFATSector );
+
+ if( ( ulCluster & 0x0001 ) != 0 )
+ {
+ /* For odd clusters, shift the address 4 bits to the right: */
+ ulFATEntry = ( ulFATEntry & 0xfff0 ) >> 4;
+ }
+ else
+ {
+ /* For even clusters, take the lower 12 bits: */
+ ulFATEntry = ( ulFATEntry & 0x0fff );
+ }
+ /* Return ulFATEntry, unless xError contains an error. */
+ }
+ else
+#endif /* ffconfigFAT12_SUPPORT */
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ /* Handle FAT16, FAT32, and FAT12 (in case the entry lies on a single sector). */
+
+ pxBuffer = prvGetFromFATBuffers( pxIOManager, pxFATBuffers, 0, ulFATSector, &xError, ucMode );
+ if( FF_isERR( xError ) )
+ {
+ xError = FF_GETERROR( xError ) | FF_GETFATENTRY;
+ }
+ else
+ {
+ switch( pxIOManager->xPartition.ucType )
+ {
+ case FF_T_FAT32:
+ ulFATEntry = FF_getLong( pxBuffer->pucBuffer, ulRelClusterEntry );
+ /* Clear the top 4 bits. */
+ ulFATEntry &= 0x0fffffff;
+ break;
+ case FF_T_FAT16:
+ ulFATEntry = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, ulRelClusterEntry );
+ break;
+ #if( ffconfigFAT12_SUPPORT != 0 )
+ case FF_T_FAT12:
+ ulFATEntry = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, ulRelClusterEntry );
+ /* Entries are either stored as 4 + 8 bits or as 8 + 4 bits,
+ depending on the cluster being odd or even. */
+ if( ( ulCluster & 0x0001 ) != 0 )
+ {
+ /* For odd clusters, shift the address 4 bits to the right: */
+ ulFATEntry = ( ulFATEntry & 0xfff0 ) >> 4;
+ }
+ else
+ {
+ /* For even clusters, take the lower 12 bits: */
+ ulFATEntry = ( ulFATEntry & 0x0fff );
+ }
+ break;
+ #endif
+ default:
+ ulFATEntry = 0;
+ break;
+ }
+
+ if( pxFATBuffers != NULL )
+ {
+ /* Store the buffer. */
+ pxFATBuffers->pxBuffers[ 0 ] = pxBuffer;
+ }
+ else
+ {
+ /* Or release it. */
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ }
+ } /* if( FF_isERR( xError ) == pdFALSE ) */
+ } /* else Handle FAT16, FAT32, and FAT12 (in case the entry lies on a single sector). */
+
+ if( FF_isERR( xError ) )
+ {
+ /* The sector address 0 is not meaningful and here it is used as the 'error value'. */
+ ulFATEntry = 0UL;
+ }
+
+ if( pxError != NULL )
+ {
+ *pxError = xError;
+ }
+
+ return ( int32_t )ulFATEntry;
+} /* FF_getFATEntry() */
+/*-----------------------------------------------------------*/
+
+/* Write all zero's to all sectors of a given cluster. */
+FF_Error_t FF_ClearCluster( FF_IOManager_t *pxIOManager, uint32_t ulCluster )
+{
+FF_Error_t xError = FF_ERR_NONE;
+FF_Buffer_t *pxBuffer = NULL;
+BaseType_t xIndex;
+uint32_t ulBaseLBA;
+
+ /* Calculate from cluster number to a real block address. */
+ ulBaseLBA = FF_Cluster2LBA( pxIOManager, ulCluster );
+ ulBaseLBA = FF_getRealLBA( pxIOManager, ulBaseLBA );
+
+ for( xIndex = 0; xIndex < ( BaseType_t ) pxIOManager->xPartition.ulSectorsPerCluster; xIndex++ )
+ {
+ if( xIndex == 0 )
+ {
+ /* When using the FF_MODE_WR_ONLY flag, the data will not be read from disk.
+ Only in the first round a buffer will be claimed. */
+ pxBuffer = FF_GetBuffer( pxIOManager, ulBaseLBA, FF_MODE_WR_ONLY );
+ if( pxBuffer == NULL )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_CLEARCLUSTER );
+ break;
+ }
+ memset( pxBuffer->pucBuffer, 0x00, pxIOManager->usSectorSize );
+ }
+
+ xError = FF_BlockWrite( pxIOManager, ulBaseLBA + xIndex, 1, pxBuffer->pucBuffer, pdFALSE );
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+ }
+
+ if( pxBuffer != NULL )
+ {
+ FF_Error_t xTempError;
+
+ /* The contents of the buffer (all zero's) has been written explicitly to disk
+ by calling FF_BlockWrite(). Therefore, the bModified should be cleared. */
+ pxBuffer->bModified = pdFALSE;
+ /* Releasing the handle will not write anything */
+ xTempError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ xError = xTempError;
+ }
+ }
+
+ return xError;
+}
+/*-----------------------------------------------------------*/
+
+/**
+ * @private
+ * @brief Returns the Cluster address of the Cluster number from the beginning of a chain.
+ *
+ * @param pxIOManager FF_IOManager_t Object
+ * @param ulStart Cluster address of the first cluster in the chain.
+ * @param ulCount Number of Cluster in the chain,
+ *
+ *
+ *
+ **/
+uint32_t FF_TraverseFAT( FF_IOManager_t *pxIOManager, uint32_t ulStart, uint32_t ulCount, FF_Error_t *pxError )
+{
+FF_Error_t xError = FF_ERR_NONE;
+uint32_t ulIndex;
+uint32_t ulFatEntry = ulStart;
+uint32_t ulCurrentCluster = ulStart;
+FF_FATBuffers_t xFATBuffers;
+BaseType_t xTakeLock = FF_Has_Lock( pxIOManager, FF_FAT_LOCK ) == pdFALSE;
+
+ /* xFATBuffers is nothing more than an array of FF_Buffer_t's.
+ One buffer for each FAT copy on disk. */
+ FF_InitFATBuffers( &xFATBuffers, FF_MODE_READ );
+
+ if( xTakeLock )
+ {
+ FF_LockFAT( pxIOManager );
+ }
+ for( ulIndex = 0; ulIndex < ulCount; ulIndex++ )
+ {
+ ulFatEntry = FF_getFATEntry( pxIOManager, ulCurrentCluster, &xError, &xFATBuffers );
+ if( FF_isERR( xError ) )
+ {
+ ulFatEntry = 0;
+ break;
+ }
+
+ if( FF_isEndOfChain( pxIOManager, ulFatEntry ) )
+ {
+ ulFatEntry = ulCurrentCluster;
+ break;
+ }
+
+ ulCurrentCluster = ulFatEntry;
+ }
+ if( xTakeLock )
+ {
+ FF_UnlockFAT( pxIOManager );
+ }
+
+ {
+ FF_Error_t xTempError;
+
+ xTempError = FF_ReleaseFATBuffers( pxIOManager, &xFATBuffers );
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ xError = xTempError;
+ }
+ }
+
+ *pxError = xError;
+
+ return ulFatEntry;
+}
+/*-----------------------------------------------------------*/
+
+uint32_t FF_FindEndOfChain( FF_IOManager_t *pxIOManager, uint32_t ulStart, FF_Error_t *pxError )
+{
+uint32_t ulFatEntry = ulStart;
+FF_Error_t xError;
+
+ if( FF_isEndOfChain( pxIOManager, ulStart ) == pdFALSE )
+ {
+ /* Traverse FAT for (2^32-1) items/clusters,
+ or until end-of-chain is encountered. */
+ ulFatEntry = FF_TraverseFAT( pxIOManager, ulStart, ~0UL, &xError );
+ }
+ else
+ {
+ xError = FF_ERR_NONE;
+ }
+
+ *pxError = xError;
+
+ return ulFatEntry;
+}
+/*-----------------------------------------------------------*/
+
+/**
+ * @private
+ * @brief Tests if the ulFATEntry is an End of Chain Marker.
+ *
+ * @param pxIOManager FF_IOManager_t Object
+ * @param ulFATEntry The fat entry from the FAT table to be checked.
+ *
+ * @return pdTRUE if it is an end of chain, otherwise pdFALSE.
+ *
+ **/
+BaseType_t FF_isEndOfChain( FF_IOManager_t *pxIOManager, uint32_t ulFATEntry )
+{
+BaseType_t xResult = pdFALSE;
+
+ if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
+ {
+ if( ( ulFATEntry & 0x0fffffff ) >= 0x0ffffff8 )
+ {
+ xResult = pdTRUE;
+ }
+ }
+ else if( pxIOManager->xPartition.ucType == FF_T_FAT16 )
+ {
+ if( ulFATEntry >= 0x0000fff8 )
+ {
+ xResult = pdTRUE;
+ }
+ }
+ else
+ {
+ if( ulFATEntry >= 0x00000ff8 )
+ {
+ xResult = pdTRUE;
+ }
+ }
+
+ if( ulFATEntry == 0x00000000 )
+ {
+ xResult = pdTRUE; /* Perhaps trying to read a deleted file! */
+ }
+
+ return xResult;
+}
+/*-----------------------------------------------------------*/
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ static FF_Error_t prvPutFAT12Entry( FF_IOManager_t *pxIOManager, uint32_t ulCluster, uint32_t ulValue, FF_FATBuffers_t *pxFATBuffers,
+ uint32_t ulFATSector )
+ {
+ FF_Buffer_t *pxBuffer = NULL;
+ /* For FAT12 FAT Table Across sector boundary traversal. */
+ uint8_t ucBytes[ 2 ];
+ /* The function result value. */
+ uint32_t ulFATEntry;
+ FF_Error_t xError = FF_ERR_NONE;
+ BaseType_t xIndex;
+ #if( ffconfigWRITE_BOTH_FATS != 0 )
+ const BaseType_t xNumFATs = pxIOManager->xPartition.ucNumFATS;
+ #else
+ const BaseType_t xNumFATs = 1;
+ #endif
+
+ /* This routine will only change 12 out of 16 bits.
+ Get the current 16-bit value, 4 bits shall be preserved. */
+ ulFATEntry = prvGetFAT12Entry( pxIOManager, &xError, pxFATBuffers, ulFATSector );
+
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ if( ( ulCluster & 0x0001 ) != 0 )
+ {
+ ulFATEntry &= 0x000F;
+ ulValue = ( ulValue << 4 );
+ ulValue &= 0xFFF0;
+ }
+ else
+ {
+ ulFATEntry &= 0xF000;
+ ulValue &= 0x0FFF;
+ }
+ ulFATEntry |= ulValue;
+
+ /* Write at offset 0 in the array ucBytes. */
+ FF_putShort( ucBytes, 0, ( uint16_t ) ulFATEntry );
+
+ for( xIndex = 0;
+ xIndex < xNumFATs;
+ xIndex++, ulFATSector += pxIOManager->xPartition.ulSectorsPerFAT )
+ {
+ /* Write the last byte in the first sector. */
+ pxBuffer = FF_GetBuffer( pxIOManager, ulFATSector, FF_MODE_WRITE );
+ {
+ if( pxBuffer == NULL )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_PUTFATENTRY );
+ break;
+ }
+ FF_putChar( pxBuffer->pucBuffer, ( uint16_t )( pxIOManager->usSectorSize - 1 ), ucBytes[ 0 ] );
+ }
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+
+ /* Write the first byte in the subsequent sector. */
+ pxBuffer = FF_GetBuffer( pxIOManager, ulFATSector + 1, FF_MODE_WRITE );
+ {
+ if( pxBuffer == NULL )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_PUTFATENTRY );
+ break;
+ }
+ FF_putChar( pxBuffer->pucBuffer, 0x0000, ucBytes[ 1 ] );
+ }
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+ } /* for ( xIndex = 0; xIndex < xNumFATs; xIndex++ ) */
+ }
+
+ return xError;
+ }
+#endif
+
+/**
+ * @private
+ * @brief Writes a new Entry to the FAT Tables.
+ *
+ * @param pxIOManager IOMAN object.
+ * @param ulCluster Cluster Number to be modified.
+ * @param ulValue The value to store.
+ **/
+FF_Error_t FF_putFATEntry( FF_IOManager_t *pxIOManager, uint32_t ulCluster, uint32_t ulValue, FF_FATBuffers_t *pxFATBuffers )
+{
+FF_Buffer_t *pxBuffer;
+uint32_t ulFATOffset;
+uint32_t ulFATSector = 0;
+uint32_t ulFATSectorEntry;
+uint32_t ulFATEntry;
+uint32_t ulLBAAdjust;
+uint32_t ulRelClusterEntry = 0;
+BaseType_t xIndex;
+FF_Error_t xError = FF_ERR_NONE;
+#if( ffconfigWRITE_BOTH_FATS != 0 )
+ const BaseType_t xNumFATs = pxIOManager->xPartition.ucNumFATS;
+#else
+ const BaseType_t xNumFATs = 1;
+#endif
+
+
+ FF_Assert_Lock( pxIOManager, FF_FAT_LOCK );
+
+ /* Avoid corrupting the disk. */
+ if( ( ulCluster == 0ul ) || ( ulCluster >= pxIOManager->xPartition.ulNumClusters ) )
+ {
+ /* find a more specific error code. */
+ xError = ( FF_Error_t ) ( FF_ERR_IOMAN_NOT_ENOUGH_FREE_SPACE | FF_PUTFATENTRY );
+ }
+ else
+ {
+ if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
+ {
+ ulFATOffset = ulCluster * 4;
+ }
+ else if( pxIOManager->xPartition.ucType == FF_T_FAT16 )
+ {
+ ulFATOffset = ulCluster * 2;
+ }
+ else /* pxIOManager->xPartition.ucType == FF_T_FAT12 */
+ {
+ ulFATOffset = ulCluster + ( ulCluster / 2 );
+ }
+
+ ulFATSector = pxIOManager->xPartition.ulFATBeginLBA + ( ulFATOffset / pxIOManager->xPartition.usBlkSize );
+ ulFATSectorEntry = ulFATOffset % pxIOManager->xPartition.usBlkSize;
+
+ ulLBAAdjust = ulFATSectorEntry / ( ( uint32_t ) pxIOManager->usSectorSize );
+ ulRelClusterEntry = ulFATSectorEntry % pxIOManager->usSectorSize;
+
+ ulFATSector = FF_getRealLBA( pxIOManager, ulFATSector );
+ ulFATSector += ulLBAAdjust;
+ }
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ if( ( pxIOManager->xPartition.ucType == FF_T_FAT12 ) &&
+ ( FF_isERR( xError ) == pdFALSE ) &&
+ ( ulRelClusterEntry == ( uint32_t ) ( ( pxIOManager->usSectorSize - 1 ) ) ) )
+ {
+ /* The special case in which one FAT12 entries is divided over 2 sectors.
+ Treat this in a separate function. */
+ xError = prvPutFAT12Entry( pxIOManager, ulCluster, ulValue, pxFATBuffers, ulFATSector );
+ /* Return xError. */
+ }
+ else
+#endif /* ffconfigFAT12_SUPPORT */
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ /* Handle FAT16, FAT32, and FAT12 (in case the entry lies on a single sector). */
+ for( xIndex = 0;
+ xIndex < xNumFATs;
+ xIndex++, ulFATSector += pxIOManager->xPartition.ulSectorsPerFAT )
+ {
+ pxBuffer = prvGetFromFATBuffers( pxIOManager, pxFATBuffers, xIndex, ulFATSector, &xError, FF_MODE_WRITE );
+
+ if( FF_isERR( xError ) )
+ {
+ xError = FF_GETERROR( xError ) | FF_PUTFATENTRY;
+ break;
+ }
+
+ if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
+ {
+ /* Clear the top 4 bits. */
+ ulValue &= 0x0fffffff;
+ FF_putLong( pxBuffer->pucBuffer, ulRelClusterEntry, ulValue );
+ }
+ else if( pxIOManager->xPartition.ucType == FF_T_FAT16 )
+ {
+ FF_putShort( pxBuffer->pucBuffer, ulRelClusterEntry, ( uint16_t ) ulValue );
+ }
+ else
+ {
+ ulFATEntry = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, ulRelClusterEntry );
+ if( ( ulCluster & 0x0001 ) != 0 )
+ {
+ ulFATEntry &= 0x000F;
+ ulValue = ( ulValue << 4 );
+ ulValue &= 0xFFF0;
+ }
+ else
+ {
+ ulFATEntry &= 0xF000;
+ ulValue &= 0x0FFF;
+ }
+
+ FF_putShort( pxBuffer->pucBuffer, ulRelClusterEntry, ( uint16_t ) ( ulFATEntry | ulValue ) );
+ }
+
+ if( ( xIndex < ffconfigBUF_STORE_COUNT ) && ( pxFATBuffers != NULL ) )
+ {
+ /* Store it for later use. */
+ pxFATBuffers->pxBuffers[ xIndex ] = pxBuffer;
+ pxFATBuffers->ucMode = FF_MODE_WRITE;
+ }
+ else
+ {
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+ }
+ }
+ }
+
+ /* FF_putFATEntry() returns just an error code, not an address. */
+ return xError;
+} /* FF_putFATEntry() */
+/*-----------------------------------------------------------*/
+
+/**
+ * @private
+ * @brief Finds a Free Cluster and returns its number.
+ *
+ * @param pxIOManager IOMAN Object.
+ *
+ * @return The number of the cluster found to be free.
+ * @return 0 on error.
+ **/
+#if( ffconfigFAT12_SUPPORT != 0 )
+ static uint32_t prvFindFreeClusterSimple( FF_IOManager_t *pxIOManager, FF_Error_t *pxError )
+ {
+ FF_Error_t xError = FF_ERR_NONE;
+ uint32_t ulCluster = 0;
+ uint32_t ulFATEntry;
+ FF_FATBuffers_t xFATBuffers;
+
+ FF_InitFATBuffers( &xFATBuffers, FF_MODE_READ );
+
+ for( ulCluster = pxIOManager->xPartition.ulLastFreeCluster;
+ ulCluster < pxIOManager->xPartition.ulNumClusters;
+ ulCluster++ )
+ {
+ ulFATEntry = FF_getFATEntry( pxIOManager, ulCluster, &xError, &xFATBuffers );
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+ if( ulFATEntry == 0 )
+ {
+ pxIOManager->xPartition.ulLastFreeCluster = ulCluster;
+ break;
+
+ }
+ }
+ {
+ FF_Error_t xTempError;
+
+ xTempError = FF_ReleaseFATBuffers( pxIOManager, &xFATBuffers );
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ xError = xTempError;
+ }
+ }
+ if( ( FF_isERR( xError ) == pdFALSE ) &&
+ ( ulCluster == pxIOManager->xPartition.ulNumClusters ) )
+ {
+ /* There is no free cluster any more. */
+ ulCluster = 0;
+ xError = FF_FINDFREECLUSTER | FF_ERR_IOMAN_NOT_ENOUGH_FREE_SPACE;
+ }
+
+ *pxError = xError;
+
+ return ulCluster;
+ }
+#endif
+/*-----------------------------------------------------------*/
+
+uint32_t FF_FindFreeCluster( FF_IOManager_t *pxIOManager, FF_Error_t *pxError, BaseType_t xDoClaim )
+{
+FF_Error_t xError = FF_ERR_NONE;
+FF_Buffer_t *pxBuffer = NULL;
+uint32_t x, ulCluster;
+uint32_t ulFATSectorEntry;
+uint32_t ulEntriesPerSector;
+uint32_t ulFATEntry = 1;
+const BaseType_t xEntrySize = ( pxIOManager->xPartition.ucType == FF_T_FAT32 ) ? 4 : 2;
+const uint32_t uNumClusters = pxIOManager->xPartition.ulNumClusters;
+
+BaseType_t xTakeLock = FF_Has_Lock( pxIOManager, FF_FAT_LOCK ) == pdFALSE;
+
+ if( xTakeLock )
+ {
+ FF_LockFAT( pxIOManager );
+ }
+
+ ulCluster = pxIOManager->xPartition.ulLastFreeCluster;
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ /* FAT12 tables are too small to optimise, and would make it very complicated! */
+ if( pxIOManager->xPartition.ucType == FF_T_FAT12 )
+ {
+ ulCluster = prvFindFreeClusterSimple( pxIOManager, &xError );
+ }
+ else
+#endif
+ {
+ #if( ffconfigFSINFO_TRUSTED != 0 )
+ {
+ /* If 'ffconfigFSINFO_TRUSTED', the contents of the field 'ulLastFreeCluster' is trusted.
+ Only ready it in case of FAT32 and only during the very first time, i.e. when
+ ulLastFreeCluster is still zero. */
+ if( ( pxIOManager->xPartition.ucType == FF_T_FAT32 ) && ( pxIOManager->xPartition.ulLastFreeCluster == 0ul ) )
+ {
+ pxBuffer = FF_GetBuffer( pxIOManager, pxIOManager->xPartition.ulFSInfoLBA, FF_MODE_READ );
+ if( pxBuffer == NULL )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_FINDFREECLUSTER );
+ }
+ else
+ {
+ if( ( FF_getLong(pxBuffer->pucBuffer, 0 ) == 0x41615252 ) &&
+ ( FF_getLong(pxBuffer->pucBuffer, 484 ) == 0x61417272 ) )
+ {
+ ulCluster = FF_getLong( pxBuffer->pucBuffer, 492 );
+ }
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ pxBuffer = NULL;
+ }
+
+ }
+ }
+ #endif
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ uint32_t ulFATSector;
+ uint32_t ulFATOffset;
+
+ ulEntriesPerSector = pxIOManager->usSectorSize / xEntrySize;
+ ulFATOffset = ulCluster * xEntrySize;
+
+ /* Start from a sector where the first free entry is expected,
+ and iterate through every FAT sector. */
+ for( ulFATSector = ( ulFATOffset / pxIOManager->xPartition.usBlkSize );
+ ulFATSector < pxIOManager->xPartition.ulSectorsPerFAT;
+ ulFATSector++ )
+ {
+ pxBuffer = FF_GetBuffer( pxIOManager, pxIOManager->xPartition.ulFATBeginLBA + ulFATSector, FF_MODE_READ );
+ if( pxBuffer == NULL )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_FINDFREECLUSTER );
+ break;
+ }
+ for( x = ( ulCluster % ulEntriesPerSector ); x < ulEntriesPerSector; x++ )
+ {
+ /* Double-check: don't use non-existing clusters */
+ if( ulCluster >= uNumClusters )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_IOMAN_NOT_ENOUGH_FREE_SPACE | FF_FINDFREECLUSTER );
+ break;
+ }
+ ulFATSectorEntry = ulFATOffset % pxIOManager->xPartition.usBlkSize;
+ if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
+ {
+ ulFATEntry = FF_getLong( pxBuffer->pucBuffer, ulFATSectorEntry );
+ /* Clear the top 4 bits. */
+ ulFATEntry &= 0x0fffffff;
+ }
+ else
+ {
+ ulFATEntry = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, ulFATSectorEntry );
+ }
+ if( ulFATEntry == 0x00000000 )
+ {
+ /* Break and return 'ulCluster' */
+ break;
+ }
+ ulFATOffset += xEntrySize;
+ ulCluster++;
+ }
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ pxBuffer = NULL;
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+ if( ulFATEntry == 0x00000000 )
+ {
+ /* And break from the outer loop. */
+ break;
+ }
+ }
+ if( ( FF_isERR( xError ) == pdFALSE ) &&
+ ( ulFATSector == pxIOManager->xPartition.ulSectorsPerFAT ) )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_IOMAN_NOT_ENOUGH_FREE_SPACE | FF_FINDFREECLUSTER );
+ }
+ } /* if( FF_isERR( xError ) == pdFALSE ) */
+ } /* if( pxIOManager->xPartition.ucType != FF_T_FAT12 ) */
+
+ if( FF_isERR( xError ) )
+ {
+ ulCluster = 0UL;
+ }
+ if( ( ulCluster != 0UL ) && ( xDoClaim != pdFALSE ) )
+ {
+ FF_Error_t xTempError;
+
+ /* Found a free cluster! */
+ pxIOManager->xPartition.ulLastFreeCluster = ulCluster + 1;
+
+ xTempError = FF_putFATEntry( pxIOManager, ulCluster, 0xFFFFFFFF, NULL );
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ xError = xTempError;
+ }
+
+ if( FF_isERR( xError ) )
+ {
+ ulCluster = 0UL;
+ }
+ }
+ if( xTakeLock )
+ {
+ FF_UnlockFAT( pxIOManager );
+ }
+ *pxError = xError;
+
+ return ulCluster;
+} /* FF_FindFreeCluster */
+/*-----------------------------------------------------------*/
+
+/**
+ * @private
+ * @brief Creates a Cluster Chain
+ * @return > 0 New created cluster
+ * @return = 0 See pxError
+ **/
+uint32_t FF_CreateClusterChain( FF_IOManager_t *pxIOManager, FF_Error_t *pxError )
+{
+uint32_t ulStartCluster;
+FF_Error_t xError = FF_ERR_NONE;
+
+ FF_LockFAT( pxIOManager );
+ {
+ ulStartCluster = FF_FindFreeCluster( pxIOManager, &xError, pdTRUE );
+ }
+ FF_UnlockFAT( pxIOManager );
+
+ if( ulStartCluster != 0L )
+ {
+ xError = FF_DecreaseFreeClusters( pxIOManager, 1 );
+ }
+ *pxError = xError;
+
+ return ulStartCluster;
+}
+/*-----------------------------------------------------------*/
+
+uint32_t FF_GetChainLength( FF_IOManager_t *pxIOManager, uint32_t ulStartCluster, uint32_t *pulEndOfChain, FF_Error_t *pxError )
+{
+uint32_t ulLength = 0;
+FF_FATBuffers_t xFATBuffers;
+FF_Error_t xError = FF_ERR_NONE;
+
+ FF_InitFATBuffers( &xFATBuffers, FF_MODE_READ );
+
+ FF_LockFAT( pxIOManager );
+ {
+ while( FF_isEndOfChain( pxIOManager, ulStartCluster ) == pdFALSE )
+ {
+ ulStartCluster = FF_getFATEntry( pxIOManager, ulStartCluster, &xError, &xFATBuffers );
+ if( FF_isERR( xError ) )
+ {
+ ulLength = 0;
+ break;
+ }
+ ulLength++;
+ }
+ if( pulEndOfChain != NULL )
+ {
+ /* _HT_
+ ulStartCluster has just been tested as an end-of-chain token.
+ Not sure if the caller expects this. */
+ *pulEndOfChain = ulStartCluster;
+ }
+ xError = FF_ReleaseFATBuffers( pxIOManager, &xFATBuffers );
+ }
+ FF_UnlockFAT( pxIOManager );
+
+ *pxError = xError;
+
+ return ulLength;
+}
+/*-----------------------------------------------------------*/
+
+/**
+ * @private
+ * @brief Free's Disk space by freeing unused links on Cluster Chains
+ *
+ * @param pxIOManager, IOMAN object.
+ * @param ulStartCluster Cluster Number that starts the chain.
+ * @param ulCount Number of Clusters from the end of the chain to unlink.
+ * @param ulCount 0 Means Free the entire chain (delete file).
+ * @param ulCount 1 Means mark the start cluster with EOF.
+ *
+ * @return 0 On Success.
+ * @return -1 If the device driver failed to provide access.
+ *
+ **/
+FF_Error_t FF_UnlinkClusterChain( FF_IOManager_t *pxIOManager, uint32_t ulStartCluster, BaseType_t xDoTruncate )
+{
+uint32_t ulFATEntry;
+uint32_t ulCurrentCluster;
+uint32_t ulLength = 0;
+uint32_t ulLastFree = ulStartCluster;
+FF_Error_t xTempError;
+FF_Error_t xError = FF_ERR_NONE;
+FF_FATBuffers_t xFATBuffers;
+
+BaseType_t xTakeLock = FF_Has_Lock( pxIOManager, FF_FAT_LOCK ) == pdFALSE;
+
+ if( xTakeLock )
+ {
+ FF_LockFAT( pxIOManager );
+ }
+
+ FF_InitFATBuffers( &xFATBuffers, FF_MODE_WRITE );
+
+ ulFATEntry = ulStartCluster;
+
+ /* Free all clusters in the chain! */
+ ulCurrentCluster = ulStartCluster;
+ ulFATEntry = ulCurrentCluster;
+ do
+ {
+ /* Sector will now be fetched in write-mode. */
+ ulFATEntry = FF_getFATEntry( pxIOManager, ulFATEntry, &xError, &xFATBuffers );
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+
+ if( ( xDoTruncate != pdFALSE ) && ( ulCurrentCluster == ulStartCluster ) )
+ {
+ xError = FF_putFATEntry( pxIOManager, ulCurrentCluster, 0xFFFFFFFF, &xFATBuffers );
+ }
+ else
+ {
+ xError = FF_putFATEntry( pxIOManager, ulCurrentCluster, 0x00000000, &xFATBuffers );
+ ulLength++;
+ }
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+
+ if( ulLastFree > ulCurrentCluster )
+ {
+ ulLastFree = ulCurrentCluster;
+ }
+ ulCurrentCluster = ulFATEntry;
+ } while( FF_isEndOfChain( pxIOManager, ulFATEntry ) == pdFALSE );
+
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ if( pxIOManager->xPartition.ulLastFreeCluster > ulLastFree )
+ {
+ pxIOManager->xPartition.ulLastFreeCluster = ulLastFree;
+ }
+ }
+
+ xTempError = FF_ReleaseFATBuffers( pxIOManager, &xFATBuffers );
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ xError = xTempError;
+ }
+
+ if( xTakeLock )
+ {
+ FF_UnlockFAT( pxIOManager );
+ }
+ if( ulLength != 0 )
+ {
+ xTempError = FF_IncreaseFreeClusters( pxIOManager, ulLength );
+ if( FF_isERR( xError ) == pdFALSE )
+ {
+ xError = xTempError;
+ }
+ }
+
+ return xError;
+}
+/*-----------------------------------------------------------*/
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ static uint32_t prvCountFreeClustersSimple( FF_IOManager_t *pxIOManager, FF_Error_t *pxError )
+ {
+ FF_Error_t xError = FF_ERR_NONE;
+ uint32_t ulIndex;
+ uint32_t ulFATEntry;
+ uint32_t ulFreeClusters = 0;
+ const uint32_t xTotalClusters =
+ pxIOManager->xPartition.ulDataSectors / pxIOManager->xPartition.ulSectorsPerCluster;
+
+ for( ulIndex = 0; ulIndex < xTotalClusters; ulIndex++ )
+ {
+ ulFATEntry = FF_getFATEntry( pxIOManager, ulIndex, &xError, NULL );
+ if( FF_isERR( xError) )
+ {
+ break;
+ }
+ if( ulFATEntry == 0UL )
+ {
+ ulFreeClusters++;
+ }
+ }
+
+ *pxError = xError;
+
+ return ulFreeClusters;
+ }
+#endif
+/*-----------------------------------------------------------*/
+
+
+uint32_t FF_CountFreeClusters( FF_IOManager_t *pxIOManager, FF_Error_t *pxError )
+{
+FF_Error_t xError = FF_ERR_NONE;
+FF_Buffer_t *pxBuffer;
+uint32_t ulIndex, x;
+uint32_t ulFATEntry;
+uint32_t ulEntriesPerSector;
+uint32_t ulFreeClusters = 0;
+uint32_t ClusterNum = 0;
+BaseType_t xInfoKnown = pdFALSE;
+BaseType_t xTakeLock = FF_Has_Lock( pxIOManager, FF_FAT_LOCK ) == pdFALSE;
+
+ if( xTakeLock )
+ {
+ FF_LockFAT( pxIOManager );
+ }
+
+#if( ffconfigFAT12_SUPPORT != 0 )
+ /* FAT12 tables are too small to optimise, and would make it very complicated! */
+ if( pxIOManager->xPartition.ucType == FF_T_FAT12 )
+ {
+ ulFreeClusters = prvCountFreeClustersSimple( pxIOManager, &xError );
+ }
+ else
+#endif
+ {
+ /* For FAT16 and FAT32 */
+ #if( ffconfigFSINFO_TRUSTED != 0 )
+ {
+ /* If 'ffconfigFSINFO_TRUSTED', the contents of the field 'ulFreeClusterCount' is trusted. */
+ if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
+ {
+ pxBuffer = FF_GetBuffer( pxIOManager, pxIOManager->xPartition.ulFSInfoLBA, FF_MODE_READ );
+ if( pxBuffer == NULL )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_COUNTFREECLUSTERS );
+ }
+ else
+ {
+ if( ( FF_getLong( pxBuffer->pucBuffer, 0 ) == 0x41615252 ) &&
+ ( FF_getLong( pxBuffer->pucBuffer, 484 ) == 0x61417272 ) )
+ {
+ ulFreeClusters = FF_getLong( pxBuffer->pucBuffer, 488 );
+
+ if( ulFreeClusters != ~0ul )
+ {
+ xInfoKnown = pdTRUE;
+ }
+ else
+ {
+ ulFreeClusters = 0ul;
+ }
+ }
+
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ pxBuffer = NULL;
+
+ if( xInfoKnown != pdFALSE )
+ {
+ pxIOManager->xPartition.ulFreeClusterCount = ulFreeClusters;
+ }
+ }
+ }
+ }
+ #endif
+ if( ( xInfoKnown == pdFALSE ) && ( pxIOManager->xPartition.usBlkSize != 0 ) )
+ {
+ if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
+ {
+ ulEntriesPerSector = pxIOManager->usSectorSize / 4;
+ }
+ else
+ {
+ ulEntriesPerSector = pxIOManager->usSectorSize / 2;
+ }
+ for( ulIndex = 0; ulIndex < pxIOManager->xPartition.ulSectorsPerFAT; ulIndex++ )
+ {
+ pxBuffer = FF_GetBuffer( pxIOManager, pxIOManager->xPartition.ulFATBeginLBA + ulIndex, FF_MODE_READ );
+
+ if( pxBuffer == NULL )
+ {
+ xError = ( FF_Error_t ) ( FF_ERR_DEVICE_DRIVER_FAILED | FF_COUNTFREECLUSTERS );
+ break;
+ }
+ #if USE_SOFT_WDT
+ {
+ /* _HT_ : FF_CountFreeClusters was a little too busy, have it call the WDT and sleep */
+ clearWDT( );
+ if( ( ( ulIndex + 1 ) % 32 ) == 0 )
+ {
+ FF_Sleep( 1 );
+ }
+ }
+ #endif
+ for( x = 0; x < ulEntriesPerSector; x++ )
+ {
+ if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
+ {
+ /* Clearing the top 4 bits. */
+ ulFATEntry = FF_getLong( pxBuffer->pucBuffer, x * 4 ) & 0x0fffffff;
+ }
+ else
+ {
+ ulFATEntry = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, x * 2 );
+ }
+ if( ulFATEntry == 0ul )
+ {
+ ulFreeClusters++;
+ }
+ /* FAT table might not be cluster aligned. */
+ if( ClusterNum > pxIOManager->xPartition.ulNumClusters )
+ {
+ /* Stop counting if that's the case. */
+ break;
+ }
+ ClusterNum++;
+ }
+
+ xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
+ pxBuffer = NULL;
+ if( FF_isERR( xError ) )
+ {
+ break;
+ }
+ if( ClusterNum > pxIOManager->xPartition.ulNumClusters )
+ {
+ /* Break out of 2nd loop too ^^ */
+ break;
+ }
+ /* ulFreeClusters is -2 because the first 2 fat entries in the table are reserved. */
+ if( ulFreeClusters > pxIOManager->xPartition.ulNumClusters )
+ {
+ ulFreeClusters = pxIOManager->xPartition.ulNumClusters;
+ }
+ } /* for( ulIndex = 0; ulIndex < pxIOManager->xPartition.ulSectorsPerFAT; ulIndex++ ) */
+ }
+ }
+
+ if( xTakeLock )
+ {
+ FF_UnlockFAT( pxIOManager );
+ }
+
+ if( FF_isERR( xError ) )
+ {
+ ulFreeClusters = 0;
+ }
+ *pxError = xError;
+
+ return ulFreeClusters;
+}
+/*-----------------------------------------------------------*/
+
+#if( ffconfig64_NUM_SUPPORT != 0 )
+ uint64_t FF_GetFreeSize( FF_IOManager_t *pxIOManager, FF_Error_t *pxError )
+ {
+ FF_Error_t xError = FF_ERR_NONE;
+ uint32_t ulFreeClusters;
+ uint64_t ulFreeSize = 0;
+
+ if( pxIOManager != NULL )
+ {
+ if( pxIOManager->xPartition.ulFreeClusterCount == 0ul )
+ {
+ FF_LockFAT( pxIOManager );
+ {
+ pxIOManager->xPartition.ulFreeClusterCount = FF_CountFreeClusters( pxIOManager, &xError );
+ }
+ FF_UnlockFAT( pxIOManager );
+ }
+ ulFreeClusters = pxIOManager->xPartition.ulFreeClusterCount;
+ ulFreeSize = ( uint64_t )
+ ( ( uint64_t ) ulFreeClusters * ( uint64_t )
+ ( ( uint64_t ) pxIOManager->xPartition.ulSectorsPerCluster *
+ ( uint64_t ) pxIOManager->xPartition.usBlkSize ) );
+ }
+ if( pxError != NULL )
+ {
+ *pxError = xError;
+ }
+
+ return ulFreeSize;
+ }
+#else
+ uint32_t FF_GetFreeSize( FF_IOManager_t *pxIOManager, FF_Error_t *pxError )
+ {
+ FF_Error_t xError = FF_ERR_NONE;
+ uint32_t ulFreeClusters;
+ uint32_t ulFreeSize = 0;
+
+ if( pxIOManager != NULL )
+ {
+ if( pxIOManager->xPartition.ulFreeClusterCount == 0ul )
+ {
+ FF_LockFAT( pxIOManager );
+ {
+ pxIOManager->xPartition.ulFreeClusterCount = FF_CountFreeClusters( pxIOManager, &xError );
+ }
+ FF_UnlockFAT( pxIOManager );
+ }
+ ulFreeClusters = pxIOManager->xPartition.ulFreeClusterCount;
+ ulFreeSize = ( uint32_t )
+ ( ( uint32_t ) ulFreeClusters * ( uint32_t )
+ ( ( uint32_t ) pxIOManager->xPartition.ulSectorsPerCluster *
+ ( uint32_t ) pxIOManager->xPartition.usBlkSize ) );
+ }
+
+ if( pxError != NULL )
+ {
+ *pxError = xError;
+ }
+
+ return ulFreeSize;
+ }
+#endif /* ffconfig64_NUM_SUPPORT */
+/*-----------------------------------------------------------*/
+
|