fs.h

Latest ucFS v.3.10d PC Windows Evaluation Ed., provided with free Flash driver

/*********************************************************************
*
*       FS_GetNumFilesOpen
*/
int      FS_GetNumFilesOpen(void);


/*********************************************************************
*
*       File system directory functions
*/
int  FS_CreateDir    (const char * sDirPath);
int  FS_MkDir        (const char * pDirName);
int  FS_RmDir        (const char * pDirName);
char FS_FindFirstFile(FS_FIND_DATA * pfd, const char * sPath, char * sFilename, int sizeofFilename);
char FS_FindNextFile (FS_FIND_DATA * pfd);
void FS_FindClose    (FS_FIND_DATA * pfd);

/*********************************************************************
*
*       Olsolete directory functions
*/

void     FS_DirEnt2Attr   (FS_DIRENT  * pDirEnt, U8   * pAttr);
void     FS_DirEnt2Name   (FS_DIRENT  * pDirEnt, char * pBuffer);
U32      FS_DirEnt2Size   (FS_DIRENT  * pDirEnt);
U32      FS_DirEnt2Time   (FS_DIRENT  * pDirEnt);
U32      FS_GetNumFiles   (FS_DIR     * pDir);

FS_DIR    * FS_OpenDir    (const char * pDirName);
int         FS_CloseDir   (FS_DIR     * pDir);
FS_DIRENT * FS_ReadDir    (FS_DIR     * pDir);
void        FS_RewindDir  (FS_DIR     * pDir);

/*********************************************************************
*
*       File system standard application
*/
void FSTask(void);

/*********************************************************************
*
*       File system control functions
*/
void     FS_Init          (void);

/*********************************************************************
*
*       Formatting
*/
int              FS_FormatLLIfRequired(const char * sVolumeName);
int              FS_FormatLow         (const char * sVolumeName);
int              FS_Format            (const char * sVolumeName, FS_FORMAT_INFO * pFormatInfo);
int              FS_FormatSD          (const char * sVolumeName);

/*********************************************************************
*
*       CheckDisk functionality
*/
const char * FS_CheckDisk_ErrCode2Text(int ErrCode);
int          FS_CheckDisk(const char * sVolumeName, void * pBuffer, U32 BufferSize, int MaxRecursionLevel, FS_QUERY_F_TYPE * pfOnError);

/*********************************************************************
*
*       CheckDisk macro replacement for
*/
#define FS_EFS_CheckDisk(sVolumeName, pBuffer, BufferSize, MaxRecursionLevel, pfOnError)  FS_CheckDisk(sVolumeName, pBuffer, BufferSize, MaxRecursionLevel, pfOnError)
#define FS_FAT_CheckDisk(sVolumeName, pBuffer, BufferSize, MaxRecursionLevel, pfOnError)  FS_CheckDisk(sVolumeName, pBuffer, BufferSize, MaxRecursionLevel, pfOnError)
#define FS_EFS_CheckDisk_ErrCode2Text(ErrCode)                                            FS_CheckDisk_ErrCode2Text(ErrCode)
#define FS_FAT_CheckDisk_ErrCode2Text(ErrCode)                                            FS_CheckDisk_ErrCode2Text(ErrCode)


/*********************************************************************
*
*       Journaling / transaction safety
*/
void FS_BeginTransaction(const char *sVolume);
void FS_EndTransaction  (const char *sVolume);

/*********************************************************************
*
*       Configuration functions.
*/
void FS_FAT_SupportLFN(void);
void FS_SetMaxSectorSize(unsigned MaxSectorSize);

/*********************************************************************
*
*       Space information functions
*/
U32           FS_GetFreeSpace (const char *pDevName);
U32           FS_GetTotalSpace(const char *pDevName);


/*********************************************************************
*
*       BusyLED support
*/
void FS_SetBusyLEDCallback(const char * sVolumeName, FS_BUSY_LED_CALLBACK * pfBusyLEDCallback);


/*********************************************************************
*
*       Memory accessible support
*/
void FS_SetMemAccessCallback(const char * sVolumeName, FS_MEMORY_IS_ACCESSIBLE_CALLBACK * pfIsAccessibleCallback);

