ff_ioman.h

Go to the documentation of this file.

/*****************************************************************************
 *  FullFAT - High Performance, Thread-Safe Embedded FAT File-System         *
 *  Copyright (C) 2009  James Walmsley (james@worm.me.uk)                    *
 *                                                                           *
 *  This program is free software: you can redistribute it and/or modify     *
 *  it under the terms of the GNU General Public License as published by     *
 *  the Free Software Foundation, either version 3 of the License, or        *
 *  (at your option) any later version.                                      *
 *                                                                           *
 *  This program is distributed in the hope that it will be useful,          *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of           *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the            *
 *  GNU General Public License for more details.                             *
 *                                                                           *
 *  You should have received a copy of the GNU General Public License        *
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.    *
 *                                                                           *
 *  IMPORTANT NOTICE:                                                        *
 *  =================                                                        *
 *  Alternative Licensing is available directly from the Copyright holder,   *
 *  (James Walmsley). For more information consult LICENSING.TXT to obtain   *
 *  a Commercial license.                                                    *
 *                                                                           *
 *  See RESTRICTIONS.TXT for extra restrictions on the use of FullFAT.       *
 *                                                                           *
 *  Removing the above notice is illegal and will invalidate this license.   *
 *****************************************************************************
 *  See http://worm.me.uk/fullfat for more information.                      *
 *  Or  http://fullfat.googlecode.com/ for latest releases and the wiki.     *
 *****************************************************************************/
 
#ifndef _FF_IOMAN_H_
#define _FF_IOMAN_H_
 
#include <stdlib.h>                         // Use of malloc()
#include "ff_error.h"
#include "ff_config.h"
#include "ff_types.h"
#include "ff_safety.h"                      // Provide thread-safety via semaphores.
#include "ff_memory.h"                      // Memory access routines for ENDIAN independence.
#include "ff_hash.h"
 
//#define   FF_MAX_PARTITION_NAME   5       ///< Partition name length.
 
#define FF_T_FAT12              0x0A
#define FF_T_FAT16              0x0B
#define FF_T_FAT32              0x0C
 
#define FF_MODE_READ            0x01        
#define FF_MODE_WRITE           0x02        
#define FF_MODE_APPEND          0x04        
#define FF_MODE_CREATE          0x08        
#define FF_MODE_TRUNCATE        0x10        
#define FF_MODE_DIR             0x80        
 
#define FF_BUF_MAX_HANDLES      0xFFFF      
 
typedef struct {
    FF_T_UINT16 BlkSize;
    FF_T_UINT32 TotalBlocks;
} FF_DEVICE_INFO;
 
typedef FF_T_SINT32 (*FF_WRITE_BLOCKS)  (FF_T_UINT8 *pBuffer, FF_T_UINT32 SectorAddress, FF_T_UINT32 Count, void *pParam);
typedef FF_T_SINT32 (*FF_READ_BLOCKS)   (FF_T_UINT8 *pBuffer, FF_T_UINT32 SectorAddress, FF_T_UINT32 Count, void *pParam);
 
#define FF_ERR_DRIVER_BUSY          -10
#define FF_ERR_DRIVER_FATAL_ERROR   -11
 
typedef struct {
    FF_WRITE_BLOCKS fnpWriteBlocks; 
    FF_READ_BLOCKS  fnpReadBlocks;  
    FF_T_UINT16     devBlkSize;     
    void            *pParam;        
} FF_BLK_DEVICE;
 
typedef struct {
    FF_T_UINT32     Sector;         
    FF_T_UINT32     LRU;            
    FF_T_UINT16     NumHandles;     
    FF_T_UINT16     Persistance;    
    FF_T_UINT8      Mode;           
    FF_T_BOOL       Modified;       
    FF_T_BOOL       Valid;          
    FF_T_UINT8      *pBuffer;       
} FF_BUFFER;
 
typedef struct {
#ifdef FF_UNICODE_SUPPORT
    FF_T_WCHAR  Path[FF_MAX_PATH];
#else
    FF_T_INT8   Path[FF_MAX_PATH];
#endif
    FF_T_UINT32 DirCluster;
} FF_PATHCACHE;
 
#ifdef FF_HASH_CACHE
typedef struct {
    FF_T_UINT32     ulDirCluster;   
    FF_HASH_TABLE   pHashTable;     
    FF_T_UINT32     ulNumHandles;   
    FF_T_UINT32     ulMisses;       
} FF_HASHCACHE;
#endif
 
