fs.h

/*
 *   Copyright (C) 2016 Texas Instruments Incorporated
 *
 *   All rights reserved. Property of Texas Instruments Incorporated.
 *   Restricted rights to use, duplicate or disclose this code are
 *   granted through contract.
 *
 *   The program may not be used without the written permission of
 *   Texas Instruments Incorporated or against the terms and conditions
 *   stipulated in the agreement under which this program has been supplied,
 *   and under no circumstances can it be used with non-TI connectivity device.
 *   
 */


/*****************************************************************************/
/* Include files                                                             */
/*****************************************************************************/
#include <ti/drivers/net/wifi/simplelink.h>

#ifndef __FS_H__
#define __FS_H__



#ifdef __cplusplus
extern "C" {
#endif

/*****************************************************************************/
/* Macro declarations                                                        */
/*****************************************************************************/



/* Create file max size mode  */
#define SL_FS_OPEN_MODE_BIT_MASK   (0xF8000000)
#define SL_NUM_OF_MODE_BIT         (5)

#define SL_FS_OPEN_FLAGS_BIT_MASK  (0x07FE0000)
#define SL_NUM_OF_FLAGS_BIT        (10)

#define SL_FS_OPEN_MAXSIZE_BIT_MASK         (0x1FFFF)
#define SL_NUM_OF_MAXSIZE_BIT               (17)





/*****************************************************************************/
/* Structure/Enum declarations                                               */
/*****************************************************************************/




typedef enum
{
    SL_FS_TOKEN_MASTER              = 0,
    SL_FS_TOKEN_WRITE_READ          = 1,
    SL_FS_TOKEN_WRITE_ONLY          = 2,
    SL_FS_TOKEN_READ_ONLY           = 3
}SlFsTokenId_e;



typedef struct
{
    _u16  Flags;                    /* see Flags options */
    _u32  Len;                      /* In bytes, The actual size of the copy which is used for read*/
    _u32  MaxSize;                  /* In bytes, The max file size  */
    _u32  Token[4];                 /* see SlFsTokenId_e */
    _u32  StorageSize;              /* In bytes, The total size that the file required on the storage including the mirror */
    _u32  WriteCounter;             /* Number of times in which the file have been written successfully */
}SlFsFileInfo_t;



/*
  sl_FsGetInfo and sl_FsGetFileList flags
  ------------------
*/

#define SL_FS_INFO_OPEN_WRITE                    0x1000   /* File is opened for write */
#define SL_FS_INFO_OPEN_READ                     0x800    /* File is opened for read */

#define SL_FS_INFO_MUST_COMMIT                   0x1      /* File is currently open with SL_FS_FILE_OPEN_FLAG_COMMIT_MODE */
#define SL_FS_INFO_BUNDLE_FILE                   0x2      /* File is currently open with SL_FS_FILE_OPEN_FLAG_BUNDLE_COMMIT_MODE */

#define SL_FS_INFO_PENDING_COMMIT                0x4      /* File is currently closed with SL_FS_FILE_OPEN_FLAG_COMMIT_MODE */
#define SL_FS_INFO_PENDING_BUNDLE_COMMIT         0x8      /* File is currently closed with SL_FS_FILE_OPEN_FLAG_BUNDLE_COMMIT_MODE */

#define SL_FS_INFO_NOT_FAILSAFE                  0x20     /* File was created with SL_FS_FILE_OPEN_FLAG_FAILSAFE */
#define SL_FS_INFO_NOT_VALID                     0x100    /* No valid image exists for the file */
#define SL_FS_INFO_SYS_FILE                      0x40     /* File is system file */
#define SL_FS_INFO_SECURE                        0x10     /* File is secured */
#define SL_FS_INFO_NOSIGNATURE                   0x2000   /* File is unsigned, the flag is returns only for sl_FsGetInfo function and not for sl_FsGetFileList */
#define SL_FS_INFO_PUBLIC_WRITE                  0x200    /* File is open for public write */
#define SL_FS_INFO_PUBLIC_READ                   0x400    /* File is open for public read */



/*
  fs_Open flags
  --------------
*/

/* mode */
#define     SL_FS_CREATE                           ((_u32)0x1<<(SL_NUM_OF_MAXSIZE_BIT+SL_NUM_OF_FLAGS_BIT))
#define     SL_FS_WRITE                            ((_u32)0x2<<(SL_NUM_OF_MAXSIZE_BIT+SL_NUM_OF_FLAGS_BIT))
#define     SL_FS_OVERWRITE                        ((_u32)0x4<<(SL_NUM_OF_MAXSIZE_BIT+SL_NUM_OF_FLAGS_BIT))
#define     SL_FS_READ                             ((_u32)0x8<<(SL_NUM_OF_MAXSIZE_BIT+SL_NUM_OF_FLAGS_BIT))
/* creation flags */
#define     SL_FS_CREATE_FAILSAFE                  ((_u32)0x1<<SL_NUM_OF_MAXSIZE_BIT)         /* Fail safe */
#define     SL_FS_CREATE_SECURE                    ((_u32)0x2<<SL_NUM_OF_MAXSIZE_BIT)         /* SECURE */
#define     SL_FS_CREATE_NOSIGNATURE               ((_u32)0x4<<SL_NUM_OF_MAXSIZE_BIT)         /* Relevant to secure file only  */
#define     SL_FS_CREATE_STATIC_TOKEN              ((_u32)0x8<<SL_NUM_OF_MAXSIZE_BIT)         /* Relevant to secure file only */
#define     SL_FS_CREATE_VENDOR_TOKEN              ((_u32)0x10<<SL_NUM_OF_MAXSIZE_BIT)        /* Relevant to secure file only */
#define     SL_FS_CREATE_PUBLIC_WRITE              ((_u32)0x20<<SL_NUM_OF_MAXSIZE_BIT)        /* Relevant to secure file only, the file can be opened for write without Token */
#define     SL_FS_CREATE_PUBLIC_READ               ((_u32)0x40<<SL_NUM_OF_MAXSIZE_BIT)        /* Relevant to secure file only, the file can be opened for read without Token  */

#define     SL_FS_CREATE_MAX_SIZE( MaxFileSize )           ((((_u32)MaxFileSize + 255) / 256 ) & SL_FS_OPEN_MAXSIZE_BIT_MASK )

/* write flags */
#define    SL_FS_WRITE_MUST_COMMIT                  ((_u32)0x80<<SL_NUM_OF_MAXSIZE_BIT)        /* The file is locked for changes */
#define    SL_FS_WRITE_BUNDLE_FILE                  ((_u32)0x100<<SL_NUM_OF_MAXSIZE_BIT)       /* The file is locked for changes as part of Bundle */
#define    SL_FS_WRITE_ENCRYPTED                    ((_u32)0x200<<SL_NUM_OF_MAXSIZE_BIT)       /* This indicates the start of a secured content write session */



/*
  sl_FsCtl
  --------
*/
typedef enum
{
  SL_FS_CTL_RESTORE = 0,   /* restores the factory default */
  SL_FS_CTL_ROLLBACK = 1,
  SL_FS_CTL_COMMIT = 2,
  SL_FS_CTL_RENAME = 3,
  SL_FS_CTL_GET_STORAGE_INFO = 5,
  SL_FS_CTL_BUNDLE_ROLLBACK = 6,
  SL_FS_CTL_BUNDLE_COMMIT = 7
}SlFsCtl_e;



typedef enum
{
  SL_FS_BUNDLE_STATE_STOPPED = 0,
  SL_FS_BUNDLE_STATE_STARTED = 1,
  SL_FS_BUNDLE_STATE_PENDING_COMMIT = 3
}SlFsBundleState_e;



typedef struct
{
    _u32  Key[4];/*16 bytes*/
}SlFsKey_t;



typedef struct
{
  _u8   Index;
}SlFsFileNameIndex_t;

typedef union
{
  SlFsFileNameIndex_t  Index;
  _i32                 ErrorNumber;
}SlFsFileNameIndexOrError_t;


/* File control helper structures */


/*SL_FS_CTL_RESTORE*/
typedef enum
{
  SL_FS_FACTORY_RET_TO_IMAGE =  0,/*The system will be back to the production image.*/
  SL_FS_FACTORY_RET_TO_DEFAULT = 2 /*return to factory default*/
}SlFsRetToFactoryOper_e;

typedef struct
{
  _u32 Operation;/*see _SlFsRetToFactoryOper_e*/
}SlFsRetToFactoryCommand_t;







/******************* Input flags end *****************************************/

typedef struct
{
  _u32           IncludeFilters;

}SlFsControl_t;



typedef struct
{
  _u16 DeviceBlockSize;
  _u16 DeviceBlocksCapacity;
  _u16 NumOfAllocatedBlocks;
  _u16 NumOfReservedBlocks;
  _u16 NumOfReservedBlocksForSystemfiles;
  _u16 LargestAllocatedGapInBlocks;
  _u16 NumOfAvailableBlocksForUserFiles;
  _u8  Padding[2];
} SlFsControlDeviceUsage_t;

typedef struct
{
  _u8  MaxFsFiles;
  _u8  IsDevlopmentFormatType;
  _u8  Bundlestate; /*see SlFsBundleState_e*/
  _u8  Reserved;
  _u8  MaxFsFilesReservedForSysFiles;
  _u8  ActualNumOfUserFiles;
  _u8  ActualNumOfSysFiles;
  _u8  Padding;
  _u32 NumOfAlerts;
  _u32 NumOfAlertsThreshold;
  _u16 FATWriteCounter;/*Though it is increased during the programming, the programming and ret to factory takes only 1- write to the FAT, independ of the number of the programming files */
  _u16 Padding2;
}SlFsControlFilesUsage_t;




/*SL_FS_CTL_GET_STORAGE_INFO*/
typedef struct
{
    SlFsControlDeviceUsage_t DeviceUsage;
    SlFsControlFilesUsage_t  FilesUsage;
} SlFsControlGetStorageInfoResponse_t;


typedef struct
{
   _u32   IncludeFilters; /* see SlFsControlFilterCounterFlags_e*/
   _u8    OpenedForWriteCnt;
   _u8    OpeneForReadCnt;
   _u8    ClosedFilesCnt;
   _u8    OpenedForWriteCntWithValidFailSafeImage;
   _u8    OpeneForReadCntWithValidFailSafeImage;
   _u8    ClosedFilesCntWithValidFailSafeImage;
   _u8    padding[2];
} SlFsControlGetCountersResponse_t;



/* GetFileList */
#define SL_FS_MAX_FILE_NAME_LENGTH                       180


typedef enum
{
    SL_FS_GET_FILE_ATTRIBUTES = 0x1
}SlFileListFlags_t;




typedef struct
{
   _u32  FileMaxSize;
   _u32  Properties; /* see SL_FS_INFO_  flags */
   _u32  FileAllocatedBlocks;/*1 block = 4096 bytes*/
}SlFileAttributes_t;
/*****************************************************************************/
/* external Function prototypes                                              */
/*****************************************************************************/

/*****************************************************************************/
/* Function prototypes                                                       */
/*****************************************************************************/
#if _SL_INCLUDE_FUNC(sl_FsOpen)
_i32 sl_FsOpen(const _u8 *pFileName,const _u32 AccessModeAndMaxSize,_u32 *pToken);
#endif

#if _SL_INCLUDE_FUNC(sl_FsClose)
_i16 sl_FsClose(const _i32 FileHdl,const _u8* pCeritificateFileName,const _u8* pSignature,const _u32 SignatureLen);
#endif

#if _SL_INCLUDE_FUNC(sl_FsRead)
_i32 sl_FsRead(const _i32 FileHdl,_u32 Offset ,_u8*  pData,_u32 Len);
#endif

#if _SL_INCLUDE_FUNC(sl_FsWrite)
_i32 sl_FsWrite(const _i32 FileHdl,_u32 Offset,_u8*  pData,_u32 Len);
#endif

#if _SL_INCLUDE_FUNC(sl_FsGetInfo)
_i16 sl_FsGetInfo(const _u8 *pFileName,const _u32 Token,SlFsFileInfo_t* pFsFileInfo);
#endif

#if _SL_INCLUDE_FUNC(sl_FsDel)
_i16 sl_FsDel(const _u8 *pFileName,const _u32 Token);
#endif



#if _SL_INCLUDE_FUNC(sl_FsCtl)
_i32   sl_FsCtl(  SlFsCtl_e Command,  _u32 Token,  _u8 *pFileName, const _u8 *pData, _u16 DataLen, _u8 *pOutputData, _u16 OutputDataLen,_u32 *pNewToken );
#endif

#if _SL_INCLUDE_FUNC(sl_FsProgram)
_i32   sl_FsProgram(const _u8*  pData , _u16 Len , const _u8 * pKey ,  _u32 Flags );
#endif

#if _SL_INCLUDE_FUNC(sl_FsGetFileList)
_i32  sl_FsGetFileList(_i32* pIndex, _u8 Count, _u8 MaxEntryLen , _u8* pBuff, SlFileListFlags_t Flags );
#endif




#ifdef  __cplusplus
}
#endif /*  __cplusplus */

#endif /*  __FS_H__ */