/*********************************************************************
*
*       Device Drivers
*
*/
struct FS_DEVICE_TYPE {      // Note: This definition is really intern and should be in "FS_Int.h". In order to avoid problems with old compilers, keep it here.
  const char *      (*pfGetName)      (U8 Unit);
  int               (*pfAddDevice)    (void);                                                       // Called from AddDevice. Usually the first call to the driver
  int               (*pfRead)         (U8 Unit, U32 SectorNo,       void *pBuffer, U32 NumSectors);
  int               (*pfWrite)        (U8 Unit, U32 SectorNo, const void *pBuffer, U32 NumSectors, U8 RepeatSame);
  int               (*pfIoCtl)        (U8 Unit, I32 Cmd, I32 Aux, void *pBuffer);
  int               (*pfInitMedium)   (U8 Unit);                                                       // Called when formatting or mounting a device
  int               (*pfGetStatus)    (U8 Unit);
  int               (*pfGetNumUnits)  (void);
};

extern const FS_DEVICE_TYPE    FS_RAMDISK_Driver;       /* RAMDISK_DRIVER function table */
extern const FS_DEVICE_TYPE    FS_WINDRIVE_Driver;      /* WINDRIVE_DRIVER function table */
extern const FS_DEVICE_TYPE    FS_SMC_Driver;           /* SMC_DRIVER function table */
extern const FS_DEVICE_TYPE    FS_MMC_CardMode_Driver;  /* MMC_DRIVER SPI function table */
extern const FS_DEVICE_TYPE    FS_MMC_SPI_Driver;       /* MMC_DRIVER CardMode function table */
extern const FS_DEVICE_TYPE    FS_IDE_Driver;           /* IDE_CF_DRIVER function table */
extern const FS_DEVICE_TYPE    FS_NOR_Driver;           /* NOR flash driver function table */
extern const FS_DEVICE_TYPE    FS_DATAFLASH_Driver;        /* Atmel DataFlash driver function table */
extern const FS_DEVICE_TYPE    FS_GENERIC_Driver;       /* GENERIC_DRIVER function table */
extern const FS_DEVICE_TYPE    FS_NAND_Driver;          /* Nand driver function table */

/*********************************************************************
*
*       NOR driver
*/
typedef struct {
  U32 Off;
  U32 Size;
  U32 EraseCnt;
  U16 NumUsedSectors;
  U16 NumFreeSectors;
  U16 NumEraseableSectors;
} FS_NOR_SECTOR_INFO;

typedef struct {
  U32 NumPhysSectors;
  U32 NumLogSectors;
  U32 NumUsedSectors;   /* Number of used logical sectors */
} FS_NOR_DISK_INFO;

typedef struct FS_NOR_PHY_TYPE {
  int  (*pfWriteOff)         (U8 Unit, U32 Off, const void * pSrc, U32 Len);
  int  (*pfReadOff)          (U8 Unit, void * pDest, U32 Off, U32 Len);
  int  (*pfEraseSector)      (U8 Unit, unsigned int SectorIndex);
  void (*pfGetSectorInfo)    (U8 Unit, unsigned int SectorIndex, U32 * pOff, U32 * pLen);
  int  (*pfGetNumSectors)    (U8 Unit);
  void (*pfConfigure)        (U8 Unit, U32 BaseAddr, U32 StartAddr, U32 NumBytes);
  void (*pfOnSelectPhy)      (U8 Unit);
} FS_NOR_PHY_TYPE;

extern const FS_NOR_PHY_TYPE FS_NOR_PHY_CFI_1x16;            // 1 x 16-bit CFI compliant NOR flash
extern const FS_NOR_PHY_TYPE FS_NOR_PHY_CFI_2x16;            // 2 x 16-bit CFI compliant NOR flash


void FS_NOR_GetDiskInfo     (U8 Unit, FS_NOR_DISK_INFO * pDiskInfo);
void FS_NOR_GetSectorInfo   (U8 Unit, U32 PhysSectorIndex, FS_NOR_SECTOR_INFO * pSectorInfo);
void FS_NOR_Configure       (U8 Unit, U32 BaseAddr, U32 StartAddr, U32 NumBytes);
void FS_NOR_ConfigureReserve(U8 Unit, U8 Percentage2Reserve);
void FS_NOR_SetPhyType      (U8 Unit, const FS_NOR_PHY_TYPE * pPhyType);

/*********************************************************************
*
*       RAMDISK driver
*/
void FS_RAMDISK_Configure(U8 Unit, void * pData, U16 BytesPerSector, U32 NumSectors);

/*********************************************************************
*
*       MMC/SD driver
*/
typedef struct {
  U8 aData[16];
} MMC_CARD_ID;

