Google Git
Sign in
pigweed / third_party / github / FreeRTOS / FreeRTOS-Kernel / 9c0c37ab9b56f2c90085b78df2f58b5833e473db / . / FreeRTOS-Labs / Source / FreeRTOS-Plus-FAT / ff_ioman.c
blob: 094bc07bf3f5ea4fda780049be1bd827e91974bd [file] [log] [blame]
/*
* 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_ioman.c
* @ingroup IOMAN
*
* @defgroup IOMAN I/O Manager
* @brief Handles IO buffers for FreeRTOS+FAT safely.
*
* Provides a simple static interface to the rest of FreeRTOS+FAT to manage
* buffers. It also defines the public interfaces for Creating and
* Destroying a FreeRTOS+FAT IO object.
**/
#include <time.h>
#include <string.h>
#include "ff_headers.h"
#define FAT16_SECTOR_COUNT_4085 4085
#define FAT32_SECTOR_COUNT_65525 65525 /* 65536 clusters */
/* Some values and offsets describing the special sector FS INFO: */
#define FS_INFO_SIGNATURE1_0x41615252 0x41615252UL
#define FS_INFO_SIGNATURE2_0x61417272 0x61417272UL
#define FS_INFO_OFFSET_SIGNATURE1_000 0
#define FS_INFO_OFFSET_SIGNATURE2_484 484
#define FS_INFO_OFFSET_FREE_COUNT_488 488
#define FS_INFO_OFFSET_FREE_CLUSTER_492 492
/* Inspect the PBR (Partition Boot Record) to determine the type of FAT */
static FF_Error_t prvDetermineFatType( FF_IOManager_t *pxIOManager );
/* Check if a given ID introduces an extended partition. */
static BaseType_t prvIsExtendedPartition( uint8_t ucPartitionID );
/* Return pdTRUE if the media byte in an MBR is valid. */
static BaseType_t prvIsValidMedia( uint8_t media );
/* Read the MBR to see what extended partitions have been defined.
Definitions of extended partitions may be chained.
Walk down the chain to find all extended partitions. */
static FF_Error_t FF_ParseExtended( FF_IOManager_t *pxIOManager, uint32_t ulFirstSector, uint32_t ulFirstSize,
FF_SPartFound_t *pPartsFound );
static FF_Error_t FF_GetEfiPartitionEntry( FF_IOManager_t *pxIOManager, uint32_t ulPartitionNumber );
static BaseType_t prvHasActiveHandles( FF_IOManager_t *pxIOManager );
/**
* @public
* @brief Creates an FF_IOManager_t object, to initialise FreeRTOS+FAT
*
* @param pucCacheMem Pointer to a buffer for the cache. (NULL if ok to Malloc).
* @param ulCacheSize The size of the provided buffer, or size of the cache to be created.
* (Must be at least 2 * ulSectorSize). Always a multiple of ulSectorSize.
* @param usSectorSize The block size of devices to be attached. If in doubt use 512.
* @param pError Pointer to a signed byte for error checking. Can be NULL if not required.
* To be checked when a NULL pointer is returned.
*
* @Return Returns a pointer to an FF_IOManager_t type object. NULL on xError, check the contents of
* @Return pError
**/
FF_IOManager_t *FF_CreateIOManger( FF_CreationParameters_t *pxParameters, FF_Error_t *pError )
{
FF_IOManager_t *pxIOManager = NULL;
FF_Error_t xError;
uint32_t ulCacheSize = pxParameters->ulMemorySize;
uint32_t usSectorSize = pxParameters->ulSectorSize;
/* Normally:
ulSectorSize = 512
ulCacheSize = N x ulSectorSize. */
if( ( ( usSectorSize % 512 ) != 0 ) || ( usSectorSize == 0 ) )
{
/* ulSectorSize Size not a multiple of 512 or it is zero*/
xError = FF_ERR_IOMAN_BAD_BLKSIZE | FF_CREATEIOMAN;
}
else if( ( ( ulCacheSize % ( uint32_t ) usSectorSize ) != 0 ) || ( ulCacheSize == 0 ) ||
( ulCacheSize == ( uint32_t ) usSectorSize ) )
{
/* The size of the caching memory (ulCacheSize) must now be atleast 2 * ulSectorSize (or a deadlock will occur). */
xError = FF_ERR_IOMAN_BAD_MEMSIZE | FF_CREATEIOMAN;
}
else
{
pxIOManager = ( FF_IOManager_t * ) ffconfigMALLOC( sizeof( FF_IOManager_t ) );
/* Ensure malloc() succeeded. */
if( pxIOManager != NULL )
{
/* Use memset() to clear every single bit. */
memset( pxIOManager, '\0', sizeof( FF_IOManager_t ) );
if( FF_CreateEvents( pxIOManager ) != pdFALSE )
{
xError = FF_ERR_NONE;
}
else
{
/* xEventGroupCreate() probably failed. */
xError = FF_ERR_NOT_ENOUGH_MEMORY | FF_CREATEIOMAN;
}
}
else
{
/* ffconfigMALLOC() failed. */
xError = FF_ERR_NOT_ENOUGH_MEMORY | FF_CREATEIOMAN;
}
}
if( FF_isERR( xError ) == pdFALSE )
{
/* pxIOManager is created, FF_CreateEvents() succeeded. */
if( pxParameters->pucCacheMemory != NULL )
{
/* The caller has provided a piece of memory, use it. */
pxIOManager->pucCacheMem = pxParameters->pucCacheMemory;
}
else
{
/* No cache buffer provided, call malloc(). */
pxIOManager->pucCacheMem = ( uint8_t * ) ffconfigMALLOC( ulCacheSize );
if( pxIOManager->pucCacheMem != NULL )
{
/* Indicate that malloc() was used for pucCacheMem. */
pxIOManager->ucFlags |= FF_IOMAN_ALLOC_BUFFERS;
}
else
{
xError = FF_ERR_NOT_ENOUGH_MEMORY | FF_CREATEIOMAN;
}
}
if( pxIOManager->pucCacheMem != NULL )
{
memset( pxIOManager->pucCacheMem, '\0', ulCacheSize );
}
}
if( FF_isERR( xError ) == pdFALSE )
{
pxIOManager->usSectorSize = usSectorSize;
pxIOManager->usCacheSize = ( uint16_t ) ( ulCacheSize / ( uint32_t ) usSectorSize );
/* Malloc() memory for buffer objects. FreeRTOS+FAT never refers to a
buffer directly but uses buffer objects instead. Allows for thread
safety. */
pxIOManager->pxBuffers = ( FF_Buffer_t * ) ffconfigMALLOC( sizeof( FF_Buffer_t ) * pxIOManager->usCacheSize );
if( pxIOManager->pxBuffers != NULL )
{
/* From now on a call to FF_IOMAN_InitBufferDescriptors will clear
pxBuffers. */
pxIOManager->ucFlags |= FF_IOMAN_ALLOC_BUFDESCR;
FF_IOMAN_InitBufferDescriptors( pxIOManager );
/* Finally store the semaphore for Buffer Description modifications. */
pxIOManager->pvSemaphore = pxParameters->pvSemaphore;
if( pxParameters->xBlockDeviceIsReentrant != pdFALSE )
{
pxIOManager->ucFlags |= FF_IOMAN_BLOCK_DEVICE_IS_REENTRANT;
}
pxIOManager->xBlkDevice.fnpReadBlocks = pxParameters->fnReadBlocks;
pxIOManager->xBlkDevice.fnpWriteBlocks = pxParameters->fnWriteBlocks;
pxIOManager->xBlkDevice.pxDisk = pxParameters->pxDisk;
}
else
{
xError = FF_ERR_NOT_ENOUGH_MEMORY | FF_CREATEIOMAN;
}
}
if( FF_isERR( xError ) )
{
if( pxIOManager != NULL )
{
FF_DeleteIOManager( pxIOManager );
pxIOManager = NULL;
}
}
if( pError != NULL )
{
*pError = xError;
}
return pxIOManager;
} /* FF_CreateIOManger() */
/*-----------------------------------------------------------*/
/**
* @public
* @brief Destroys an FF_IOManager_t object, and frees all assigned memory.
*
* @param pxIOManager Pointer to an FF_IOManager_t object, as returned from FF_CreateIOManger.
*
* @Return FF_ERR_NONE on sucess, or a documented error code on failure. (FF_ERR_NULL_POINTER)
*
**/
FF_Error_t FF_DeleteIOManager( FF_IOManager_t *pxIOManager )
{
FF_Error_t xError;
/* Ensure no NULL pointer was provided. */
if( pxIOManager == NULL )
{
xError = FF_ERR_NULL_POINTER | FF_DESTROYIOMAN;
}
else
{
xError = FF_ERR_NONE;
/* Ensure pxBuffers pointer was allocated. */
if( ( pxIOManager->ucFlags & FF_IOMAN_ALLOC_BUFDESCR ) != 0 )
{
ffconfigFREE( pxIOManager->pxBuffers );
}
/* Ensure pucCacheMem pointer was allocated. */
if( ( pxIOManager->ucFlags & FF_IOMAN_ALLOC_BUFFERS ) != 0 )
{
ffconfigFREE( pxIOManager->pucCacheMem );
}
/* Delete the event group object within the IO manager before deleting
the manager. */
FF_DeleteEvents( pxIOManager );
/* Finally free the FF_IOManager_t object. */
ffconfigFREE( pxIOManager );
}
return xError;
} /* FF_DeleteIOManager() */
/*-----------------------------------------------------------*/
/**
* @private
* @brief Initialises Buffer Descriptions as part of the FF_IOManager_t object initialisation.
*
* @param pxIOManager IOMAN Object.
*
**/
void FF_IOMAN_InitBufferDescriptors( FF_IOManager_t *pxIOManager )
{
uint8_t *pucBuffer = pxIOManager->pucCacheMem;
FF_Buffer_t *pxBuffer = pxIOManager->pxBuffers;
FF_Buffer_t *pxLastBuffer = pxBuffer + pxIOManager->usCacheSize;
/* Clear the contents of the buffer descriptors. */
memset( ( void * ) pxBuffer, '\0', sizeof( FF_Buffer_t ) * pxIOManager->usCacheSize );
while( pxBuffer < pxLastBuffer )
{
pxBuffer->pucBuffer = pucBuffer;
pxBuffer++;
pucBuffer += pxIOManager->usSectorSize;
}
} /* FF_IOMAN_InitBufferDescriptors() */
/*-----------------------------------------------------------*/
/**
* @private
* @brief Flushes all Write cache buffers with no active Handles.
*
* @param pxIOManager IOMAN Object.
*
* @Return FF_ERR_NONE on Success.
**/
FF_Error_t FF_FlushCache( FF_IOManager_t *pxIOManager )
{
BaseType_t xIndex, xIndex2;
FF_Error_t xError;
if( pxIOManager == NULL )
{
xError = FF_ERR_NULL_POINTER | FF_FLUSHCACHE;
}
else
{
xError = FF_ERR_NONE;
FF_PendSemaphore( pxIOManager->pvSemaphore );
{
for( xIndex = 0; xIndex < pxIOManager->usCacheSize; xIndex++ )
{
/* If a buffers has no users and if it has been modified... */
if( ( pxIOManager->pxBuffers[ xIndex ].usNumHandles == 0 ) && ( pxIOManager->pxBuffers[ xIndex ].bModified == pdTRUE ) )
{
/* The buffer may be flushed to disk. */
FF_BlockWrite( pxIOManager, pxIOManager->pxBuffers[ xIndex ].ulSector, 1, pxIOManager->pxBuffers[ xIndex ].pucBuffer, pdTRUE );
/* Buffer has now been flushed, mark it as a read buffer and unmodified. */
pxIOManager->pxBuffers[ xIndex ].ucMode = FF_MODE_READ;
pxIOManager->pxBuffers[ xIndex ].bModified = pdFALSE;
/* Search for other buffers that used this sector, and mark them as modified
So that further requests will result in the new sector being fetched. */
for( xIndex2 = 0; xIndex2 < pxIOManager->usCacheSize; xIndex2++ )
{
if( ( xIndex != xIndex2 ) &&
( pxIOManager->pxBuffers[ xIndex2 ].ulSector == pxIOManager->pxBuffers[ xIndex ].ulSector ) &&
( pxIOManager->pxBuffers[ xIndex2 ].ucMode == FF_MODE_READ ) )
{
pxIOManager->pxBuffers[ xIndex2 ].bModified = pdTRUE;
}
}
}
}
}
if( ( pxIOManager->xBlkDevice.pxDisk != NULL ) &&
( pxIOManager->xBlkDevice.pxDisk->fnFlushApplicationHook != NULL ) )
{
/* Let the low-level driver also flush data.
See comments in ff_ioman.h. */
pxIOManager->xBlkDevice.pxDisk->fnFlushApplicationHook( pxIOManager->xBlkDevice.pxDisk );
}
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
}
return xError;
} /* FF_FlushCache() */
/*-----------------------------------------------------------*/
/*
A new version of FF_GetBuffer() with a simple mechanism for timeout
*/
#define FF_GETBUFFER_SLEEP_TIME_MS 10
#define FF_GETBUFFER_WAIT_TIME_MS ( 20000 / FF_GETBUFFER_SLEEP_TIME_MS )
FF_Buffer_t *FF_GetBuffer( FF_IOManager_t *pxIOManager, uint32_t ulSector, uint8_t ucMode )
{
FF_Buffer_t *pxBuffer;
/* Least Recently Used Buffer */
FF_Buffer_t *pxRLUBuffer;
FF_Buffer_t *pxMatchingBuffer = NULL;
int32_t lRetVal;
BaseType_t xLoopCount = FF_GETBUFFER_WAIT_TIME_MS;
const FF_Buffer_t *pxLastBuffer = &( pxIOManager->pxBuffers[ pxIOManager->usCacheSize ] );
/* 'pxIOManager->usCacheSize' is bigger than zero and it is a multiple of ulSectorSize. */
while( pxMatchingBuffer == NULL )
{
xLoopCount--;
if( xLoopCount == 0 )
{
break;
}
FF_PendSemaphore( pxIOManager->pvSemaphore );
for( pxBuffer = pxIOManager->pxBuffers; pxBuffer < pxLastBuffer; pxBuffer++ )
{
if( ( pxBuffer->ulSector == ulSector ) && ( pxBuffer->bValid ) )
{
pxMatchingBuffer = pxBuffer;
/* Don't look further if you found a perfect match. */
break;
}
}
if( pxMatchingBuffer != NULL )
{
/* A Match was found process! */
if( ( ucMode == FF_MODE_READ ) && ( pxMatchingBuffer->ucMode == FF_MODE_READ ) )
{
pxMatchingBuffer->usNumHandles += 1;
pxMatchingBuffer->usPersistance += 1;
break;
}
if( pxMatchingBuffer->usNumHandles == 0 )
{
pxMatchingBuffer->ucMode = ( ucMode & FF_MODE_RD_WR );
if( ( ucMode & FF_MODE_WRITE ) != 0 )
{
/* This buffer has no attached handles. */
pxMatchingBuffer->bModified = pdTRUE;
}
pxMatchingBuffer->usNumHandles = 1;
pxMatchingBuffer->usPersistance += 1;
break;
}
pxMatchingBuffer = NULL; /* Sector is already in use, keep yielding until its available! */
}
else
{
/* There is no valid buffer now for the desired sector.
Find a free buffer and use it for that sector. */
pxRLUBuffer = NULL;
for( pxBuffer = pxIOManager->pxBuffers; pxBuffer < pxLastBuffer; pxBuffer++ )
{
if( pxBuffer->usNumHandles != 0 )
{
continue; /* Occupied */
}
pxBuffer->ulLRU += 1;
if( ( pxRLUBuffer == NULL ) ||
( pxBuffer->ulLRU > pxRLUBuffer->ulLRU ) ||
( ( pxBuffer->ulLRU == pxRLUBuffer->ulLRU ) && ( pxBuffer->usPersistance > pxRLUBuffer->usPersistance ) ) )
{
pxRLUBuffer = pxBuffer;
}
}
/* A free buffer with the highest value of 'ulLRU' was found: */
if( pxRLUBuffer != NULL )
{
/* Process the suitable candidate. */
if( pxRLUBuffer->bModified == pdTRUE )
{
/* Along with the pdTRUE parameter to indicate semaphore has been claimed already. */
lRetVal = FF_BlockWrite( pxIOManager, pxRLUBuffer->ulSector, 1, pxRLUBuffer->pucBuffer, pdTRUE );
if( lRetVal < 0 )
{
/* NULL will be returned because 'pxMatchingBuffer' is still NULL. */
break;
}
}
if( ucMode == FF_MODE_WR_ONLY )
{
memset( pxRLUBuffer->pucBuffer, '\0', pxIOManager->usSectorSize );
}
else
{
lRetVal = FF_BlockRead( pxIOManager, ulSector, 1, pxRLUBuffer->pucBuffer, pdTRUE );
if( lRetVal < 0 )
{
/* 'pxMatchingBuffer' is NULL. */
break;
}
}
pxRLUBuffer->ucMode = ( ucMode & FF_MODE_RD_WR );
pxRLUBuffer->usPersistance = 1;
pxRLUBuffer->ulLRU = 0;
pxRLUBuffer->usNumHandles = 1;
pxRLUBuffer->ulSector = ulSector;
pxRLUBuffer->bModified = ( ucMode & FF_MODE_WRITE ) != 0;
pxRLUBuffer->bValid = pdTRUE;
pxMatchingBuffer = pxRLUBuffer;
break;
} /* if( pxRLUBuffer != NULL ) */
} /* else ( pxMatchingBuffer == NULL ) */
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
/* Better to go asleep to give low-priority task a chance to release buffer(s). */
FF_BufferWait( pxIOManager, FF_GETBUFFER_SLEEP_TIME_MS );
} /* while( pxMatchingBuffer == NULL ) */
if( xLoopCount > 0 )
{
/* If xLoopCount is 0 here, the semaphore was not taken. */
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
}
if( pxMatchingBuffer == NULL )
{
FF_PRINTF( "FF_GetBuffer[0x%X]: failed mode 0x%X\n", ( unsigned )ulSector, ( unsigned )ucMode );
}
return pxMatchingBuffer; /* Return the Matched Buffer! */
} /* FF_GetBuffer() */
/*-----------------------------------------------------------*/
/**
* @private
* @brief Releases a buffer resource.
*
* @param pxIOManager Pointer to an FF_IOManager_t object.
* @param pxBuffer Pointer to an FF_Buffer_t object.
*
**/
FF_Error_t FF_ReleaseBuffer( FF_IOManager_t *pxIOManager, FF_Buffer_t *pxBuffer )
{
FF_Error_t xError = FF_ERR_NONE;
/* Protect description changes with a semaphore. */
FF_PendSemaphore( pxIOManager->pvSemaphore );
{
#if( ffconfigCACHE_WRITE_THROUGH != 0 )
if( pxBuffer->bModified == pdTRUE )
{
xError = FF_BlockWrite( pxIOManager, pxBuffer->ulSector, 1, pxBuffer->pucBuffer, pdTRUE );
if( FF_isERR( xError ) == pdFALSE )
{
/* Ensure if an error occurs its still possible to write the block again. */
pxBuffer->bModified = pdFALSE;
}
}
#endif
configASSERT( pxBuffer->usNumHandles != 0 );
if( pxBuffer->usNumHandles != 0 )
{
pxBuffer->usNumHandles--;
}
else
{
/*printf ("FF_ReleaseBuffer: buffer not claimed\n"); */
}
}
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
/* Notify tasks which may be waiting in FF_GetBuffer() */
FF_BufferProceed( pxIOManager );
return xError;
} /* FF_ReleaseBuffer() */
/*-----------------------------------------------------------*/
/* New Interface for FreeRTOS+FAT to read blocks. */
int32_t FF_BlockRead( FF_IOManager_t *pxIOManager, uint32_t ulSectorLBA, uint32_t ulNumSectors, void *pxBuffer,
BaseType_t xSemLocked )
{
int32_t slRetVal = 0;
if( pxIOManager->xPartition.ulTotalSectors != 0ul )
{
/* At some point while formatting a partition, ulTotalSectors might be unknown.
In that case this test will be skipped. */
if( ( ulSectorLBA + ulNumSectors ) > ( pxIOManager->xPartition.ulTotalSectors + pxIOManager->xPartition.ulBeginLBA ) )
{
slRetVal = FF_ERR_IOMAN_OUT_OF_BOUNDS_READ | FF_BLOCKREAD;
}
}
if( ( slRetVal == 0ul ) && ( pxIOManager->xBlkDevice.fnpReadBlocks != NULL ) )
{
do
{
/* Make sure we don't execute a NULL. */
if( ( xSemLocked == pdFALSE ) &&
( ( pxIOManager->ucFlags & FF_IOMAN_BLOCK_DEVICE_IS_REENTRANT ) == pdFALSE ) )
{
FF_PendSemaphore( pxIOManager->pvSemaphore );
}
slRetVal = pxIOManager->xBlkDevice.fnpReadBlocks( pxBuffer, ulSectorLBA, ulNumSectors, pxIOManager->xBlkDevice.pxDisk );
if( ( xSemLocked == pdFALSE ) &&
( ( pxIOManager->ucFlags & FF_IOMAN_BLOCK_DEVICE_IS_REENTRANT ) == pdFALSE ) )
{
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
}
if( FF_GETERROR( slRetVal ) != FF_ERR_DRIVER_BUSY )
{
break;
}
FF_Sleep( ffconfigDRIVER_BUSY_SLEEP_MS );
} while( pdTRUE );
}
return slRetVal;
} /* FF_BlockRead() */
/*-----------------------------------------------------------*/
int32_t FF_BlockWrite( FF_IOManager_t *pxIOManager, uint32_t ulSectorLBA, uint32_t ulNumSectors, void *pxBuffer,
BaseType_t xSemLocked )
{
int32_t slRetVal = 0;
if( pxIOManager->xPartition.ulTotalSectors != 0 )
{
/* At some point while formatting a partition, ulTotalSectors might be unknown.
In that case this test will be skipped. */
if( ( ulSectorLBA + ulNumSectors ) > ( pxIOManager->xPartition.ulTotalSectors + pxIOManager->xPartition.ulBeginLBA ) )
{
slRetVal = FF_ERR_IOMAN_OUT_OF_BOUNDS_WRITE | FF_BLOCKWRITE;
}
}
if( ( slRetVal == 0ul ) && ( pxIOManager->xBlkDevice.fnpWriteBlocks != NULL ) )
{
do
{ /* Make sure we don't execute a NULL. */
if( ( xSemLocked == pdFALSE ) &&
( ( pxIOManager->ucFlags & FF_IOMAN_BLOCK_DEVICE_IS_REENTRANT ) == pdFALSE ) )
{
FF_PendSemaphore( pxIOManager->pvSemaphore );
}
slRetVal = pxIOManager->xBlkDevice.fnpWriteBlocks( pxBuffer, ulSectorLBA, ulNumSectors, pxIOManager->xBlkDevice.pxDisk );
if( ( xSemLocked == pdFALSE ) &&
( ( pxIOManager->ucFlags & FF_IOMAN_BLOCK_DEVICE_IS_REENTRANT ) == pdFALSE ) )
{
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
}
if( FF_GETERROR( slRetVal ) != FF_ERR_DRIVER_BUSY )
{
break;
}
FF_Sleep( ffconfigDRIVER_BUSY_SLEEP_MS );
} while( pdTRUE );
}
return slRetVal;
} /* FF_BlockWrite() */
/*-----------------------------------------------------------*/
/*
* This global variable is a kind of expert option:
* It may be set to one of these values: FF_T_FAT[12,16,32]
* just to force the driver to assume a certain FAT type.
*/
uint8_t ucAssumeFATType;
/* The history of FAT types:
* The Microsoft documents says that the actual type: FAT-12, FAT-16 and FAT-32
* of a partition can be found by looking at the total number of data clusters:
*
* if( clusters < 4085 )
* Assume FAT-12
* else if( clusters < 65525 )
* Assume FAT-16
* else
* Assume FAT-32
*
* In practice however, this does not always seem to be a correct assumption.
*
* The first 12 or 16 bits in the FAT table may also help to determine the
* correct FAT-type:
*
* FAT-12: ( firstWord & 0x3FF ) == 0x3F8 )
* FAT-16: ( firstWord == 0xFFF8 )
*/
static FF_Error_t prvDetermineFatType( FF_IOManager_t *pxIOManager )
{
FF_Partition_t *pxPartition;
FF_Buffer_t *pxBuffer;
uint32_t ulFirstWord = 0ul;
FF_Error_t xError = FF_ERR_NONE;
pxPartition = &( pxIOManager->xPartition );
if( ucAssumeFATType != 0 )
{
switch( ucAssumeFATType )
{
case FF_T_FAT12:
case FF_T_FAT16:
case FF_T_FAT32:
pxPartition->ucType = ucAssumeFATType;
break;
default:
/* An invalid value will be ignored, and the FAT type is determined dynamically. */
ucAssumeFATType = 0;
break;
}
xError = FF_ERR_NONE;
}
/* Test again, the value may have become zero now: */
if( ucAssumeFATType == 0 )
{
pxBuffer = FF_GetBuffer( pxIOManager, pxIOManager->xPartition.ulFATBeginLBA, FF_MODE_READ );
if( pxBuffer == NULL )
{
xError = FF_ERR_DEVICE_DRIVER_FAILED | FF_DETERMINEFATTYPE;
}
else
{
ulFirstWord = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, 0x0000 );
xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
}
}
if( ( ucAssumeFATType == 0 ) && ( FF_isERR( xError ) == pdFALSE ) )
{
#if( ffconfigFAT12_SUPPORT != 0 )
if( pxPartition->ulNumClusters < FAT16_SECTOR_COUNT_4085 )
{
/* FAT12 */
pxPartition->ucType = FF_T_FAT12;
#if( ffconfigFAT_CHECK != 0 )
if( ( ulFirstWord & 0x3FF ) != 0x3F8 )
{
xError = FF_ERR_IOMAN_NOT_FAT_FORMATTED | FF_DETERMINEFATTYPE;
}
else
#endif /* ffconfigFAT_CHECK */
{
xError = FF_ERR_NONE;
}
}
else
#endif /* ffconfigFAT12_SUPPORT */
if( pxPartition->ulNumClusters < FAT32_SECTOR_COUNT_65525 )
{
/* FAT 16 */
pxPartition->ucType = FF_T_FAT16;
#if( ffconfigFAT_CHECK != 0 )
{
if( ulFirstWord == 0xFFF8 )
{
xError = FF_ERR_NONE;
}
else {
if( ( ulFirstWord & 0x3FF ) != 0x3F8 )
{
FF_PRINTF( "Part at %lu is probably a FAT12\n", pxIOManager->xPartition.ulFATBeginLBA );
}
else
{
FF_PRINTF( "Partition at %lu has strange FAT data %08lX\n",
pxIOManager->xPartition.ulFATBeginLBA, ulFirstWord );
}
xError = FF_ERR_IOMAN_INVALID_FORMAT | FF_DETERMINEFATTYPE;
}
}
#endif /* ffconfigFAT_CHECK */
}
else
{
/* FAT 32! */
pxPartition->ucType = FF_T_FAT32;
#if( ffconfigFAT_CHECK != 0 )
if( ( ( ulFirstWord & 0x0FFFFFF8 ) != 0x0FFFFFF8 ) &&
( ( ulFirstWord & 0x0FFFFFF8 ) != 0x0FFFFFF0 ) )
{
/* _HT_
I had an SD-card which worked well in Linux/W32
but FreeRTOS+FAT returned me this error
So for me I left out this check (just issue a warning for now)
*/
FF_PRINTF( "prvDetermineFatType: firstWord %08lX\n", ulFirstWord );
xError = FF_ERR_NONE; /* FF_ERR_IOMAN_NOT_FAT_FORMATTED; */
}
#endif /* ffconfigFAT_CHECK */
xError = FF_ERR_NONE;
}
}
return xError;
} /* prvDetermineFatType() */
/*-----------------------------------------------------------*/
/* Check if ucPartitionID introduces an extended partition. */
static BaseType_t prvIsExtendedPartition( uint8_t ucPartitionID )
{
BaseType_t xResult;
if( ( ucPartitionID == FF_DOS_EXT_PART ) ||
( ucPartitionID == FF_WIN98_EXT_PART ) ||
( ucPartitionID == FF_LINUX_EXT_PART ) )
{
xResult = pdTRUE;
}
else
{
xResult = pdFALSE;
}
return xResult;
} /* prvIsExtendedPartition() */
/*-----------------------------------------------------------*/
/* Check if the media byte in an MBR is valid */
static BaseType_t prvIsValidMedia( uint8_t media )
{
BaseType_t xResult;
/*
* 0xF8 is the standard value for “fixed” (non-removable) media. For
* removable media, 0xF0 is frequently used. The legal values for this
* field are 0xF0, 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, and
* 0xFF. The only other important point is that whatever value is put
* in here must also be put in the low byte of the FAT[0] entry. This
* dates back to the old MS-DOS 1.x media determination noted
* earlier and is no longer usually used for anything.
*/
if( ( 0xf8 <= media ) || ( media == 0xf0 ) )
{
xResult = pdTRUE;
}
else
{
xResult = pdFALSE;
}
return xResult;
} /* prvIsValidMedia() */
/*-----------------------------------------------------------*/
void FF_ReadParts( uint8_t *pucBuffer, FF_Part_t *pxParts )
{
BaseType_t xPartNr;
UBaseType_t uxOffset = FF_FAT_PTBL;
/* pxParts is expected to be declared as an array of 4 elements:
FF_Part_t pxParts[4];
FF_ReadParts( pxBuffer->pucBuffer, pxParts );
*/
for( xPartNr = 0; xPartNr < 4; xPartNr++, uxOffset += 16, pxParts++ )
{
pxParts->ucActive = FF_getChar( pucBuffer, uxOffset + FF_FAT_PTBL_ACTIVE );
pxParts->ucPartitionID = FF_getChar( pucBuffer, uxOffset + FF_FAT_PTBL_ID );
pxParts->ulSectorCount = FF_getLong( pucBuffer, uxOffset + FF_FAT_PTBL_SECT_COUNT );
pxParts->ulStartLBA = FF_getLong( pucBuffer, uxOffset + FF_FAT_PTBL_LBA );
}
}
/*-----------------------------------------------------------*/
/* This function will traverse through a chain of extended partitions. */
/* It is protected against rubbish data by a counter. */
static FF_Error_t FF_ParseExtended( FF_IOManager_t *pxIOManager, uint32_t ulFirstSector, uint32_t ulFirstSize,
FF_SPartFound_t *pPartsFound )
{
uint32_t ulThisSector, ulThisSize;
uint32_t ulSectorSize = pxIOManager->usSectorSize / 512;
uint32_t prevTotalSectors = pxIOManager->xPartition.ulTotalSectors;
FF_Buffer_t *pxBuffer = NULL;
BaseType_t xTryCount = 100;
BaseType_t xPartNr;
BaseType_t xExtendedPartNr;
FF_Error_t xError = FF_ERR_NONE;
FF_Part_t pxPartitions[ 4 ];
ulThisSector = ulFirstSector;
ulThisSize = ulFirstSize;
/* Disable sector checking in FF_BlockRead, because the
exact disk (partition) parameters are not yet known.
Let user driver return an error is appropriate. */
pxIOManager->xPartition.ulTotalSectors = 0;
while( xTryCount-- )
{
if( ( pxBuffer == NULL ) || ( pxBuffer->ulSector != ulThisSector ) )
{
/* Moving to a different sector. Release the
previous one and allocate a new buffer. */
if( pxBuffer != NULL )
{
xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
pxBuffer = NULL;
if( FF_isERR( xError ) )
{
break;
}
}
FF_PRINTF( "FF_ParseExtended: Read sector %u\n", ( unsigned) ulThisSector );
pxBuffer = FF_GetBuffer( pxIOManager, ulThisSector, FF_MODE_READ );
if( pxBuffer == NULL )
{
xError = FF_PARSEEXTENDED | FF_ERR_DEVICE_DRIVER_FAILED; /* | FUNCTION...; */
break;
}
}
{
uint8_t a = FF_getChar( pxBuffer->pucBuffer, FF_FAT_MBR_SIGNATURE + 0 );
uint8_t b = FF_getChar( pxBuffer->pucBuffer, FF_FAT_MBR_SIGNATURE + 1 );
if( ( a != 0x55 ) || ( b != 0xAA ) )
{
FF_PRINTF( "FF_ParseExtended: No signature %02X,%02X\n", a, b );
break;
}
}
/* Check for data partition(s),
and remember if there is an extended partition */
FF_ReadParts( pxBuffer->pucBuffer, pxPartitions );
/* Assume there is no next ext partition. */
xExtendedPartNr = -1;
for( xPartNr = 0; xPartNr < 4; xPartNr++ )
{
uint32_t ulOffset, ulSize, ulNext;
if( pxPartitions[ xPartNr ].ulSectorCount == 0 )
{
/* Partition is empty */
continue;
}
if( prvIsExtendedPartition( pxPartitions[ xPartNr ].ucPartitionID ) )
{
if( xExtendedPartNr < 0 )
{
xExtendedPartNr = xPartNr;
}
continue; /* We'll examine this ext partition later */
}
/* Some sanity checks */
ulOffset = pxPartitions[ xPartNr ].ulStartLBA * ulSectorSize;
ulSize = pxPartitions[ xPartNr ].ulSectorCount * ulSectorSize;
ulNext = ulThisSector + ulOffset;
if(
/* Is it oversized? */
( ulOffset + ulSize > ulThisSize ) ||
/* or going backward? */
( ulNext < ulFirstSector ) ||
/* Or outsize the logical partition? */
( ulNext > ulFirstSector + ulFirstSize )
)
{
FF_PRINTF( "Part %d looks insane: ulThisSector %u ulOffset %u ulNext %u\n",
( int ) xPartNr, ( unsigned )ulThisSector, ( unsigned )ulOffset, ( unsigned )ulNext );
continue;
}
{
/* Store this partition for the caller */
FF_Part_t *p = &pPartsFound->pxPartitions[ pPartsFound->iCount++ ];
/* Copy the whole structure */
memcpy( p, pxPartitions + xPartNr, sizeof( *p ) );
/* and make LBA absolute to sector-0. */
p->ulStartLBA += ulThisSector;
p->bIsExtended = pdTRUE;
}
if( pPartsFound->iCount >= ffconfigMAX_PARTITIONS )
{
break;
}
xTryCount = 100;
} /* for( xPartNr = 0; xPartNr < 4; xPartNr++ ) */
if( xExtendedPartNr < 0 )
{
FF_PRINTF( "No more extended partitions\n" );
break; /* nothing left to do */
}
/* Examine the ulNext extended partition */
ulThisSector = ulFirstSector + pxPartitions[ xExtendedPartNr ].ulStartLBA * ulSectorSize;
ulThisSize = pxPartitions[ xExtendedPartNr ].ulSectorCount * ulSectorSize;
}
if( pxBuffer != NULL )
{
FF_Error_t xTempError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
if( FF_isERR( xError ) == pdFALSE )
{
xError = xTempError;
}
}
pxIOManager->xPartition.ulTotalSectors = prevTotalSectors;
return xError;
} /* FF_ParseExtended() */
/*-----------------------------------------------------------*/
/**
* @public
* @brief Searches a disk for all primary and extended/logical partitions
* @brief Previously called FF_PartitionCount
*
* @param pxIOManager FF_IOManager_t object.
* @param pPartsFound Contains an array of ffconfigMAX_PARTITIONS partitions
*
* @Return >=0 Number of partitions found
* @Return <0 error
**/
FF_Error_t FF_PartitionSearch( FF_IOManager_t *pxIOManager, FF_SPartFound_t *pPartsFound )
{
BaseType_t xPartNr;
FF_Buffer_t *pxBuffer;
uint8_t *ucDataBuffer;
BaseType_t isPBR = pdFALSE;
FF_Error_t xError = FF_ERR_NONE;
uint32_t prevTotalSectors = pxIOManager->xPartition.ulTotalSectors;
FF_Part_t pxPartitions[ 4 ];
memset( pPartsFound, '\0', sizeof( *pPartsFound ) );
do
{
pxBuffer = FF_GetBuffer( pxIOManager, 0, FF_MODE_READ );
if( pxBuffer == NULL )
{
xError = FF_ERR_DEVICE_DRIVER_FAILED | FF_PARTITIONSEARCH;
break;
}
/* Disable sector checking in FF_BlockRead
Let user driver return an error is appropriate. */
pxIOManager->xPartition.ulTotalSectors = 0;
ucDataBuffer = pxBuffer->pucBuffer;
/* Check MBR (Master Boot Record) or
PBR (Partition Boot Record) signature. */
if( ( FF_getChar( ucDataBuffer, FF_FAT_MBR_SIGNATURE ) != 0x55 ) &&
( FF_getChar( ucDataBuffer, FF_FAT_MBR_SIGNATURE ) != 0xAA ) )
{
/* No MBR, but is it a PBR ?
Partition Boot Record */
if( ( FF_getChar( ucDataBuffer, 0 ) == 0xEB ) && /* PBR Byte 0 */
( FF_getChar( ucDataBuffer, 2 ) == 0x90 ) )
{
/* PBR Byte 2
No MBR but PBR exist then there is only one partition
Handle this later. */
isPBR = pdTRUE;
}
else
{
FF_PRINTF( "FF_PartitionSearch: [%02X,%02X] No signature (%02X %02X), no PBR neither\n",
FF_getChar( ucDataBuffer, 0 ),
FF_getChar( ucDataBuffer, 2 ),
FF_getChar( ucDataBuffer, FF_FAT_MBR_SIGNATURE ),
FF_getChar( ucDataBuffer, FF_FAT_MBR_SIGNATURE + 1 ) );
/* No MBR and no PBR then no partition found. */
xError = FF_ERR_IOMAN_INVALID_FORMAT | FF_PARTITIONSEARCH;
break;
}
}
/* Copy the 4 partition records into 'pxPartitions': */
FF_ReadParts( ucDataBuffer, pxPartitions );
for( xPartNr = 0; ( xPartNr < 4 ) && ( isPBR == pdFALSE ); xPartNr++ )
{
/* FF_PRINTF ("FF_Part[%d]: id %02X act %02X Start %6lu Len %6lu (sectors)\n", */
/* xPartNr, pxPartitions[ xPartNr ].ucPartitionID, */
/* pxPartitions[ xPartNr ].ucActive, */
/* pxPartitions[ xPartNr ].ulStartLBA, */
/* pxPartitions[ xPartNr ].ulSectorCount); */
if( prvIsExtendedPartition( pxPartitions[ xPartNr ].ucPartitionID ) != pdFALSE )
{
continue; /* Do this later */
}
/* The first sector must be a MBR, then check the partition entry in the MBR */
if( ( pxPartitions[ xPartNr ].ucActive != 0x80 ) &&
( pxPartitions[ xPartNr ].ucActive != 0x00 ) )
{
if( ( xPartNr == 0 ) &&
( FF_getShort( ucDataBuffer, FF_FAT_RESERVED_SECTORS ) != 0 ) &&
( FF_getChar( ucDataBuffer, FF_FAT_NUMBER_OF_FATS ) != 0 ) )
{
isPBR = pdTRUE;
}
else
{
xError = FF_ERR_IOMAN_INVALID_FORMAT | FF_PARTITIONSEARCH;
break;
}
}
else if( pxPartitions[ xPartNr ].ulSectorCount )
{
FF_Part_t *p = &pPartsFound->pxPartitions[ pPartsFound->iCount++ ];
*p = pxPartitions[ xPartNr ];
p->bIsExtended = 0;
if( pPartsFound->iCount >= ffconfigMAX_PARTITIONS )
{
break;
}
}
}
if( FF_isERR( xError ) || ( pPartsFound->iCount >= ffconfigMAX_PARTITIONS ) )
{
break;
}
for( xPartNr = 0; xPartNr < 4; xPartNr++ )
{
if( prvIsExtendedPartition( pxPartitions[ xPartNr ].ucPartitionID ) )
{
xError = FF_ParseExtended( pxIOManager, pxPartitions[ xPartNr ].ulStartLBA,
pxPartitions[ xPartNr ].ulSectorCount, pPartsFound );
if( ( FF_isERR( xError ) != pdFALSE ) || ( pPartsFound->iCount >= ffconfigMAX_PARTITIONS ) )
{
goto done;
}
}
}
if( pPartsFound->iCount == 0 )
{
FF_PRINTF( "FF_Part: no partitions, try as PBR\n" );
isPBR = pdTRUE;
}
if( isPBR )
{
uint8_t media = FF_getChar( ucDataBuffer, FF_FAT_MEDIA_TYPE );
FF_Part_t *p;
if( !prvIsValidMedia( media ) )
{
FF_PRINTF( "FF_Part: Looks like PBR but media %02X\n", media );
xError = FF_ERR_IOMAN_NO_MOUNTABLE_PARTITION | FF_PARTITIONSEARCH;
goto done;
}
/* This looks like a PBR because it has a valid media type */
p = pPartsFound->pxPartitions;
p->ulStartLBA = 0; /* FF_FAT_PTBL_LBA */
p->ulSectorCount = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, FF_FAT_16_TOTAL_SECTORS );
if( p->ulSectorCount == 0ul )
{
p->ulSectorCount = FF_getLong( pxBuffer->pucBuffer, FF_FAT_32_TOTAL_SECTORS );
}
p->ucActive = 0x80; /* FF_FAT_PTBL_ACTIVE */
p->ucPartitionID = 0x0B; /* FF_FAT_PTBL_ID MSDOS data partition */
p->bIsExtended = 0;
pPartsFound->iCount = 1;
}
} while( pdFALSE );
done:
if( pxBuffer )
{
FF_Error_t xTempError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
if( FF_isERR( xError ) == pdFALSE )
{
xError = xTempError;
}
}
pxIOManager->xPartition.ulTotalSectors = prevTotalSectors;
return FF_isERR( xError ) ? xError : pPartsFound->iCount;
} /* FF_PartitionSearch() */
/*-----------------------------------------------------------*/
/*
Mount GPT Partition Tables
*/
#define FF_GPT_HEAD_ENTRY_SIZE 0x54
#define FF_GPT_HEAD_TOTAL_ENTRIES 0x50
#define FF_GPT_HEAD_PART_ENTRY_LBA 0x48
#define FF_GPT_ENTRY_FIRST_SECTOR_LBA 0x20
#define FF_GPT_HEAD_CRC 0x10
#define FF_GPT_HEAD_LENGTH 0x0C
static FF_Error_t FF_GetEfiPartitionEntry( FF_IOManager_t *pxIOManager, uint32_t ulPartitionNumber )
{
/* Continuing on from FF_Mount() pPartition->ulBeginLBA should be the sector of the GPT Header */
FF_Buffer_t *pxBuffer;
FF_Partition_t *pxPartition = &( pxIOManager->xPartition );
uint32_t ulBeginGPT;
uint32_t ulEntrySector;
uint32_t ulSectorOffset;
uint32_t ulPartitionEntrySize;
uint32_t ulGPTHeadCRC, ulGPTCrcCheck, ulGPTHeadLength;
FF_Error_t xError;
do
{
if( ulPartitionNumber >= 128 )
{
xError = FF_ERR_IOMAN_INVALID_PARTITION_NUM | FF_GETEFIPARTITIONENTRY;
break;
}
pxBuffer = FF_GetBuffer( pxIOManager, pxPartition->ulBeginLBA, FF_MODE_READ );
if( pxBuffer == NULL )
{
xError = FF_ERR_DEVICE_DRIVER_FAILED | FF_GETEFIPARTITIONENTRY;
break;
}
/* Verify this is an EFI header with the text "EFI PART": */
if( memcmp( pxBuffer->pucBuffer, "EFI PART", 8 ) != 0 )
{
/* Already returning an error, but this error would override the current one. */
xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
if( FF_isERR( xError ) == pdFALSE )
{
xError = FF_ERR_IOMAN_INVALID_FORMAT | FF_GETEFIPARTITIONENTRY;
}
break;
}
ulBeginGPT = FF_getLong( pxBuffer->pucBuffer, FF_GPT_HEAD_PART_ENTRY_LBA );
ulPartitionEntrySize = FF_getLong( pxBuffer->pucBuffer, FF_GPT_HEAD_ENTRY_SIZE );
ulGPTHeadCRC = FF_getLong( pxBuffer->pucBuffer, FF_GPT_HEAD_CRC );
ulGPTHeadLength = FF_getLong( pxBuffer->pucBuffer, FF_GPT_HEAD_LENGTH );
/* Calculate Head CRC */
/* Blank CRC field */
FF_putLong( pxBuffer->pucBuffer, FF_GPT_HEAD_CRC, 0x00000000 );
/* Calculate CRC */
ulGPTCrcCheck = FF_GetCRC32( pxBuffer->pucBuffer, ulGPTHeadLength );
/* Restore The CRC field */
FF_putLong( pxBuffer->pucBuffer, FF_GPT_HEAD_CRC, ulGPTHeadCRC );
xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
if( FF_isERR( xError ) )
{
break;
}
/* Check CRC */
if( ulGPTHeadCRC != ulGPTCrcCheck )
{
xError = FF_ERR_IOMAN_GPT_HEADER_CORRUPT | FF_GETEFIPARTITIONENTRY;
break;
}
/* Calculate Sector Containing the Partition Entry we want to use. */
ulEntrySector = ( ( ulPartitionNumber * ulPartitionEntrySize ) / pxIOManager->usSectorSize ) + ulBeginGPT;
ulSectorOffset = ( ulPartitionNumber % ( pxIOManager->usSectorSize / ulPartitionEntrySize ) ) * ulPartitionEntrySize;
pxBuffer = FF_GetBuffer( pxIOManager, ulEntrySector, FF_MODE_READ );
{
if( pxBuffer == NULL )
{
xError = FF_ERR_DEVICE_DRIVER_FAILED | FF_GETEFIPARTITIONENTRY;
break;
}
pxPartition->ulBeginLBA = FF_getLong( pxBuffer->pucBuffer, ulSectorOffset + FF_GPT_ENTRY_FIRST_SECTOR_LBA );
}
xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
if( FF_isERR( xError ) == pdFALSE )
{
if( pxPartition->ulBeginLBA == 0ul )
{
xError = FF_ERR_IOMAN_INVALID_PARTITION_NUM | FF_GETEFIPARTITIONENTRY;
}
}
}
while( pdFALSE );
return xError;
} /* FF_GetEfiPartitionEntry() */
/*-----------------------------------------------------------*/
/**
* @public
* @brief Mounts the Specified partition, the volume specified by the FF_IOManager_t object provided.
*
* The device drivers must adhere to the specification provided by
* FF_WriteBlocks_t and FF_ReadBlocks_t.
*
* @param pxIOManager FF_IOManager_t object.
* @param PartitionNumber The primary or logical partition number to be mounted,
* ranging between 0 and ffconfigMAX_PARTITIONS-1 (normally 0)
* Note that FF_PartitionSearch can be called in advance to
* enumerate all available partitions
*
* @Return 0 on success.
* @Return FF_ERR_NULL_POINTER if a pxIOManager object wasn't provided.
* @Return FF_ERR_IOMAN_INVALID_PARTITION_NUM if the partition number is out of range.
* @Return FF_ERR_IOMAN_NO_MOUNTABLE_PARTITION if no partition was found.
* @Return FF_ERR_IOMAN_INVALID_FORMAT if the master boot record or partition boot block didn't provide sensible data.
* @Return FF_ERR_IOMAN_NOT_FAT_FORMATTED if the volume or partition couldn't be determined to be FAT. (@see FreeRTOSFATConfig.h)
*
**/
FF_Error_t FF_Mount( FF_Disk_t *pxDisk, BaseType_t xPartitionNumber )
{
FF_Partition_t *pxPartition;
FF_Buffer_t *pxBuffer = 0;
FF_Error_t xError = FF_ERR_NONE;
int16_t rootEntryCount;
FF_IOManager_t *pxIOManager = pxDisk->pxIOManager;
/* HT TODO: find a method to safely determine the FAT type: 32/16/12 */
/* other than only counting Clusters */
/* UBaseType_t fat32Indicator = 0; */
FF_Part_t *pxMyPartition;
#if( ffconfigHASH_CACHE != 0 )
BaseType_t i;
#endif
FF_Error_t xPartitionCount = 0;
FF_SPartFound_t partsFound;
partsFound.iCount = 0;
do
{
if( pxIOManager == NULL )
{
xError = FF_ERR_NULL_POINTER | FF_MOUNT;
break;
}
pxPartition = &( pxIOManager->xPartition );
#if( ffconfigREMOVABLE_MEDIA != 0 )
{
pxIOManager->ucFlags &= ( uint8_t ) ( ~ ( FF_IOMAN_DEVICE_IS_EXTRACTED ) );
}
#endif /* ffconfigREMOVABLE_MEDIA */
/* FF_IOMAN_InitBufferDescriptors will clear 'pxBuffers' */
memset( pxIOManager->pucCacheMem, '\0', ( size_t ) pxIOManager->usSectorSize * pxIOManager->usCacheSize );
#if( ffconfigHASH_CACHE != 0 )
{
memset( pxIOManager->xHashCache, '\0', sizeof( pxIOManager->xHashCache ) );
for( i = 0; i < ffconfigHASH_CACHE_DEPTH; i++ )
{
/* _HT_ Check why did JW put it to 100? */
pxIOManager->xHashCache[ i ].ulMisses = 100;
}
}
#endif
#if( ffconfigPATH_CACHE != 0 )
{
memset( pxPartition->pxPathCache, '\0', sizeof( pxPartition->pxPathCache ) );
}
#endif
FF_IOMAN_InitBufferDescriptors( pxIOManager );
pxIOManager->FirstFile = 0;
xPartitionCount = FF_PartitionSearch( pxIOManager, &partsFound );
if( FF_isERR( xPartitionCount ) )
{
xError = xPartitionCount;
break;
}
if( xPartitionCount == 0 )
{
xError = FF_ERR_IOMAN_NO_MOUNTABLE_PARTITION | FF_MOUNT;
break;
}
if( xPartitionNumber >= xPartitionCount )
{
xError = FF_ERR_IOMAN_INVALID_PARTITION_NUM | FF_MOUNT;
break;
}
pxMyPartition = &( partsFound.pxPartitions[ xPartitionNumber ] );
pxPartition->ulBeginLBA = pxMyPartition->ulStartLBA;
if( pxMyPartition->ucPartitionID == 0xEE )
{
xError = FF_GetEfiPartitionEntry( pxIOManager, xPartitionNumber );
if( FF_isERR( xError ) )
{
break;
}
}
/* Now we get the Partition sector. */
pxBuffer = FF_GetBuffer( pxIOManager, pxPartition->ulBeginLBA, FF_MODE_READ );
if( pxBuffer == NULL )
{
xError = FF_ERR_DEVICE_DRIVER_FAILED | FF_MOUNT;
break;
}
pxPartition->usBlkSize = FF_getShort( pxBuffer->pucBuffer, FF_FAT_BYTES_PER_SECTOR );
if( ( ( pxPartition->usBlkSize % 512 ) != 0 ) || ( pxPartition->usBlkSize == 0 ) )
{
/* An error here should override the current error, as its likely fatal. */
xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
if( FF_isERR( xError ) == pdFALSE )
{
xError = FF_ERR_IOMAN_INVALID_FORMAT | FF_MOUNT;
}
break;
}
/* Assume FAT16, then we'll adjust if its FAT32 */
pxPartition->usReservedSectors = FF_getShort( pxBuffer->pucBuffer, FF_FAT_RESERVED_SECTORS );
pxPartition->ulFATBeginLBA = pxPartition->ulBeginLBA + pxPartition->usReservedSectors;
pxPartition->ucNumFATS = ( uint8_t ) FF_getShort( pxBuffer->pucBuffer, FF_FAT_NUMBER_OF_FATS );
pxPartition->ulSectorsPerFAT = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, FF_FAT_16_SECTORS_PER_FAT );
pxPartition->ulSectorsPerCluster = FF_getChar( pxBuffer->pucBuffer, FF_FAT_SECTORS_PER_CLUS );
/* Set the BlockFactor (How many real-blocks in a fake block!). */
pxPartition->ucBlkFactor = ( uint8_t ) ( pxPartition->usBlkSize / pxIOManager->usSectorSize );
pxPartition->ulTotalSectors = ( uint32_t ) FF_getShort( pxBuffer->pucBuffer, FF_FAT_16_TOTAL_SECTORS );
if( pxPartition->ulTotalSectors == 0 )
{
pxPartition->ulTotalSectors = FF_getLong( pxBuffer->pucBuffer, FF_FAT_32_TOTAL_SECTORS );
}
if( pxPartition->ulSectorsPerFAT == 0 )
{ /* FAT32 */
pxPartition->ulSectorsPerFAT = FF_getLong( pxBuffer->pucBuffer, FF_FAT_32_SECTORS_PER_FAT );
pxPartition->ulRootDirCluster = FF_getLong( pxBuffer->pucBuffer, FF_FAT_ROOT_DIR_CLUSTER );
memcpy( pxPartition->pcVolumeLabel, pxBuffer->pucBuffer + FF_FAT_32_VOL_LABEL, sizeof( pxPartition->pcVolumeLabel ) - 1 );
}
else
{ /* FAT16 */
pxPartition->ulRootDirCluster = 1; /* 1st Cluster is RootDir! */
memcpy( pxPartition->pcVolumeLabel, pxBuffer->pucBuffer + FF_FAT_16_VOL_LABEL, sizeof( pxPartition->pcVolumeLabel ) - 1);
}
pxPartition->ulClusterBeginLBA = pxPartition->ulFATBeginLBA + ( pxPartition->ucNumFATS * pxPartition->ulSectorsPerFAT );
#if( ffconfigWRITE_FREE_COUNT != 0 )
{
pxPartition->ulFSInfoLBA = pxPartition->ulBeginLBA + FF_getShort( pxBuffer->pucBuffer, 48 );
}
#endif
FF_ReleaseBuffer( pxIOManager, pxBuffer ); /* Release the buffer finally! */
if( pxPartition->usBlkSize == 0 )
{
xError = FF_ERR_IOMAN_INVALID_FORMAT | FF_MOUNT;
break;
}
rootEntryCount = FF_getShort( pxBuffer->pucBuffer, FF_FAT_ROOT_ENTRY_COUNT );
pxPartition->ulRootDirSectors = ( ( rootEntryCount * 32 ) + pxPartition->usBlkSize - 1 ) / pxPartition->usBlkSize;
pxPartition->ulFirstDataSector = pxPartition->ulClusterBeginLBA + pxPartition->ulRootDirSectors;
pxPartition->ulDataSectors = pxPartition->ulTotalSectors - ( pxPartition->usReservedSectors + ( pxPartition->ucNumFATS * pxPartition->ulSectorsPerFAT ) + pxPartition->ulRootDirSectors );
/*
* HT: fat32Indicator not yet used
* As there is so much confusion about the FAT types
* I was thinking of collecting indications for either FAT12, 16 or 32
*/
/*
if( FF_getShort( pxBuffer->pucBuffer, FF_FAT_EXT_BOOT_SIGNATURE ) == 0x29 )
fat32Indicator++;
if( rootEntryCount == 0 )
fat32Indicator++;
*/
if( pxPartition->ulSectorsPerCluster == 0 )
{
xError = FF_ERR_IOMAN_INVALID_FORMAT | FF_MOUNT;
break;
}
pxPartition->ulNumClusters = pxPartition->ulDataSectors / pxPartition->ulSectorsPerCluster;
xError = prvDetermineFatType( pxIOManager );
if( FF_isERR( xError ) )
{
break;
}
if( !rootEntryCount && pxPartition->ucType != FF_T_FAT32 )
{
FF_PRINTF( "No root dir, must be a FAT32\n" );
pxPartition->ucType = FF_T_FAT32;
}
pxPartition->ucPartitionMounted = pdTRUE;
pxPartition->ulLastFreeCluster = 0;
#if( ffconfigMOUNT_FIND_FREE != 0 )
{
FF_LockFAT( pxIOManager );
{
/* The parameter 'pdFALSE' means: do not claim the free cluster found. */
pxPartition->ulLastFreeCluster = FF_FindFreeCluster( pxIOManager, &xError, pdFALSE );
}
FF_UnlockFAT( pxIOManager );
if( FF_isERR( xError ) )
{
if( FF_GETERROR( xError ) == FF_ERR_IOMAN_NOT_ENOUGH_FREE_SPACE )
{
pxPartition->ulLastFreeCluster = 0;
}
else
{
break;
}
}
pxPartition->ulFreeClusterCount = FF_CountFreeClusters( pxIOManager, &xError );
if( FF_isERR( xError ) )
{
break;
}
}
#else
{
pxPartition->ulFreeClusterCount = 0;
}
#endif /* ffconfigMOUNT_FIND_FREE */
}
while( pdFALSE );
if( FF_isERR( xError ) == pdFALSE )
{
xError = 0;
}
return xError;
} /* FF_Mount() */
/*-----------------------------------------------------------*/
/**
* @private
* @brief Checks the cache for Active Handles
*
* @param pxIOManager FF_IOManager_t Object.
*
* @Return pdTRUE if an active handle is found, else pdFALSE.
*
* @pre This function must be wrapped with the cache handling semaphore.
**/
static BaseType_t prvHasActiveHandles( FF_IOManager_t *pxIOManager )
{
BaseType_t xResult;
FF_Buffer_t *pxBuffer = pxIOManager->pxBuffers;
FF_Buffer_t *pxLastBuffer = pxBuffer + pxIOManager->usCacheSize;
for( ; ; )
{
if( pxBuffer->usNumHandles )
{
xResult = pdTRUE;
break;
}
pxBuffer++;
if( pxBuffer == pxLastBuffer )
{
xResult = pdFALSE;
break;
}
}
return xResult;
} /* prvHasActiveHandles() */
/*-----------------------------------------------------------*/
/**
* @public
* @brief Unmounts the active partition.
*
* @param pxIOManager FF_IOManager_t Object.
*
* @Return FF_ERR_NONE on success.
**/
FF_Error_t FF_Unmount( FF_Disk_t *pxDisk )
{
FF_Error_t xError = FF_ERR_NONE;
FF_IOManager_t *pxIOManager;
#if( ffconfigMIRROR_FATS_UMOUNT != 0 )
UBaseType_t uxIndex, y;
FF_Buffer_t *pxBuffer;
#endif
if( pxDisk->pxIOManager == NULL )
{
xError = FF_ERR_NULL_POINTER | FF_UNMOUNT;
}
else if( pxDisk->pxIOManager->xPartition.ucPartitionMounted == 0 )
{
xError = FF_ERR_NONE;
}
else
{
pxIOManager = pxDisk->pxIOManager;
FF_PendSemaphore( pxIOManager->pvSemaphore ); /* Ensure that there are no File Handles */
{
if( prvHasActiveHandles( pxIOManager ) != 0 )
{
/* Active handles found on the cache. */
xError = FF_ERR_IOMAN_ACTIVE_HANDLES | FF_UNMOUNT;
}
else if( pxIOManager->FirstFile != NULL )
{
/* Open files in this partition. */
xError = FF_ERR_IOMAN_ACTIVE_HANDLES | FF_UNMOUNT;
}
else
{
/* Release Semaphore to call this function! */
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
/* Flush any unwritten sectors to disk. */
xError = FF_FlushCache( pxIOManager );
/* Reclaim Semaphore */
FF_PendSemaphore( pxIOManager->pvSemaphore );
if( FF_isERR( xError ) == pdFALSE )
{
pxIOManager->xPartition.ucPartitionMounted = pdFALSE;
#if( ffconfigMIRROR_FATS_UMOUNT != 0 )
{
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
for( uxIndex = 0; uxIndex < pxIOManager->xPartition.ulSectorsPerFAT; uxIndex++ )
{
pxBuffer = FF_GetBuffer( pxIOManager, pxIOManager->xPartition.ulFATBeginLBA + uxIndex, FF_MODE_READ );
if( !pxBuffer )
{
xError = FF_ERR_DEVICE_DRIVER_FAILED | FF_UNMOUNT;
break;
}
for( y = 0; y < pxIOManager->xPartition.ucNumFATS; y++ )
{
FF_BlockWrite( pxIOManager,
pxIOManager->xPartition.ulFATBeginLBA + ( y * pxIOManager->xPartition.ulSectorsPerFAT ) + uxIndex, 1,
pxBuffer->pucBuffer, pdFALSE );
}
}
FF_PendSemaphore( pxIOManager->pvSemaphore );
}
#endif
}
}
}
FF_ReleaseSemaphore( pxIOManager->pvSemaphore );
}
return xError;
} /* FF_Unmount() */
/*-----------------------------------------------------------*/
FF_Error_t FF_IncreaseFreeClusters( FF_IOManager_t *pxIOManager, uint32_t Count )
{
FF_Error_t xError;
#if( ffconfigWRITE_FREE_COUNT != 0 )
FF_Buffer_t *pxBuffer;
#endif
do
{
/* Open a do {} while( pdFALSE ) loop to allow the use of break statements. */
if( pxIOManager->xPartition.ulFreeClusterCount == 0ul )
{
/* Apparently the number of free clusters has not been calculated yet,
or no free cluster was available. Now check it. */
pxIOManager->xPartition.ulFreeClusterCount = FF_CountFreeClusters( pxIOManager, &xError );
if( FF_isERR( xError ) )
{
break;
}
}
else
{
xError = FF_ERR_NONE;
taskENTER_CRITICAL();
{
pxIOManager->xPartition.ulFreeClusterCount += Count;
}
taskEXIT_CRITICAL();
}
if( pxIOManager->xPartition.ulLastFreeCluster == 0 )
{
BaseType_t xTakeLock = FF_Has_Lock( pxIOManager, FF_FAT_LOCK ) == pdFALSE;
if( xTakeLock )
{
FF_LockFAT( pxIOManager );
}
/* Find the an available cluster. */
pxIOManager->xPartition.ulLastFreeCluster = FF_FindFreeCluster( pxIOManager, &xError, pdFALSE );
if( xTakeLock )
{
FF_UnlockFAT( pxIOManager );
}
if( FF_isERR( xError ) )
{
break;
}
}
#if( ffconfigWRITE_FREE_COUNT != 0 )
{
/* FAT32 updates the FSINFO sector. */
if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
{
/* Find the FSINFO sector. */
pxBuffer = FF_GetBuffer( pxIOManager, pxIOManager->xPartition.ulFSInfoLBA, FF_MODE_WRITE );
if( pxBuffer == NULL )
{
xError = FF_ERR_DEVICE_DRIVER_FAILED | FF_INCREASEFREECLUSTERS;
}
else
{
uint32_t ulSignature1;
uint32_t ulSignature2;
ulSignature1 = FF_getLong( pxBuffer->pucBuffer, FS_INFO_OFFSET_SIGNATURE1_000 );
ulSignature2 = FF_getLong( pxBuffer->pucBuffer, FS_INFO_OFFSET_SIGNATURE2_484 );
if( ( ulSignature1 == FS_INFO_SIGNATURE1_0x41615252 ) &&
( ulSignature2 == FS_INFO_SIGNATURE2_0x61417272 ) )
{
/* FSINFO sector magic numbers we're verified. Safe to write. */
FF_putLong( pxBuffer->pucBuffer, FS_INFO_OFFSET_FREE_COUNT_488, pxIOManager->xPartition.ulFreeClusterCount );
FF_putLong( pxBuffer->pucBuffer, FS_INFO_OFFSET_FREE_CLUSTER_492, pxIOManager->xPartition.ulLastFreeCluster );
}
xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
}
}
}
#endif
}
while( pdFALSE );
return xError;
} /* FF_IncreaseFreeClusters() */
/*-----------------------------------------------------------*/
FF_Error_t FF_DecreaseFreeClusters( FF_IOManager_t *pxIOManager, uint32_t Count )
{
FF_Error_t xError = FF_ERR_NONE;
#if( ffconfigWRITE_FREE_COUNT != 0 )
FF_Buffer_t *pxBuffer;
#endif
if( pxIOManager->xPartition.ulFreeClusterCount == 0ul )
{
pxIOManager->xPartition.ulFreeClusterCount = FF_CountFreeClusters( pxIOManager, &xError );
}
else
{
taskENTER_CRITICAL();
pxIOManager->xPartition.ulFreeClusterCount -= Count;
taskEXIT_CRITICAL();
}
if( FF_isERR( xError ) == pdFALSE )
{
if( pxIOManager->xPartition.ulLastFreeCluster == 0 )
{
FF_LockFAT( pxIOManager );
{
pxIOManager->xPartition.ulLastFreeCluster = FF_FindFreeCluster( pxIOManager, &xError, pdFALSE );
}
FF_UnlockFAT( pxIOManager );
}
}
if( FF_isERR( xError ) == pdFALSE )
{
#if( ffconfigWRITE_FREE_COUNT != 0 )
{
/* FAT32 update the FSINFO sector. */
if( pxIOManager->xPartition.ucType == FF_T_FAT32 )
{
/* Find the FSINFO sector. */
pxBuffer = FF_GetBuffer( pxIOManager, pxIOManager->xPartition.ulFSInfoLBA, FF_MODE_WRITE );
if( pxBuffer == NULL )
{
xError = FF_ERR_DEVICE_DRIVER_FAILED | FF_DECREASEFREECLUSTERS;
}
else
{
if( ( FF_getLong( pxBuffer->pucBuffer, FS_INFO_OFFSET_SIGNATURE1_000 ) == FS_INFO_SIGNATURE1_0x41615252 ) &&
( FF_getLong( pxBuffer->pucBuffer, FS_INFO_OFFSET_SIGNATURE2_484 ) == FS_INFO_SIGNATURE2_0x61417272 ) )
{
/* FSINFO sector magic nums we're verified. Safe to write. */
FF_putLong( pxBuffer->pucBuffer, FS_INFO_OFFSET_FREE_COUNT_488, pxIOManager->xPartition.ulFreeClusterCount );
FF_putLong( pxBuffer->pucBuffer, FS_INFO_OFFSET_FREE_CLUSTER_492, pxIOManager->xPartition.ulLastFreeCluster );
}
xError = FF_ReleaseBuffer( pxIOManager, pxBuffer );
}
}
}
#endif
}
return xError;
} /* FF_DecreaseFreeClusters() */
/*-----------------------------------------------------------*/
/**
* @brief Returns the Block-size of a mounted Partition
*
* The purpose of this function is to provide API access to information
* that might be useful in special cases. Like USB sticks that require a sector
* knocking sequence for security. After the sector knock, some secure USB
* sticks then present a different BlockSize.
*
* @param pxIOManager FF_IOManager_t Object returned from FF_CreateIOManger()
*
* @Return The blocksize of the partition. A value less than 0 when an error occurs.
* @Return Any negative value can be cast to the FF_Error_t type.
**/
int32_t FF_GetPartitionBlockSize( FF_IOManager_t *pxIOManager )
{
int32_t lReturn;
if( pxIOManager )
{
lReturn = ( int32_t ) pxIOManager->xPartition.usBlkSize;
}
else
{
lReturn = FF_ERR_NULL_POINTER | FF_GETPARTITIONBLOCKSIZE;
}
return lReturn;
} /* FF_GetPartitionBlockSize() */
/*-----------------------------------------------------------*/
#if( ffconfig64_NUM_SUPPORT != 0 )
/**
* @brief Returns the number of bytes contained within the mounted partition or volume.
*
* @param pxIOManager FF_IOManager_t Object returned from FF_CreateIOManger()
*
* @Return The total number of bytes that the mounted partition or volume contains.
*
**/
uint64_t FF_GetVolumeSize( FF_IOManager_t *pxIOManager )
{
uint64_t ullResult;
if( pxIOManager )
{
uint32_t TotalClusters = ( pxIOManager->xPartition.ulDataSectors / pxIOManager->xPartition.ulSectorsPerCluster );
ullResult = ( uint64_t )
(
( uint64_t ) TotalClusters * ( uint64_t )
( ( uint64_t ) pxIOManager->xPartition.ulSectorsPerCluster * ( uint64_t ) pxIOManager->xPartition.usBlkSize )
);
}
else
{
ullResult = 0ULL;
}
return ullResult;
} /* FF_GetVolumeSize() */
#else
uint32_t FF_GetVolumeSize( FF_IOManager_t *pxIOManager )
{
uint32_t ulResult;
if( pxIOManager )
{
uint32_t TotalClusters = pxIOManager->xPartition.ulDataSectors / pxIOManager->xPartition.ulSectorsPerCluster;
ulResult = ( uint32_t ) ( TotalClusters * ( pxIOManager->xPartition.ulSectorsPerCluster * pxIOManager->xPartition.usBlkSize ) );
}
else
{
ulResult = 0UL;
}
return ulResult;
} /* FF_GetVolumeSize() */
#endif
/*-----------------------------------------------------------*/