| /* |
| * fs.h - CC31xx/CC32xx Host Driver Implementation |
| * |
| * Copyright (C) 2017 Texas Instruments Incorporated - http://www.ti.com/ |
| * |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the |
| * distribution. |
| * |
| * Neither the name of Texas Instruments Incorporated nor the names of |
| * its contributors may be used to endorse or promote products derived |
| * from this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| */ |
| |
| |
| |
| /*****************************************************************************/ |
| /* Include files */ |
| /*****************************************************************************/ |
| #include <ti/drivers/net/wifi/simplelink.h> |
| |
| #ifndef __FS_H__ |
| #define __FS_H__ |
| |
| |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /*! |
| \defgroup FileSystem |
| \short Provides file system capabilities to TI's CC31XX that can be used by both the CC31XX device and the user |
| |
| */ |
| |
| /*! |
| |
| \addtogroup FileSystem |
| @{ |
| |
| */ |
| |
| /*****************************************************************************/ |
| /* 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; |
| /*! |
| \cond DOXYGEN_REMOVE |
| */ |
| /*****************************************************************************/ |
| /* external Function prototypes */ |
| /*****************************************************************************/ |
| |
| /*****************************************************************************/ |
| /* Function prototypes */ |
| /*****************************************************************************/ |
| /*! |
| \endcond |
| */ |
| /*! |
| \brief open file for read or write from/to storage device |
| |
| \param[in] pFileName File Name buffer pointer |
| \param[in] AccessModeAndMaxSize Options: As described below |
| \param[in] pToken input Token for read, output Token for write |
| |
| AccessModeAndMaxSize possible input \n |
| SL_FS_READ - Read a file \n |
| SL_FS_WRITE - Open for write for an existing file (whole file content needs to be rewritten)\n |
| SL_FS_CREATE|maxSizeInBytes,accessModeFlags |
| SL_FS_CREATE|SL_FS_OVERWRITE|maxSizeInBytes,accessModeFlags - Open for creating a new file. Max file size is defined in bytes. \n |
| For optimal FS size, use max size in 4K-512 bytes steps (e.g. 3584,7680,117760) \n |
| Several access modes bits can be combined together from SlFileOpenFlags_e enum |
| |
| \return File handle on success. Negative error code on fail |
| |
| \sa sl_FsRead sl_FsWrite sl_FsClose |
| \note belongs to \ref basic_api |
| \warning |
| \par Example |
| |
| - Creating file and writing data to it |
| \code |
| char* DeviceFileName = "MyFile.txt"; |
| unsigned long MaxSize = 63 * 1024; //62.5K is max file size |
| long DeviceFileHandle = -1; |
| _i32 RetVal; //negative retval is an error |
| unsigned long Offset = 0; |
| unsigned char InputBuffer[100]; |
| _u32 MasterToken = 0; |
| |
| // Create a file and write data. The file in this example is secured, without signature and with a fail safe commit |
| |
| //create a secure file if not exists and open it for write. |
| DeviceFileHandle = sl_FsOpen(unsigned char *)DeviceFileName, |
| SL_FS_CREATE|SL_FS_OVERWRITE | SL_FS_CREATE_SECURE | SL_FS_CREATE_NOSIGNATURE | SL_FS_CREATE_MAX_SIZE( MaxSize ), |
| &MasterToken); |
| |
| Offset = 0; |
| //Preferred in secure file that the Offset and the length will be aligned to 16 bytes. |
| RetVal = sl_FsWrite( DeviceFileHandle, Offset, (unsigned char *)"HelloWorld", strlen("HelloWorld")); |
| |
| RetVal = sl_FsClose(DeviceFileHandle, NULL, NULL , 0); |
| |
| // open the same file for read, using the Token we got from the creation procedure above |
| DeviceFileHandle = sl_FsOpen(unsigned char *)DeviceFileName, |
| SL_FS_READ, |
| &MasterToken); |
| |
| Offset = 0; |
| RetVal = sl_FsRead( DeviceFileHandle, Offset, (unsigned char *)InputBuffer, strlen("HelloWorld")); |
| |
| RetVal = sl_FsClose(DeviceFileHandle, NULL, NULL , 0); |
| |
| \endcode |
| <br> |
| |
| - Create a non secure file if not already exists and open it for write |
| \code |
| DeviceFileHandle = sl_FsOpen((unsigned char *)DeviceFileName, |
| SL_FS_CREATE|SL_FS_OVERWRITE| SL_FS_CREATE_MAX_SIZE( MaxSize ), |
| NULL); |
| \endcode |
| |
| \note Some of the flags are creation flags and can only be set when the file is created. When opening the file for write the creation flags are ignored. For more information, refer to chapter 8 in the user manual. |
| |
| */ |
| |
| #if _SL_INCLUDE_FUNC(sl_FsOpen) |
| _i32 sl_FsOpen(const _u8 *pFileName,const _u32 AccessModeAndMaxSize,_u32 *pToken); |
| #endif |
| |
| /*! |
| \brief Close file in storage device |
| |
| \param[in] FileHdl Pointer to the file (assigned from sl_FsOpen) |
| \param[in] pCeritificateFileName Certificate file, or NULL if irrelevant. |
| \param[in] pSignature The signature is SHA-1, the certificate chain may include SHA-256 |
| \param[in] SignatureLen The signature actual length |
| |
| |
| \return Zero on success, or a negative value if an error occurred |
| \sa sl_FsRead sl_FsWrite sl_FsOpen |
| \note Call the fs_Close with signature = 'A' signature len = 1 for activating an abort action\n |
| Creating signature : OpenSSL> dgst -binary -sha1 -sign <file-location>\<private_key>.pem -out <file-location>\<output>.sig <file-location>\<input>.txt |
| \warning |
| \par Examples |
| |
| - Closing file: |
| \code |
| _i16 RetVal; |
| RetVal = sl_FsClose(FileHandle,0,0,0); |
| \endcode |
| <br> |
| |
| - Aborting file: |
| \code |
| |
| _u8 Signature; |
| Signature = 'A'; |
| sl_FsClose(FileHandle,0,&Signature, 1); |
| \endcode |
| |
| \note In case the file was opened as not secure file or as secure-not signed, any certificate or signature provided are ignored, those fields should be set to NULL. |
| */ |
| #if _SL_INCLUDE_FUNC(sl_FsClose) |
| _i16 sl_FsClose(const _i32 FileHdl,const _u8* pCeritificateFileName,const _u8* pSignature,const _u32 SignatureLen); |
| #endif |
| |
| /*! |
| \brief Read block of data from a file in storage device |
| |
| \param[in] FileHdl Pointer to the file (assigned from sl_FsOpen) |
| \param[in] Offset Offset to specific read block |
| \param[out] pData Pointer for the received data |
| \param[in] Len Length of the received data |
| |
| \return Number of read bytes on success, negative error code on failure |
| |
| \sa sl_FsClose sl_FsWrite sl_FsOpen |
| \note belongs to \ref basic_api |
| \warning |
| \par Example |
| |
| - Reading File: |
| \code |
| Status = sl_FsRead(FileHandle, 0, &readBuff[0], readSize); |
| \endcode |
| */ |
| #if _SL_INCLUDE_FUNC(sl_FsRead) |
| _i32 sl_FsRead(const _i32 FileHdl,_u32 Offset ,_u8* pData,_u32 Len); |
| #endif |
| |
| /*! |
| \brief Write block of data to a file in storage device |
| |
| \param[in] FileHdl Pointer to the file (assigned from sl_FsOpen) |
| \param[in] Offset Offset to specific block to be written |
| \param[in] pData Pointer the transmitted data to the storage device |
| \param[in] Len Length of the transmitted data |
| |
| \return Number of wireted bytes on success, negative error code on failure |
| |
| \sa |
| \note belongs to \ref basic_api |
| \warning |
| \par Example |
| |
| - Writing file: |
| \code |
| Status = sl_FsWrite(FileHandle, 0, &buff[0], readSize); |
| \endcode |
| */ |
| #if _SL_INCLUDE_FUNC(sl_FsWrite) |
| _i32 sl_FsWrite(const _i32 FileHdl,_u32 Offset,_u8* pData,_u32 Len); |
| #endif |
| |
| /*! |
| \brief Get information of a file |
| |
| \param[in] pFileName File name |
| \param[in] Token File token. if irrelevant set to 0. |
| \param[out] pFsFileInfo Returns the File's Information (SlFsFileInfo_t) |
| - Flags |
| - File size |
| - Allocated size |
| - Tokens |
| |
| \return Zero on success, negative error code on failure \n |
| When file not exists : SL_ERROR_FS_FILE_NOT_EXISTS |
| \note |
| - If the return value is SL_ERROR_FS_FILE_HAS_NOT_BEEN_CLOSE_CORRECTLY or SL_ERROR_FS_FILE_IS_ALREADY_OPENED information about the file is valid. |
| - Belongs to \ref basic_api |
| |
| \sa sl_FsOpen |
| \warning |
| \par Example |
| |
| - Getting file info: |
| \code |
| Status = sl_FsGetInfo("FileName.html",Token,&FsFileInfo); |
| \endcode |
| */ |
| #if _SL_INCLUDE_FUNC(sl_FsGetInfo) |
| _i16 sl_FsGetInfo(const _u8 *pFileName,const _u32 Token,SlFsFileInfo_t* pFsFileInfo); |
| #endif |
| |
| /*! |
| \brief Delete specific file from a storage or all files from a storage (format) |
| |
| \param[in] pFileName File Name |
| \param[in] Token File token. if irrelevant set to 0 |
| \return Zero on success, or a negative value if an error occurred |
| |
| \sa |
| \note belongs to \ref basic_api |
| \warning |
| \par Example |
| |
| - Deleting file: |
| \code |
| Status = sl_FsDel("FileName.html",Token); |
| \endcode |
| */ |
| #if _SL_INCLUDE_FUNC(sl_FsDel) |
| _i16 sl_FsDel(const _u8 *pFileName,const _u32 Token); |
| #endif |
| |
| |
| |
| /*! |
| \brief Controls various file system operations |
| |
| \param[in] Command , the command to execute, \see SlFsCtl_e |
| SL_FS_CTL_RESTORE , Return to factory default, return to factory image , see fs programming |
| SL_FS_CTL_ROLLBACK , Roll-back file which was created with 'SL_FS_WRITE_MUST_COMMIT' |
| SL_FS_CTL_COMMIT,Commit file which was created with 'SL_FS_WRITE_MUST_COMMIT' |
| SL_FS_CTL_RENAME, Rename file |
| SL_FS_CTL_GET_STORAGE_INFO, Total size of storage , available size of storage |
| SL_FS_CTL_BUNDLE_ROLLBACK, Rollback bundle files |
| SL_FS_CTL_BUNDLE_COMMIT, Commit Bundle files |
| \param[in] Token Set to NULL if not relevant to the command |
| \param[in] pFileName Set to NULL if not relevant to the command |
| \param[in] pData The data according the command. |
| \param[in] DataLen Length of data buffer |
| \param[out] pOutputData Buffer for the output data |
| \param[out] OutputDataLen Length of the output data buffer |
| \param[out] pNewToken The new valid file token, if irrelevant can be set to NULL. |
| \return |
| - Zero on success, or a negative value if an error occurred |
| - For SL_FS_CTL_BUNDLE_ROLLBACK, On success bundle the new bundle state is returned (see SlFsBundleState_e) else negative error number |
| - For SL_FS_CTL_BUNDLE_COMMIT, On success the new bundle state is returned (see SlFsBundleState_e) else negative error number |
| |
| \sa |
| \note belongs to \ref ext_api |
| \warning |
| \par Examples |
| |
| - SL_FS_CTL_ROLLBACK: |
| \code |
| FsControl.IncludeFilters = 0; |
| slRetVal = sl_FsCtl( (SlFsCtl_e)SL_FS_CTL_FILE_ROLLBACK, Token, NWPfileName ,(_u8 *)&FsControl, sizeof(SlFsControl_t), NULL, 0 , pNewToken); |
| \endcode |
| <br> |
| |
| - SL_FS_CTL_COMMIT: |
| \code |
| FsControl.IncludeFilters = 0; |
| slRetVal = sl_FsCtl(SL_FS_CTL_COMMIT, Token, NWPfileName ,(_u8 *)&FsControl, sizeof(SlFsControl_t), NULL, 0, pNewToken ); |
| \endcode |
| <br> |
| |
| - SL_FS_CTL_RENAME: |
| \code |
| slRetVal = sl_FsCtl(SL_FS_CTL_RENAME, Token, NWPfileName, NewFileName, 0, NULL, 0, NULL ); |
| \endcode |
| <br> |
| |
| - SL_FS_CTL_GET_STORAGE_INFO: |
| \code |
| _i32 GetStorageInfo( SlFsControlGetStorageInfoResponse_t* pSlFsControlGetStorageInfoResponse ) |
| { |
| _i32 slRetVal; |
| |
| slRetVal = sl_FsCtl( ( SlFsCtl_e)SL_FS_CTL_GET_STORAGE_INFO, 0, NULL , NULL , 0, (_u8 *)pSlFsControlGetStorageInfoResponse, sizeof(SlFsControlGetStorageInfoResponse_t), NULL ); |
| return slRetVal; |
| |
| } |
| \endcode |
| <br> |
| |
| - SL_FS_CTL_RESTORE: |
| \code |
| //Return 0 for OK, else Error |
| _i32 ProgramRetToImage( ) |
| { |
| _i32 slRetVal; |
| SlFsRetToFactoryCommand_t RetToFactoryCommand; |
| _i32 RetVal, ExtendedError; |
| |
| RetToFactoryCommand.Operation = SL_FS_FACTORY_RET_TO_IMAGE; |
| slRetVal = sl_FsCtl( (SlFsCtl_e)SL_FS_CTL_RESTORE, 0, NULL , (_u8 *)&RetToFactoryCommand , sizeof(SlFsRetToFactoryCommand_t), NULL, 0 , NULL ); |
| if ((_i32)slRetVal < 0) |
| { |
| //Pay attention, for this function the slRetVal is composed from Signed RetVal & extended error |
| RetVal = (_i16)slRetVal>> 16; |
| ExtendedError = (_u16)slRetVal& 0xFFFF; |
| printf("\tError SL_FS_FACTORY_RET_TO_IMAGE, 5d, %d\n", RetVal, ExtendedError); |
| return slRetVal; |
| } |
| //Reset |
| sl_Stop(0); |
| Sleep(1000); |
| sl_Start(NULL, NULL, NULL); |
| |
| return slRetVal; |
| } |
| \endcode |
| <br> |
| |
| - SL_FS_CTL_BUNDLE_ROLLBACK: |
| \code |
| //return 0 for O.K else negative |
| _i32 BundleRollback() |
| { |
| _i32 slRetVal = 0; |
| SlFsControl_t FsControl; |
| FsControl.IncludeFilters = 0; //Use default behaviour |
| slRetVal = sl_FsCtl( (SlFsCtl_e)SL_FS_CTL_BUNDLE_ROLLBACK, 0, NULL ,(_u8 *)&FsControl, sizeof(SlFsControl_t), NULL, 0 , NULL); |
| return slRetVal; |
| } |
| \endcode |
| <br> |
| |
| - SL_FS_CTL_BUNDLE_COMMIT: |
| \code |
| //return 0 for O.K else negative |
| _i32 BundleCommit() |
| { |
| _i32 slRetVal = 0; |
| SlFsControl_t FsControl; |
| FsControl.IncludeFilters = 0; //Use default behaviour |
| slRetVal = sl_FsCtl( (SlFsCtl_e)SL_FS_CTL_BUNDLE_COMMIT, 0, NULL ,(_u8 *)&FsControl, sizeof(SlFsControl_t), NULL, 0 , NULL); |
| return slRetVal; |
| } |
| \endcode |
| */ |
| #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 |
| /*! |
| \brief Enables to format and configure the device with pre-prepared configuration |
| |
| \param[in] Flags For future use |
| \param[in] pKey In case the ucf is encrypted the encryption key, otherwise NULL |
| \param[in] pData The file is download in data chunks, the chunk size should be aligned to 16 bytes, if no data Set to NULL |
| \param[in] Len The length of pData in bytes |
| \return The return value is: |
| - On error < 0 , contains the error number and extended error number |
| - On success > 0, represent the number of bytes received |
| - On successful end == 0 , when all file chunks are download |
| \sa |
| \note belongs to \ref ext_api |
| \warning |
| \par Example |
| |
| - FS programming: |
| \code |
| |
| //Return 0 for OK, else Error |
| _i32 ProgramImage( char* UcfFileName, char * KeyFileName ) |
| { |
| #define PROGRAMMING_CHUNK_SIZE 4096 |
| _i32 slRetVal = 0; |
| SlFsKey_t Key; |
| FILE *hostFileHandle = NULL; |
| _u16 bytesRead; |
| _u8 DataBuf[PROGRAMMING_CHUNK_SIZE]; |
| FILE *KeyFileHandle = NULL; |
| short ErrorNum; |
| unsigned short ExtendedErrorNum; |
| time_t start,end; |
| double dif; |
| _u8* pKey = NULL; |
| errno_t err; |
| |
| |
| |
| if (KeyFileName != "") |
| { |
| //Read key |
| err = fopen_s( &KeyFileHandle, KeyFileName, "rb"); |
| if (err != 0) |
| { |
| return __LINE__;//error |
| } |
| fread((_u8*)&Key, 1, sizeof(SlFsKey_t), KeyFileHandle); |
| fclose(KeyFileHandle); |
| pKey = (_u8*)&Key; |
| } |
| |
| // Downlaoding the Data with the key, the key can be set only in the first chunk,no need to download it with each chunk |
| if (UcfFileName != "") |
| { |
| //Read data |
| err = fopen_s( &hostFileHandle, UcfFileName, "rb"); |
| if (err != 0) |
| { |
| return __LINE__;//error |
| } |
| |
| |
| time (&start); |
| |
| bytesRead = fread(DataBuf, 1, PROGRAMMING_CHUNK_SIZE, hostFileHandle); |
| |
| while ( bytesRead ) |
| { |
| slRetVal = sl_FsProgram( DataBuf , bytesRead , (_u8*)pKey, 0 ); |
| if(slRetVal == SL_API_ABORTED)//timeout |
| { |
| return( slRetVal ); |
| } |
| else if (slRetVal < 0 )//error |
| { |
| ErrorNum = (long)slRetVal >> 16; |
| ExtendedErrorNum = (_u16)(slRetVal & 0xFFFF); |
| printf("\tError sl_FsProgram = %d , %d \n", ErrorNum, ExtendedErrorNum); |
| fclose(hostFileHandle); |
| return( ErrorNum ); |
| } |
| if(slRetVal == 0)//finished succesfully |
| break; |
| pKey = NULL;//no need to download the key with each chunk; |
| bytesRead = fread(DataBuf, 1, PROGRAMMING_CHUNK_SIZE, hostFileHandle); |
| } |
| |
| |
| time (&end); |
| dif = difftime (end,start); |
| #ifdef PRINT |
| printf ("\tProgramming took %.2lf seconds to run.\n", dif ); |
| #endif |
| //The file was downloaded but it was not detected by the programming as the EOF. |
| if((bytesRead == 0 ) && (slRetVal > 0 )) |
| { |
| return __LINE__;//error |
| } |
| |
| |
| fclose(hostFileHandle); |
| }//if (UcfFileName != "") |
| |
| //this scenario is in case the image was already "burned" to the SFLASH by external tool and only the key is downloaded |
| else if (KeyFileName != "") |
| { |
| slRetVal = sl_FsProgram(NULL , 0 , (_u8*)pKey, 0 ); |
| if (slRetVal < 0)//error |
| { |
| ErrorNum = (long)slRetVal >> 16; |
| ExtendedErrorNum = (_u16)slRetVal && 0xFF;; |
| printf("\tError sl_FsProgram = %d , %d \n", ErrorNum, ExtendedErrorNum); |
| fclose(hostFileHandle); |
| return( ErrorNum ); |
| } |
| } |
| |
| if( slRetVal == 0 ) |
| { |
| //Reset the nWP |
| sl_Stop(100); |
| Sleep(1000); |
| sl_Start(NULL, NULL, NULL); |
| Sleep(2000); |
| } |
| |
| return slRetVal; |
| |
| } |
| |
| \endcode |
| */ |
| |
| #if _SL_INCLUDE_FUNC(sl_FsProgram) |
| _i32 sl_FsProgram(const _u8* pData , _u16 Len , const _u8 * pKey , _u32 Flags ); |
| #endif |
| /*! |
| \brief The list of file names, the files are retrieve in chunks |
| |
| \param[in, out] pIndex The first chunk should start with value of -1, afterwards the Index from the previous call should be set as input\n |
| Returns current chunk intex, start the next chunk from that number |
| \param[in] Count Number of entries to retrieve |
| \param[in] MaxEntryLen The total size of the buffer is Count * MaxEntryLen |
| \param[out] pBuff The buffer contains list of SlFileAttributes_t + file name |
| \param[in] Flags Is to retrieve file attributes see SlFileAttributes_t. |
| \return The actual number of entries which are contained in the buffer. On error negative number which contains the error number. |
| \sa |
| \note belongs to \ref ext_api |
| \warning |
| \par Example |
| |
| - Getting file list |
| \code |
| typedef struct |
| { |
| SlFileAttributes_t attribute; |
| char fileName[SL_FS_MAX_FILE_NAME_LENGTH]; |
| }slGetfileList_t; |
| |
| #define COUNT 5 |
| |
| void PrintFileListProperty(_u16 prop); |
| |
| INT32 GetFileList() |
| { |
| _i32 NumOfEntriesOrError = 1; |
| _i32 Index = -1; |
| slGetfileList_t File[COUNT]; |
| _i32 i; |
| _i32 RetVal = 0; |
| |
| printf("%\n"); |
| while( NumOfEntriesOrError > 0 ) |
| { |
| NumOfEntriesOrError = sl_FsGetFileList( &Index, COUNT, (_u8)(SL_FS_MAX_FILE_NAME_LENGTH + sizeof(SlFileAttributes_t)), (unsigned char*)File, SL_FS_GET_FILE_ATTRIBUTES); |
| if (NumOfEntriesOrError < 0) |
| { |
| RetVal = NumOfEntriesOrError;//error |
| break; |
| } |
| for (i = 0; i < NumOfEntriesOrError; i++) |
| { |
| printf("Name: %s\n", File[i].fileName); |
| printf("AllocatedBlocks: %5d ",File[i].attribute.FileAllocatedBlocks); |
| printf("MaxSize(byte): %5d \n", File[i].attribute.FileMaxSize); |
| PrintFileListProperty((_u16)File[i].attribute.Properties); |
| printf("%\n\n"); |
| } |
| } |
| printf("%\n"); |
| return RetVal;//0 means O.K |
| } |
| |
| void PrintFileListProperty(_u16 prop) |
| { |
| printf("Flags : "); |
| if (prop & SL_FS_INFO_MUST_COMMIT) |
| printf("Open file commit,"); |
| if (prop & SL_FS_INFO_BUNDLE_FILE) |
| printf("Open bundle commit,"); |
| if (prop & SL_FS_INFO_PENDING_COMMIT) |
| printf("Pending file commit,"); |
| if (prop & SL_FS_INFO_PENDING_BUNDLE_COMMIT) |
| printf("Pending bundle commit,"); |
| if (prop & SL_FS_INFO_SECURE) |
| printf("Secure,"); |
| if (prop & SL_FS_INFO_NOT_FAILSAFE) |
| printf("File safe,"); |
| if (prop & SL_FS_INFO_SYS_FILE) |
| printf("System,"); |
| if (prop & SL_FS_INFO_NOT_VALID) |
| printf("No valid copy,"); |
| if (prop & SL_FS_INFO_PUBLIC_WRITE) |
| printf("Public write,"); |
| if (prop & SL_FS_INFO_PUBLIC_READ) |
| printf("Public read,"); |
| } |
| |
| \endcode |
| */ |
| #if _SL_INCLUDE_FUNC(sl_FsGetFileList) |
| _i32 sl_FsGetFileList(_i32* pIndex, _u8 Count, _u8 MaxEntryLen , _u8* pBuff, SlFileListFlags_t Flags ); |
| #endif |
| |
| |
| |
| |
| /*! |
| |
| Close the Doxygen group. |
| @} |
| |
| */ |
| |
| #ifdef __cplusplus |
| } |
| #endif /* __cplusplus */ |
| |
| #endif /* __FS_H__ */ |
| |