void FS_MMC_ActivateCRC(void);
void FS_MMC_DeactivateCRC(void);
int  FS_MMC_GetCardId(U8 Unit, MMC_CARD_ID * pCardId);

/*********************************************************************
*
*       IDE/CF driver
*/
void FS_IDE_Configure(U8 Unit, U8 IsSlave);

/*********************************************************************
*
*       NAND driver
*/

typedef struct {
  U16          brsi;              // Block relative sector index.
  U32          ECC;               // Ecc stored for this sector.
  U8           IsValid;           // Sector contains valid data.
} FS_NAND_SECTOR_INFO;

typedef struct {
  U32          EraseCnt;
  U32          lbi;
  U16          NumSectorsBlank;               // Sectors are not used yet.
  U16          NumSectorsValid;               // Sectors contain correct data.
  U16          NumSectorsInvalid;             // Sectors have been invalidated.
  U16          NumSectorsECCError;            // Sectors have incorrect ECC.
  U16          NumSectorsECCCorrectable;      // Sectors have correctable ECC error.
  const char * sType;
} FS_NAND_BLOCK_INFO;

typedef struct {
  U32 NumPhyBlocks;
  U32 NumLogBlocks;
  U32 NumUsedPhyBlocks;
  U32 NumBadPhyBlocks;
  U32 NumPagesPerBlock;
  U32 NumSectorsPerBlock;
  U32 BytesPerPage;
  U32 BytesPerSector;
} FS_NAND_DISK_INFO;

typedef struct FS_NAND_DEVICE_INFO {
  U8  BPP_Shift;              // Bytes per Page shift: 9 for 512 bytes/page or 11 for 2048 bytes/page
  U8  PPB_Shift;              // Pages per block shift: 32 -> 5, 64 -> 6
  U16 NumBlocks;              // Number of Blocks in device
} FS_NAND_DEVICE_INFO;

typedef struct FS_NAND_PHY_TYPE {
  int    (*pfEraseBlock)    (U8 Unit, U32 Block);
  int    (*pfInitGetDeviceInfo) (U8 Unit, FS_NAND_DEVICE_INFO * pDevInfo);
  int    (*pfIsWP)          (U8 Unit);
  int    (*pfRead)          (U8 Unit, U32 PageNo,       void * pData, unsigned Off, unsigned NumBytes);
  int    (*pfReadEx)        (U8 Unit, U32 PageNo,       void * pData, unsigned Off, unsigned NumBytes, void * pSpare, unsigned OffSpare, unsigned NumBytesSpare);
  int    (*pfWrite)         (U8 Unit, U32 PageNo, const void * pData, unsigned Off, unsigned NumBytes);
  int    (*pfWriteEx)       (U8 Unit, U32 PageNo, const void * pData, unsigned Off, unsigned NumBytes, const void* pSpare, unsigned OffSpare, unsigned NumBytesSpare);
} FS_NAND_PHY_TYPE;


extern const FS_NAND_PHY_TYPE FS_NAND_PHY_x;                        // 512 or 2048 byte pages,  8-bit or 16-bit interface
extern const FS_NAND_PHY_TYPE FS_NAND_PHY_x8;                       // 512 or 2048 byte pages,  8-bit interface
extern const FS_NAND_PHY_TYPE FS_NAND_PHY_x16;                      // 512 or 2048 byte pages, 16-bit interface
extern const FS_NAND_PHY_TYPE FS_NAND_PHY_512x8;                    // 512 byte pages,  8-bit interface
extern const FS_NAND_PHY_TYPE FS_NAND_PHY_512x16;                   // 512 byte pages, 16-bit interface
extern const FS_NAND_PHY_TYPE FS_NAND_PHY_2048x8;                   // 2048 byte pages,  8-bit interface
extern const FS_NAND_PHY_TYPE FS_NAND_PHY_2048x16;                  // 2048 byte pages,  16-bit interface
extern const FS_NAND_PHY_TYPE FS_NAND_PHY_DataFlash;                // Physical layer for Atmel serial DATAFLASH

void FS_NAND_ResetStatCounters(U8 Unit);
void FS_NAND_SetPhyType       (U8 Unit, const FS_NAND_PHY_TYPE * pPhyType);
void FS_NAND_SetBlockRange    (U8 Unit, U16 FirstBlock, U16 MaxNumBlocks);
void FS_NAND_GetDiskInfo      (U8 Unit, FS_NAND_DISK_INFO * pDiskInfo);
void FS_NAND_GetBlockInfo     (U8 Unit, U32 PhysBlockIndex, FS_NAND_BLOCK_INFO * pBlockInfo);
void FS_NAND_GetSectorInfo    (U8 Unit, U32 PhysSectorIndex, FS_NAND_SECTOR_INFO * pBlockInfo);

