len0rd/FreeRTOS-Kernel
1
0
Fork 0
mirror of https://github.com/FreeRTOS/FreeRTOS-Kernel.git synced 2025-09-07 14:47:42 -04:00
Code Issues Projects Releases Packages Wiki Activity

Add the Labs projects provided in the V10.2.1_191129 zip file.

Browse source
This commit is contained in:
Richard Barry 2019-12-02 23:39:25 +00:00
parent 46e5937529
commit e5708b38e9
801 changed files with 356576 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

383
FreeRTOS-Labs/Source/FreeRTOS-Plus-FAT/include/ff_ioman.h Normal file
View file

@ -0,0 +1,383 @@
/*
* 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.h
* @ingroup IOMAN
**/
#ifndef _FF_IOMAN_H_
#define _FF_IOMAN_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <stdlib.h> /* Use of malloc() */
#ifndef PLUS_FAT_H
#error this header will be included from "plusfat.h"
#endif
#define FF_T_FAT12 0x0A
#define FF_T_FAT16 0x0B
#define FF_T_FAT32 0x0C
#define FF_MODE_READ 0x01 /* Buffer / FILE Mode for Read Access. */
#define FF_MODE_WRITE 0x02 /* Buffer / FILE Mode for Write Access. */
#define FF_MODE_APPEND 0x04 /* FILE Mode Append Access. */
#define FF_MODE_CREATE 0x08 /* FILE Mode Create file if not existing. */
#define FF_MODE_TRUNCATE 0x10 /* FILE Mode Truncate an Existing file. */
#define FF_MODE_VIRGIN 0x40 /* Buffer mode: do not fetch content from disk. Used for write-only buffers. */
#define FF_MODE_DIR 0x80 /* Special Mode to open a Dir. (Internal use ONLY!) */
#define FF_MODE_RD_WR ( FF_MODE_READ | FF_MODE_WRITE ) /* Just for bit filtering. */
/* The buffer write-only mode saves a fetch from disk.
The write-only mode is used when a buffer is needed just
for clearing sectors. */
#define FF_MODE_WR_ONLY ( FF_MODE_VIRGIN | FF_MODE_WRITE ) /* Buffer for Write-only Access (Internal use ONLY!) */
#define FF_BUF_MAX_HANDLES 0xFFFF /* Maximum number handles sharing a buffer. (16 bit integer, we don't want to overflow it!) */
#define FF_MAX_ENTRIES_PER_DIRECTORY 0xFFFF
#define FF_SIZEOF_SECTOR 512
#define FF_SIZEOF_DIRECTORY_ENTRY 32
#ifndef pdTRUE_SIGNED
/* Temporary solution: eventually the defines below will appear
in 'Source\include\projdefs.h' */
#define pdTRUE_SIGNED pdTRUE
#define pdFALSE_SIGNED pdFALSE
#define pdTRUE_UNSIGNED ( ( UBaseType_t ) 1u )
#define pdFALSE_UNSIGNED ( ( UBaseType_t ) 0u )
#endif
/**
* I/O Driver Definitions
* Provide access to any Block Device via the following interfaces.
* Returns the number of blocks actually read or written.
**/
/**
* A special information structure for the FreeRTOS+FAT mass storage device
* driver model.
**/
typedef struct
{
uint16_t BlkSize;
uint32_t TotalBlocks;
} FF_DeviceInfo_t;
#if( ffconfigHASH_CACHE != 0 )
#define FF_HASH_TABLE_ENTRY_COUNT ( ( ffconfigHASH_TABLE_SIZE + 3 ) / 4 )
struct xHASH_TABLE
{
uint32_t ulDirCluster; /* The Starting Cluster of the dir that the hash represents. */
uint32_t ulNumHandles; /* Number of active Handles using this hash table. */
uint32_t ulMisses; /* Number of times this Hash Table was missed, (i.e. how redundant it is). */
uint32_t ulBitTable[ FF_HASH_TABLE_ENTRY_COUNT ];
};
typedef struct xHASH_TABLE FF_HashTable_t;
void FF_ClearHash( FF_HashTable_t *pxHash, uint32_t ulHash );
void FF_SetHash( FF_HashTable_t *pxHash, uint32_t ulHash );
BaseType_t FF_isHashSet( FF_HashTable_t *pxHash, uint32_t ulHash );
#endif /* ffconfigHASH_CACHE */
/* A forward declaration for the I/O manager, to be used in 'struct xFFDisk'. */
struct _FF_IOMAN;
struct xFFDisk;
typedef void ( *FF_FlushApplicationHook )( struct xFFDisk *pxDisk );
/*
* Some low-level drivers also need to flush data to a device.
* Use an Application hook that will be called every time when
* FF_FlushCache() is called. The semaphore will still be taken
* to avoid unwanted reentrancy.
* For example:
*
* void FTL_FlushData( struct xFFDisk *pxDisk )
* {
* // You may or may not inspect 'pxDisk'
* FTL_FlushTableCache();
* }
*
* Make sure you bind the function to the disc object, right after creation:
*
* pxDisk->fnFlushApplicationHook = FTL_FlushData;
*/
/* Structure that contains fields common to all media drivers, and can be
extended to contain additional fields to tailor it for use with a specific media
type. */
struct xFFDisk
{
struct
{
/* Flags that can optionally be used by the media driver to ensure the
disk has been initialised, registered and mounted before it is accessed. */
uint32_t bIsInitialised : 1;
uint32_t bIsMounted : 1;
uint32_t spare0 : 5;
/* The partition number on the media described by this structure. */
uint32_t bPartitionNumber : 8;
uint32_t spare1 : 16;
} xStatus;
/* Provided to allow this structure to be extended to include additional
attributes that are specific to a media type. */
void * pvTag;
/* Points to input and output manager used by the disk described by this
structure. */
struct _FF_IOMAN *pxIOManager;
/* The number of sectors on the disk. */
uint32_t ulNumberOfSectors;
/* See comments here above. */
FF_FlushApplicationHook fnFlushApplicationHook;
/* Field that can optionally be set to a signature that is unique to the
media. Read and write functions can check the ulSignature field to validate
the media type before they attempt to access the pvTag field, or perform any
read and write operations. */
uint32_t ulSignature;
};
typedef struct xFFDisk FF_Disk_t;
typedef int32_t ( *FF_WriteBlocks_t ) ( uint8_t *pucBuffer, uint32_t ulSectorAddress, uint32_t ulCount, FF_Disk_t *pxDisk );
typedef int32_t ( *FF_ReadBlocks_t ) ( uint8_t *pucBuffer, uint32_t ulSectorAddress, uint32_t ulCount, FF_Disk_t *pxDisk );
/**
* @public
* @brief Describes the block device driver interface to FreeRTOS+FAT.
**/
typedef struct
{
FF_WriteBlocks_t fnpWriteBlocks; /* Function Pointer, to write a block(s) from a block device. */
FF_ReadBlocks_t fnpReadBlocks; /* Function Pointer, to read a block(s) from a block device. */
FF_Disk_t *pxDisk; /* Earlier called 'pParam': pointer to some parameters e.g. for a Low-Level Driver Handle. */
} FF_BlockDevice_t;
/**
* @private
* @brief FreeRTOS+FAT handles memory with buffers, described as below.
* @note This may change throughout development.
**/
typedef struct
{
uint32_t ulSector; /* The LBA of the Cached sector. */
uint32_t ulLRU; /* For the Least Recently Used algorithm. */
uint8_t *pucBuffer; /* Pointer to the cache block. */
uint32_t ucMode : 8, /* Read or Write mode. */
bModified : 1, /* If the sector was modified since read. */
bValid : 1; /* Initially FALSE. */
uint16_t usNumHandles; /* Number of objects using this buffer. */
uint16_t usPersistance; /* For the persistance algorithm. */
} FF_Buffer_t;
typedef struct
{
#if( ffconfigUNICODE_UTF16_SUPPORT != 0 )
FF_T_WCHAR pcPath[ ffconfigMAX_FILENAME ];
#else
char pcPath[ ffconfigMAX_FILENAME ];
#endif
uint32_t ulDirCluster;
} FF_PathCache_t;
/**
* @private
* @brief FreeRTOS+FAT identifies a partition with the following data.
* @note This may shrink as development and optimisation goes on.
**/
typedef struct
{
uint32_t ulBeginLBA; /* LBA start address of the partition. */
uint32_t ulFATBeginLBA; /* LBA of the FAT tables. */
uint32_t ulSectorsPerFAT; /* Number of sectors per Fat. */
uint32_t ulTotalSectors;
uint32_t ulDataSectors;
#if( ffconfigWRITE_FREE_COUNT != 0 )
uint32_t ulFSInfoLBA; /* LBA of the FSINFO sector. */
#endif
uint32_t ulRootDirSectors;
uint32_t ulFirstDataSector;
uint32_t ulClusterBeginLBA; /* LBA of first cluster. */
uint32_t ulNumClusters; /* Number of clusters. */
uint32_t ulRootDirCluster; /* Cluster number of the root directory entry. */
uint32_t ulLastFreeCluster;
uint32_t ulFreeClusterCount; /* Records free space on mount. */
uint32_t ulSectorsPerCluster;/* Number of sectors per Cluster. */
char pcVolumeLabel[ 12 ];/* Volume Label of the partition. */
uint16_t usBlkSize; /* Size of a Sector Block in bytes. */
uint16_t usReservedSectors;
uint8_t ucType; /* Partition Type Identifier. */
uint8_t ucBlkFactor; /* Scale Factor for block sizes above 512! */
uint8_t ucNumFATS; /* Number of FAT tables. */
uint8_t ucPartitionMounted; /* pdTRUE if the partition is mounted, otherwise pdFALSE. */
#if( ffconfigPATH_CACHE != 0 )
FF_PathCache_t pxPathCache[ffconfigPATH_CACHE_DEPTH];
uint32_t ulPCIndex;
#endif
} FF_Partition_t;
/**
* @public
* @brief FF_IOManager_t Object description.
*
* FreeRTOS+FAT functions around an object like this.
**/
#define FF_FAT_LOCK 0x01 /* Lock bit mask for FAT table locking. */
#define FF_DIR_LOCK 0x02 /* Lock bit mask for DIR modification locking. */
#define FF_BUF_LOCK 0x04 /* Lock bit mask for buffers. */
/**
* @public
* @brief FF_IOManager_t Object. A developer should not touch these values.
*
**/
typedef struct _FF_IOMAN
{
FF_BlockDevice_t xBlkDevice; /* Pointer to a Block device description. */
FF_Partition_t xPartition; /* A partition description. */
FF_Buffer_t *pxBuffers; /* Pointer to an array of buffer descriptors. */
void *pvSemaphore; /* Pointer to a Semaphore object. (For buffer description modifications only!). */
void *FirstFile; /* Pointer to the first File object. */
void *xEventGroup; /* An event group, used for locking FAT, DIR and Buffers. Replaces ucLocks. */
uint8_t *pucCacheMem; /* Pointer to a block of memory for the cache. */
uint16_t usSectorSize; /* The sector size that IOMAN is configured to. */
uint16_t usCacheSize; /* Size of the cache in number of Sectors. */
uint8_t ucPreventFlush; /* Flushing to disk only allowed when 0. */
uint8_t ucFlags; /* Bit-Mask: identifying allocated pointers and other flags */
#if( ffconfigHASH_CACHE != 0 )
FF_HashTable_t xHashCache[ ffconfigHASH_CACHE_DEPTH ];
#endif
void *pvFATLockHandle;
} FF_IOManager_t;
/* Bit values for 'FF_IOManager_t::ucFlags': */
/* Memory Allocation testing and other flags. */
#define FF_IOMAN_ALLOC_BUFDESCR 0x01 /* Flags the pxBuffers pointer is allocated. */
#define FF_IOMAN_ALLOC_BUFFERS 0x02 /* Flags the pucCacheMem pointer is allocated. */
#define FF_IOMAN_BLOCK_DEVICE_IS_REENTRANT 0x10 /* When true, ffRead/ffWrite are not protected by a semaphore. */
#if( ffconfigREMOVABLE_MEDIA != 0 )
#define FF_IOMAN_DEVICE_IS_EXTRACTED 0x20
#endif /* ffconfigREMOVABLE_MEDIA */
typedef struct xFF_CREATION_PARAMETERS
{
uint8_t *pucCacheMemory; /* User provided memory, or use NULL to malloc the cache memory. */
uint32_t ulMemorySize; /* Size of the cache memory, must be a multiple of 'ulSectorSize'. */
BaseType_t ulSectorSize; /* Sector size, unit for reading/writing to the disk, normally 512 bytes. */
FF_WriteBlocks_t fnWriteBlocks; /* A function to write sectors to the device. */
FF_ReadBlocks_t fnReadBlocks; /* A function to read sectors from the device. */
FF_Disk_t *pxDisk; /* Some properties of the disk driver. */
void *pvSemaphore; /* Pointer to a Semaphore object. */
BaseType_t xBlockDeviceIsReentrant; /* Make non-zero if ffRead/ffWrite are re-entrant. */
} FF_CreationParameters_t;
/*---------- PROTOTYPES (in order of appearance). */
/* PUBLIC (Interfaces): */
FF_IOManager_t *FF_CreateIOManger( FF_CreationParameters_t *pxParameters, FF_Error_t *pError );
FF_Error_t FF_DeleteIOManager( FF_IOManager_t *pxIOManager);
FF_Error_t FF_Mount( FF_Disk_t *pxDisk, BaseType_t xPartitionNumber );
FF_Error_t FF_Unmount( FF_Disk_t *pxDisk );
FF_Error_t FF_FlushCache( FF_IOManager_t *pxIOManager );
static portINLINE BaseType_t FF_Mounted( FF_IOManager_t *pxIOManager )
{
return pxIOManager && pxIOManager->xPartition.ucPartitionMounted;
}
int32_t FF_GetPartitionBlockSize(FF_IOManager_t *pxIOManager);
#if( ffconfig64_NUM_SUPPORT != 0 )
uint64_t FF_GetVolumeSize( FF_IOManager_t *pxIOManager );
#else
uint32_t FF_GetVolumeSize( FF_IOManager_t *pxIOManager );
#endif
/* PUBLIC (To FreeRTOS+FAT Only): */
int32_t FF_BlockRead( FF_IOManager_t *pxIOManager, uint32_t ulSectorLBA, uint32_t ulNumSectors, void *pBuffer, BaseType_t aSemLocked );
int32_t FF_BlockWrite( FF_IOManager_t *pxIOManager, uint32_t ulSectorLBA, uint32_t ulNumSectors, void *pBuffer, BaseType_t aSemLocked );
FF_Error_t FF_IncreaseFreeClusters( FF_IOManager_t *pxIOManager, uint32_t Count );
FF_Error_t FF_DecreaseFreeClusters( FF_IOManager_t *pxIOManager, uint32_t Count );
FF_Buffer_t *FF_GetBuffer( FF_IOManager_t *pxIOManager, uint32_t ulSector, uint8_t Mode );
FF_Error_t FF_ReleaseBuffer( FF_IOManager_t *pxIOManager, FF_Buffer_t *pBuffer );
/* 'Internal' to FreeRTOS+FAT. */
typedef struct _SPart
{
uint32_t ulStartLBA; /* FF_FAT_PTBL_LBA */
uint32_t ulSectorCount; /* FF_FAT_PTBL_SECT_COUNT */
uint32_t
ucActive : 8, /* FF_FAT_PTBL_ACTIVE */
ucPartitionID : 8, /* FF_FAT_PTBL_ID */
bIsExtended : 1;
} FF_Part_t;
typedef struct _SPartFound
{
int iCount;
FF_Part_t pxPartitions[ffconfigMAX_PARTITIONS];
} FF_SPartFound_t;
/* This function will parse the 4 entries in a partition table: */
void FF_ReadParts( uint8_t *pucBuffer, FF_Part_t *pxParts );
/* FF_PartitionCount() has now been replaced by FF_PartitionSearch()
* It will enumerate all valid partitions found
* If sector-0 happens to be a valid MBR, 1 partition will be returned
*/
FF_Error_t FF_PartitionSearch( FF_IOManager_t *pxIOManager, FF_SPartFound_t *pPartsFound );
/* HT : for debugging only. */
BaseType_t xIsFatSector( FF_IOManager_t *pxIOManager, uint32_t ulSectorNr );
BaseType_t xNeedLogging( FF_IOManager_t *pxIOManager );
BaseType_t xIsRootDirSector( FF_IOManager_t *pxIOManager, uint32_t ulSectorNr );
const char *pcSectorType( FF_IOManager_t *pxIOManager, uint32_t ulSectorNr );
/* Needed to make this public/private to be used in FF_Partition/FF_Format. */
void FF_IOMAN_InitBufferDescriptors( FF_IOManager_t *pxIOManager );
#ifdef __cplusplus
} /* extern "C" */
#endif
#endif