typedef struct {
    //FF_T_UINT8        ID;                 ///< Partition Incremental ID number.
    FF_T_UINT8      Type;               
    FF_T_UINT16     BlkSize;            
    FF_T_UINT8      BlkFactor;          
    //FF_T_INT8     Name[FF_MAX_PARTITION_NAME];    ///< Partition Identifier e.g. c: sd0: etc.
    FF_T_INT8       VolLabel[12];       
    FF_T_UINT32     BeginLBA;           
    FF_T_UINT32     PartSize;           
    FF_T_UINT32     FatBeginLBA;        
    FF_T_UINT8      NumFATS;            
    FF_T_UINT32     SectorsPerFAT;      
    FF_T_UINT8      SectorsPerCluster;  
    FF_T_UINT32     TotalSectors;
    FF_T_UINT32     DataSectors;
    FF_T_UINT32     RootDirSectors;
    FF_T_UINT32     FirstDataSector;
    FF_T_UINT16     ReservedSectors;
    FF_T_UINT32     ClusterBeginLBA;    
    FF_T_UINT32     NumClusters;        
    FF_T_UINT32     RootDirCluster;     
    FF_T_UINT32     LastFreeCluster;
    FF_T_UINT32     FreeClusterCount;   
    FF_T_BOOL       PartitionMounted;   
#ifdef FF_PATH_CACHE
    FF_PATHCACHE    PathCache[FF_PATH_CACHE_DEPTH];
    FF_T_UINT32     PCIndex;
#endif
} FF_PARTITION;
 
 
 
#define FF_FAT_LOCK         0x01    
#define FF_DIR_LOCK         0x02    
//#define FF_PATHCACHE_LOCK 0x04
 
typedef struct {
    FF_BLK_DEVICE   *pBlkDevice;        
    FF_PARTITION    *pPartition;        
    FF_BUFFER       *pBuffers;          
    void            *pSemaphore;        
#ifdef FF_BLKDEV_USES_SEM
    void            *pBlkDevSemaphore;  
#endif
    void            *FirstFile;         
    FF_T_UINT8      *pCacheMem;         
    FF_T_UINT32     LastReplaced;       
    FF_T_UINT16     BlkSize;            
    FF_T_UINT16     CacheSize;          
    FF_T_UINT8      PreventFlush;       
    FF_T_UINT8      MemAllocation;      
    FF_T_UINT8      Locks;              
#ifdef FF_HASH_CACHE
    FF_HASHCACHE    HashCache[FF_HASH_CACHE_DEPTH];
#endif
} FF_IOMAN;
 
// Bit-Masks for Memory Allocation testing.
#define FF_IOMAN_ALLOC_BLKDEV   0x01    
#define FF_IOMAN_ALLOC_PART     0x02    
#define FF_IOMAN_ALLOC_BUFDESCR 0x04    
#define FF_IOMAN_ALLOC_BUFFERS  0x08    
#define FF_IOMAN_ALLOC_RESERVED 0xF0    
 
 
//---------- PROTOTYPES (in order of appearance)
 
// PUBLIC (Interfaces):
FF_IOMAN    *FF_CreateIOMAN         (FF_T_UINT8 *pCacheMem, FF_T_UINT32 Size, FF_T_UINT16 BlkSize, FF_ERROR *pError);
FF_ERROR    FF_DestroyIOMAN         (FF_IOMAN *pIoman);
FF_ERROR    FF_RegisterBlkDevice    (FF_IOMAN *pIoman, FF_T_UINT16 BlkSize, FF_WRITE_BLOCKS fnWriteBlocks, FF_READ_BLOCKS fnReadBlocks, void *pParam);
FF_ERROR    FF_UnregisterBlkDevice  (FF_IOMAN *pIoman);
FF_ERROR    FF_MountPartition       (FF_IOMAN *pIoman, FF_T_UINT8 PartitionNumber);
FF_ERROR    FF_UnmountPartition     (FF_IOMAN *pIoman);
FF_ERROR    FF_FlushCache           (FF_IOMAN *pIoman);
FF_T_SINT32 FF_GetPartitionBlockSize(FF_IOMAN *pIoman);
 
#ifdef FF_64_NUM_SUPPORT
FF_T_UINT64 FF_GetVolumeSize(FF_IOMAN *pIoman);
#else
FF_T_UINT32 FF_GetVolumeSize(FF_IOMAN *pIoman);
#endif
 
// PUBLIC  (To FullFAT Only):
FF_T_SINT32 FF_BlockRead            (FF_IOMAN *pIoman, FF_T_UINT32 ulSectorLBA, FF_T_UINT32 ulNumSectors, void *pBuffer);
FF_T_SINT32 FF_BlockWrite           (FF_IOMAN *pIoman, FF_T_UINT32 ulSectorLBA, FF_T_UINT32 ulNumSectors, void *pBuffer);
FF_ERROR    FF_IncreaseFreeClusters (FF_IOMAN *pIoman, FF_T_UINT32 Count);
FF_ERROR    FF_DecreaseFreeClusters (FF_IOMAN *pIoman, FF_T_UINT32 Count);
FF_BUFFER   *FF_GetBuffer           (FF_IOMAN *pIoman, FF_T_UINT32 Sector, FF_T_UINT8 Mode);
void        FF_ReleaseBuffer        (FF_IOMAN *pIoman, FF_BUFFER *pBuffer);
 
// PRIVATE (For this module only!):
 
 
#endif