Diff: xternal/simplelink/source/fs.c

Revision:

16:a004191a79ab

Parent:

0:33d4e66780c0

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/xternal/simplelink/source/fs.c	Thu Oct 03 11:40:13 2019 -0500
@@ -0,0 +1,456 @@
+/*
+ * fs.c - CC31xx/CC32xx Host Driver Implementation
+ *
+ * Copyright (C) 2015 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 "simplelink.h"
+#include "protocol.h"
+#include "driver.h"
+
+/*****************************************************************************/
+/* Macro declarations                                                        */
+/*****************************************************************************/
+#define sl_min(a,b) (((a) < (b)) ? (a) : (b))
+#define MAX_NVMEM_CHUNK_SIZE  1460
+
+/*****************************************************************************/
+/* Internal functions                                                        */
+/*****************************************************************************/
+
+#ifndef SL_TINY
+
+static _u16 _sl_Strlen(const _u8 *buffer);
+
+/*****************************************************************************/
+/* _sl_Strlen                                                                */
+/*****************************************************************************/
+static _u16 _sl_Strlen(const _u8 *buffer)
+{
+    _u16 len = 0;
+    if( buffer != NULL )
+    {
+      while(*buffer++) len++;
+    }
+    return len;
+}
+
+/*****************************************************************************/
+/* _sl_GetCreateFsMode                                                       */
+/*****************************************************************************/
+_u32 _sl_GetCreateFsMode(_u32 maxSizeInBytes,_u32 accessFlags)
+{
+   _u32 granIdx = 0;
+   _u32 granNum = 0;
+   _u32 granTable[_FS_MAX_MODE_SIZE_GRAN] = {256,1024,4096,16384,65536}; 
+   for(granIdx= _FS_MODE_SIZE_GRAN_256B ;granIdx< _FS_MAX_MODE_SIZE_GRAN;granIdx++) 
+   {                                                       
+       if( granTable[granIdx]*255 >= maxSizeInBytes ) 
+            break;                                                      
+   }                                                                 
+   granNum = maxSizeInBytes/granTable[granIdx];
+   if( maxSizeInBytes % granTable[granIdx] != 0 )
+         granNum++;
+
+   return _FS_MODE(_FS_MODE_OPEN_WRITE_CREATE_IF_NOT_EXIST,  granIdx, granNum, accessFlags);
+}
+
+#endif
+
+/*****************************************************************************/
+/* API functions                                                        */
+/*****************************************************************************/
+
+/*****************************************************************************/
+/*  sl_FsOpen */ 
+/*****************************************************************************/
+typedef union
+{
+	_FsOpenCommand_t	    Cmd;
+	_FsOpenResponse_t	    Rsp;
+}_SlFsOpenMsg_u;
+
+
+#if _SL_INCLUDE_FUNC(sl_FsOpen)
+
+static const _SlCmdCtrl_t _SlFsOpenCmdCtrl =
+{
+    SL_OPCODE_NVMEM_FILEOPEN,
+    (_SlArgSize_t)sizeof(_FsOpenCommand_t),
+    (_SlArgSize_t)sizeof(_FsOpenResponse_t)
+};
+
+_i32 sl_FsOpen(const _u8 *pFileName,const _u32 AccessModeAndMaxSize, _u32 *pToken,_i32 *pFileHandle)
+{
+    _SlReturnVal_t        RetVal;
+    _SlFsOpenMsg_u        Msg;
+    _SlCmdExt_t           CmdExt;
+
+    /* verify no erorr handling in progress. if in progress than
+      ignore the API execution and return immediately with an error */
+    VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
+    
+    CmdExt.TxPayloadLen = (_u16)((_sl_Strlen(pFileName)+4) & (~3)); /* add 4: 1 for NULL and the 3 for align */
+    CmdExt.RxPayloadLen = 0;
+    CmdExt.pTxPayload = (_u8*)pFileName;
+    CmdExt.pRxPayload = NULL;
+
+    Msg.Cmd.Mode          =  AccessModeAndMaxSize; 
+
+	if(pToken != NULL)
+	{
+       Msg.Cmd.Token         = *pToken;
+	}
+    else
+	{
+       Msg.Cmd.Token         = 0;
+	}
+
+    RetVal = _SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsOpenCmdCtrl, &Msg, &CmdExt);
+    *pFileHandle = (_i32)Msg.Rsp.FileHandle;
+	if (pToken != NULL)
+	{
+        *pToken =      Msg.Rsp.Token;
+	}
+       
+	/* in case of an error, return the erros file handler as an error code */
+	if( *pFileHandle < 0 )
+	{
+	   return *pFileHandle;
+	}
+    return (_i32)RetVal;
+}
+#endif
+
+/*****************************************************************************/
+/* sl_FsClose */ 
+/*****************************************************************************/
+typedef union
+{
+	_FsCloseCommand_t	    Cmd;
+	_BasicResponse_t	    Rsp;
+}_SlFsCloseMsg_u;
+
+
+#if _SL_INCLUDE_FUNC(sl_FsClose)
+
+static const _SlCmdCtrl_t _SlFsCloseCmdCtrl =
+{
+    SL_OPCODE_NVMEM_FILECLOSE,
+    (_SlArgSize_t)sizeof(_FsCloseCommand_t),
+    (_SlArgSize_t)sizeof(_FsCloseResponse_t)
+};
+
+
+_i16 sl_FsClose(const _i32 FileHdl, const _u8*  pCeritificateFileName,const _u8*  pSignature ,const _u32 SignatureLen)
+{
+    _SlFsCloseMsg_u    Msg;
+    _SlCmdExt_t        ExtCtrl;
+
+    _SlDrvMemZero(&Msg, (_u16)sizeof(_FsCloseCommand_t));
+    
+    /* verify no erorr handling in progress. if in progress than
+      ignore the API execution and return immediately with an error */
+    VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
+    
+    Msg.Cmd.FileHandle             = (_u32)FileHdl;
+    if( pCeritificateFileName != NULL )
+    {
+        Msg.Cmd.CertificFileNameLength = (_u32)((_sl_Strlen(pCeritificateFileName)+4) & (~3)); /* add 4: 1 for NULL and the 3 for align */
+    }
+    Msg.Cmd.SignatureLen           = SignatureLen;
+    
+    ExtCtrl.TxPayloadLen = (_u16)(((SignatureLen+3) & (~3))); /* align */
+    ExtCtrl.pTxPayload   = (_u8*)pSignature;
+    ExtCtrl.RxPayloadLen = (_i16)Msg.Cmd.CertificFileNameLength;
+    ExtCtrl.pRxPayload   = (_u8*)pCeritificateFileName; /* Add signature */
+    
+    if(ExtCtrl.pRxPayload != NULL &&  ExtCtrl.RxPayloadLen != 0)
+    {
+       ExtCtrl.RxPayloadLen = ExtCtrl.RxPayloadLen * (-1);
+    }
+
+    VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsCloseCmdCtrl, &Msg, &ExtCtrl));
+
+    return (_i16)((_i16)Msg.Rsp.status);
+}
+#endif
+
+
+/*****************************************************************************/
+/* sl_FsRead */ 
+/*****************************************************************************/
+typedef union
+{
+	_FsReadCommand_t	    Cmd;
+	_FsReadResponse_t	    Rsp;
+}_SlFsReadMsg_u;
+
+#if _SL_INCLUDE_FUNC(sl_FsRead)
+
+
+static const _SlCmdCtrl_t _SlFsReadCmdCtrl =
+{
+    SL_OPCODE_NVMEM_FILEREADCOMMAND,
+    (_SlArgSize_t)sizeof(_FsReadCommand_t),
+    (_SlArgSize_t)sizeof(_FsReadResponse_t)
+}; 
+
+_i32 sl_FsRead(const _i32 FileHdl,_u32 Offset, _u8*  pData,_u32 Len)
+{
+    _SlFsReadMsg_u      Msg;
+    _SlCmdExt_t         ExtCtrl;
+    _u16      ChunkLen;
+    _SlReturnVal_t      RetVal =0;
+    _i32                RetCount = 0;
+
+    /* verify no erorr handling in progress. if in progress than
+      ignore the API execution and return immediately with an error */
+    VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
+
+    ExtCtrl.TxPayloadLen = 0;
+    ExtCtrl.pTxPayload   = NULL;
+
+    ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
+    ExtCtrl.RxPayloadLen = (_i16)ChunkLen;
+    ExtCtrl.pRxPayload   = (_u8 *)(pData);
+    Msg.Cmd.Offset       = Offset;
+    Msg.Cmd.Len          = ChunkLen;
+    Msg.Cmd.FileHandle   = (_u32)FileHdl;
+    do
+    {
+        RetVal = _SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsReadCmdCtrl, &Msg, &ExtCtrl);
+        if(SL_OS_RET_CODE_OK == RetVal)
+        {
+            if( Msg.Rsp.status < 0)
+            {
+                if( RetCount > 0)
+                {
+                   return RetCount;
+                }
+                else
+                {
+                   return Msg.Rsp.status;
+                }
+            }
+            RetCount += (_i32)Msg.Rsp.status;
+            Len -= ChunkLen;
+            Offset += ChunkLen;
+            Msg.Cmd.Offset      = Offset;
+            ExtCtrl.pRxPayload   += ChunkLen;
+            ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
+            ExtCtrl.RxPayloadLen  = (_i16)ChunkLen;
+            Msg.Cmd.Len           = ChunkLen;
+            Msg.Cmd.FileHandle  = (_u32)FileHdl;
+        }
+        else
+        {
+            return RetVal;
+        }
+    }while(ChunkLen > 0);
+
+    return (_i32)RetCount;
+}
+#endif
+
+/*****************************************************************************/
+/* sl_FsWrite */ 
+/*****************************************************************************/
+typedef union
+{
+	_FsWriteCommand_t	    Cmd;
+	_FsWriteResponse_t	    Rsp;
+}_SlFsWriteMsg_u;
+
+
+#if _SL_INCLUDE_FUNC(sl_FsWrite)
+
+static const _SlCmdCtrl_t _SlFsWriteCmdCtrl =
+{
+    SL_OPCODE_NVMEM_FILEWRITECOMMAND,
+    (_SlArgSize_t)sizeof(_FsWriteCommand_t),
+    (_SlArgSize_t)sizeof(_FsWriteResponse_t)
+};
+
+_i32 sl_FsWrite(const _i32 FileHdl,_u32 Offset, _u8*  pData,_u32 Len)
+{
+    _SlFsWriteMsg_u     Msg;
+    _SlCmdExt_t         ExtCtrl;
+    _u16      ChunkLen;
+    _SlReturnVal_t      RetVal;
+    _i32                RetCount = 0;
+
+    /* verify no erorr handling in progress. if in progress than
+      ignore the API execution and return immediately with an error */
+    VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
+
+    ExtCtrl.RxPayloadLen = 0;
+    ExtCtrl.pRxPayload   = NULL;
+
+    ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
+    ExtCtrl.TxPayloadLen = ChunkLen;
+    ExtCtrl.pTxPayload   = (_u8 *)(pData);
+    Msg.Cmd.Offset      = Offset;
+    Msg.Cmd.Len          = ChunkLen;
+    Msg.Cmd.FileHandle  = (_u32)FileHdl;
+
+    do
+    {
+    
+        RetVal = _SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsWriteCmdCtrl, &Msg, &ExtCtrl);
+        if(SL_OS_RET_CODE_OK == RetVal)
+        {
+            if( Msg.Rsp.status < 0)
+            {
+                if( RetCount > 0)
+                {
+                   return RetCount;
+                }
+                else
+                {
+                   return Msg.Rsp.status;
+                }
+            }
+
+            RetCount += (_i32)Msg.Rsp.status;
+            Len -= ChunkLen;
+            Offset += ChunkLen;
+            Msg.Cmd.Offset        = Offset;
+            ExtCtrl.pTxPayload   += ChunkLen;
+            ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
+            ExtCtrl.TxPayloadLen  = ChunkLen;
+            Msg.Cmd.Len           = ChunkLen;
+            Msg.Cmd.FileHandle  = (_u32)FileHdl;
+        }
+        else
+        {
+            return RetVal;
+        }
+    }while(ChunkLen > 0);
+
+    return (_i32)RetCount;
+}
+#endif
+
+/*****************************************************************************/
+/* sl_FsGetInfo */ 
+/*****************************************************************************/
+typedef union
+{
+	_FsGetInfoCommand_t	    Cmd;
+	_FsGetInfoResponse_t    Rsp;
+}_SlFsGetInfoMsg_u;
+
+
+#if _SL_INCLUDE_FUNC(sl_FsGetInfo)
+
+
+static const _SlCmdCtrl_t _SlFsGetInfoCmdCtrl =
+{
+    SL_OPCODE_NVMEM_FILEGETINFOCOMMAND,
+    (_SlArgSize_t)sizeof(_FsGetInfoCommand_t),
+    (_SlArgSize_t)sizeof(_FsGetInfoResponse_t)
+};
+
+_i16 sl_FsGetInfo(const _u8 *pFileName,const _u32 Token,SlFsFileInfo_t* pFsFileInfo)
+{
+    _SlFsGetInfoMsg_u    Msg;
+    _SlCmdExt_t          CmdExt;
+
+    /* verify no erorr handling in progress. if in progress than
+      ignore the API execution and return immediately with an error */
+    VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
+
+    CmdExt.TxPayloadLen = (_u16)((_sl_Strlen(pFileName)+4) & (~3)); /* add 4: 1 for NULL and the 3 for align  */
+    CmdExt.RxPayloadLen = 0;
+    CmdExt.pTxPayload   = (_u8*)pFileName;
+    CmdExt.pRxPayload   = NULL;
+    Msg.Cmd.Token       = Token;
+
+    VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsGetInfoCmdCtrl, &Msg, &CmdExt));
+
+    pFsFileInfo->flags        = Msg.Rsp.flags;
+    pFsFileInfo->FileLen      = Msg.Rsp.FileLen;
+    pFsFileInfo->AllocatedLen = Msg.Rsp.AllocatedLen;
+    pFsFileInfo->Token[0]     = Msg.Rsp.Token[0];
+    pFsFileInfo->Token[1]     = Msg.Rsp.Token[1];
+    pFsFileInfo->Token[2]     = Msg.Rsp.Token[2];
+    pFsFileInfo->Token[3]     = Msg.Rsp.Token[3];
+    return  (_i16)((_i16)Msg.Rsp.Status);
+}
+#endif
+
+/*****************************************************************************/
+/* sl_FsDel */ 
+/*****************************************************************************/
+typedef union
+{
+	_FsDeleteCommand_t   	    Cmd;
+	_FsDeleteResponse_t	        Rsp;
+}_SlFsDeleteMsg_u;
+
+
+#if _SL_INCLUDE_FUNC(sl_FsDel)
+
+static const _SlCmdCtrl_t _SlFsDeleteCmdCtrl =
+{
+    SL_OPCODE_NVMEM_FILEDELCOMMAND,
+    (_SlArgSize_t)sizeof(_FsDeleteCommand_t),
+    (_SlArgSize_t)sizeof(_FsDeleteResponse_t)
+};
+
+_i16 sl_FsDel(const _u8 *pFileName,const _u32 Token)
+{
+    _SlFsDeleteMsg_u Msg;
+    _SlCmdExt_t          CmdExt;
+
+    /* verify no erorr handling in progress. if in progress than
+    ignore the API execution and return immediately with an error */
+    VERIFY_NO_ERROR_HANDLING_IN_PROGRESS();
+    CmdExt.TxPayloadLen = (_u16)((_sl_Strlen(pFileName)+4) & (~3)); /* add 4: 1 for NULL and the 3 for align */
+    CmdExt.RxPayloadLen = 0;
+    CmdExt.pTxPayload   = (_u8*)pFileName;
+    CmdExt.pRxPayload   = NULL;
+    Msg.Cmd.Token       = Token;
+
+
+    VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsDeleteCmdCtrl, &Msg, &CmdExt));
+
+    return  (_i16)((_i16)Msg.Rsp.status);
+}
+#endif