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        ///< 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_DIR             0x80        ///< Special Mode to open a Dir. (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!)

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    ///< Lock bit mask for FAT table locking.
#define FF_DIR_LOCK         0x02    ///< Lock bit mask for DIR modification locking.
//#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    ///< Flags the pBlkDevice pointer is allocated.
#define FF_IOMAN_ALLOC_PART     0x02    ///< Flags the pPartition pointer is allocated.
#define FF_IOMAN_ALLOC_BUFDESCR 0x04    ///< Flags the pBuffers pointer is allocated.
#define FF_IOMAN_ALLOC_BUFFERS  0x08    ///< Flags the pCacheMem pointer is allocated.
#define FF_IOMAN_ALLOC_RESERVED 0xF0    ///< Reserved Section.


//---------- 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