/*********************************************************************
*
*       WinDrive driver
*/
void WINDRIVE_Configure(U8 Unit, const char * sWindowsDriveName);



/*********************************************************************
*
*       Cache handling
*/
#if FS_SUPPORT_CACHE

/*********************************************************************
*
*       General Cache mode defines, do not use in application
*/
#define FS_CACHE_MODE_R         0x01
#define FS_CACHE_MODE_W         0x02
#define FS_CACHE_MODE_D         0x04
// Obsolete Cache mode define, do not use
#define FS_CACHE_MODE_FULL      (FS_CACHE_MODE_R | FS_CACHE_MODE_W | FS_CACHE_MODE_D)

/*********************************************************************
*
*       Cache mode defines that can be used in application
*/
#define FS_CACHE_MODE_WT        (FS_CACHE_MODE_R | FS_CACHE_MODE_W)
#define FS_CACHE_MODE_WB        (FS_CACHE_MODE_R | FS_CACHE_MODE_W | FS_CACHE_MODE_D)

/*********************************************************************
*
*       Cache specific defines
*/
#define FS_CACHE_NONE      NULL
#define FS_CACHE_MAN       FS_CacheMan_Init
#define FS_CACHE_RW        FS_CacheRW_Init
#define FS_CACHE_RW_QUOTA  FS_CacheRWQuota_Init
#define FS_CACHE_ALL       FS_CacheAll_Init
#define FS_CACHEALL_API    FS_CacheAll_Init    /* For compatibility with older version */
#define FS_CACHEMAN_API    FS_CacheMan_Init    /* For compatibility with older version */
/*********************************************************************
*
*       Cache specific types
*/
typedef U32 FS_INIT_CACHE (FS_DEVICE * pDevice, void * pData,   I32 NumBytes);

/*********************************************************************
*
*       Cache specific prototypes
*/
U32    FS_AssignCache   (const char * pName, void * pData, I32 NumBytes, FS_INIT_CACHE * pfInit);
void   FS_CACHE_Clean   (const char * pName);
int    FS_CACHE_Command (const char * pName, int Cmd,      void * pData);
int    FS_CACHE_SetMode (const char * pName, int TypeMask, int    ModeMask);
int    FS_CACHE_SetQuota(const char * pName, int TypeMask, U32    NumSectors);

/*********************************************************************
*
*       Cache initialization prototypes
*/
U32 FS_CacheAll_Init    (FS_DEVICE * pDev, void * pData, I32 NumBytes);
U32 FS_CacheMan_Init    (FS_DEVICE * pDev, void * pData, I32 NumBytes);
U32 FS_CacheRW_Init     (FS_DEVICE * pDev, void * pData, I32 NumBytes);
U32 FS_CacheRWQuota_Init(FS_DEVICE * pDev, void * pData, I32 NumBytes);

#endif


/*********************************************************************
*
*       Memory allocation functions
*/
void * FS_Alloc      (I32 NumBytes);
void * FS_AllocZeroed(I32 NumBytes);
void * FS_Free       (void * p);
void   FS_AllocZeroedPtr(void ** pp, I32 NumBytes);

/*********************************************************************
*
*       Logical driver config
*/
int FS_AddPhysDevice   (const FS_DEVICE_TYPE * pDevType);
int FS_LOGVOL_Create   (const char * sVolName);
int FS_LOGVOL_AddDevice(const char * sLogVolName, const FS_DEVICE_TYPE * pDevice, U8 Unit, U32 StartOff, U32 NumSectors);


/*********************************************************************
*
*       Debug support
*/
void   FS_X_Log     (const char *s);
void   FS_X_Warn    (const char *s);
void   FS_X_ErrorOut(const char *s);


/*********************************************************************
*
*       Application supplied functions FS_X_...
*/
void * FS_X_Alloc(U32 NumBytes);
void   FS_X_Free(void * p);
void   FS_X_Panic(int ErrorCode);
void   FS_X_AddDevices(void);
U32    FS_X_GetTimeDate(void);


#if defined(__cplusplus)
  }              /* Make sure we have C-declarations in C++ programs */
#endif

#endif                        // Avoid recursive and multiple inclusion

/*************************** End of file ****************************/