cc3100_fs.cpp

00001 /*
00002  * fs.c - CC31xx/CC32xx Host Driver Implementation
00003  *
00004  * Copyright (C) 2014 Texas Instruments Incorporated - http://www.ti.com/ 
00005  * 
00006  * 
00007  *  Redistribution and use in source and binary forms, with or without 
00008  *  modification, are permitted provided that the following conditions 
00009  *  are met:
00010  *
00011  *    Redistributions of source code must retain the above copyright 
00012  *    notice, this list of conditions and the following disclaimer.
00013  *
00014  *    Redistributions in binary form must reproduce the above copyright
00015  *    notice, this list of conditions and the following disclaimer in the 
00016  *    documentation and/or other materials provided with the   
00017  *    distribution.
00018  *
00019  *    Neither the name of Texas Instruments Incorporated nor the names of
00020  *    its contributors may be used to endorse or promote products derived
00021  *    from this software without specific prior written permission.
00022  *
00023  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
00024  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
00025  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00026  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 
00027  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
00028  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 
00029  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
00030  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
00031  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
00032  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
00033  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00034  *
00035 */
00036 
00037 
00038 
00039 /*****************************************************************************/
00040 /* Include files                                                             */
00041 /*****************************************************************************/
00042 #include "cc3100_simplelink.h"
00043 #include "cc3100_protocol.h"
00044 #include "cc3100_driver.h"
00045 
00046 /*****************************************************************************/
00047 /* Macro declarations                                                        */
00048 /*****************************************************************************/
00049 #define sl_min(a,b) (((a) < (b)) ? (a) : (b))
00050 #define MAX_NVMEM_CHUNK_SIZE  1460
00051 
00052 /*****************************************************************************/
00053 /* Internal functions                                                        */
00054 /*****************************************************************************/
00055 
00056 
00057 /*****************************************************************************/
00058 /* _sl_Strlen                                                                */
00059 /*****************************************************************************/
00060 _u16 _sl_Strlen(const _u8 *buffer)
00061 {
00062     _u16 len = 0;
00063     if( buffer != NULL )
00064     {
00065       while(*buffer++) len++;
00066     }
00067     return len;
00068 }
00069 
00070 /*****************************************************************************/
00071 /* _sl_GetCreateFsMode                                                       */
00072 /*****************************************************************************/
00073 _u32 _sl_GetCreateFsMode(_u32 maxSizeInBytes,_u32 accessFlags)
00074 {
00075    _u32 granIdx = 0;
00076    _u32 granNum = 0;
00077    _u32 granTable[_FS_MAX_MODE_SIZE_GRAN] = {256,1024,4096,16384,65536}; 
00078    for(granIdx= _FS_MODE_SIZE_GRAN_256B ;granIdx< _FS_MAX_MODE_SIZE_GRAN;granIdx++) 
00079    {                                                       
00080        if( granTable[granIdx]*255 >= maxSizeInBytes ) 
00081             break;                                                      
00082    }                                                                 
00083    granNum = maxSizeInBytes/granTable[granIdx];
00084    if( maxSizeInBytes % granTable[granIdx] != 0 )
00085          granNum++;
00086 
00087    return _FS_MODE(_FS_MODE_OPEN_WRITE_CREATE_IF_NOT_EXIST,  granIdx, granNum, accessFlags);
00088 }
00089 
00090 
00091 /*****************************************************************************/
00092 /* API functions                                                        */
00093 /*****************************************************************************/
00094 
00095 /*****************************************************************************/
00096 /*  sl_FsOpen */ 
00097 /*****************************************************************************/
00098 typedef union
00099 {
00100     _FsOpenCommand_t        Cmd;
00101     _FsOpenResponse_t       Rsp;
00102 }_SlFsOpenMsg_u;
00103 
00104 const _SlCmdCtrl_t _SlFsOpenCmdCtrl =
00105 {
00106     SL_OPCODE_NVMEM_FILEOPEN,
00107     sizeof(_FsOpenCommand_t),
00108     sizeof(_FsOpenResponse_t)
00109 };
00110 
00111 #if _SL_INCLUDE_FUNC(sl_FsOpen)
00112 _i32 sl_FsOpen(_u8 *pFileName,_u32 AccessModeAndMaxSize, _u32 *pToken,_i32 *pFileHandle)
00113 {
00114     _SlReturnVal_t        RetVal;
00115     _SlFsOpenMsg_u        Msg;
00116     _SlCmdExt_t           CmdExt;
00117 
00118     CmdExt.TxPayloadLen = (_sl_Strlen(pFileName)+4) & (~3); // add 4: 1 for NULL and the 3 for align 
00119     CmdExt.RxPayloadLen = 0;
00120     CmdExt.pTxPayload = pFileName;
00121     CmdExt.pRxPayload = NULL;
00122 
00123     Msg.Cmd.Mode          =  AccessModeAndMaxSize; 
00124 
00125     if(pToken != NULL)
00126     {
00127        Msg.Cmd.Token         = *pToken;
00128     }
00129     else
00130     {
00131        Msg.Cmd.Token         = 0;
00132     }
00133 
00134     RetVal = _SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsOpenCmdCtrl, &Msg, &CmdExt);
00135     *pFileHandle = Msg.Rsp.FileHandle;
00136     if (pToken != NULL)
00137     {
00138         *pToken =      Msg.Rsp.Token;
00139     }
00140        
00141     /* in case of an error, return the erros file handler as an error code */
00142     if( *pFileHandle < 0 )
00143     {
00144        return *pFileHandle;
00145     }
00146     return (_i32)RetVal;
00147 }
00148 #endif
00149 
00150 /*****************************************************************************/
00151 /* sl_FsClose */ 
00152 /*****************************************************************************/
00153 typedef union
00154 {
00155     _FsCloseCommand_t       Cmd;
00156     _BasicResponse_t        Rsp;
00157 }_SlFsCloseMsg_u;
00158 
00159 const _SlCmdCtrl_t _SlFsCloseCmdCtrl =
00160 {
00161     SL_OPCODE_NVMEM_FILECLOSE,
00162     sizeof(_FsCloseCommand_t),
00163     sizeof(_FsCloseResponse_t)
00164 };
00165 
00166 #if _SL_INCLUDE_FUNC(sl_FsClose)
00167 _i16 sl_FsClose(_i32 FileHdl, _u8*  pCeritificateFileName,_u8*  pSignature ,_u32 SignatureLen)
00168 {
00169     _SlFsCloseMsg_u Msg = {0};
00170     _SlCmdExt_t         ExtCtrl;
00171     
00172     Msg.Cmd.FileHandle             = FileHdl;
00173     if( pCeritificateFileName != NULL )
00174     {
00175         Msg.Cmd.CertificFileNameLength = (_sl_Strlen(pCeritificateFileName)+4) & (~3); /* add 4: 1 for NULL and the 3 for align */
00176     }
00177     Msg.Cmd.SignatureLen           = SignatureLen;
00178     
00179     ExtCtrl.TxPayloadLen = ((SignatureLen+3) & (~3)); /* align */
00180     ExtCtrl.pTxPayload   = pSignature;
00181     ExtCtrl.RxPayloadLen = (_u16)Msg.Cmd.CertificFileNameLength;
00182     ExtCtrl.pRxPayload   = pCeritificateFileName; /* Add signature */
00183     
00184     if(ExtCtrl.pRxPayload != NULL &&  ExtCtrl.RxPayloadLen != 0)
00185     {
00186         g_pCB->RelayFlagsViaRxPayload = TRUE;
00187     }
00188 
00189     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsCloseCmdCtrl, &Msg, &ExtCtrl));
00190 
00191     return (_i16)((_i16)Msg.Rsp.status);
00192 }
00193 #endif
00194 
00195 
00196 /*****************************************************************************/
00197 /* sl_FsRead */ 
00198 /*****************************************************************************/
00199 typedef union
00200 {
00201     _FsReadCommand_t        Cmd;
00202     _FsReadResponse_t       Rsp;
00203 }_SlFsReadMsg_u;
00204 
00205 const _SlCmdCtrl_t _SlFsReadCmdCtrl =
00206 {
00207     SL_OPCODE_NVMEM_FILEREADCOMMAND,
00208     sizeof(_FsReadCommand_t),
00209     sizeof(_FsReadResponse_t)
00210 };
00211 
00212  
00213 #if _SL_INCLUDE_FUNC(sl_FsRead)
00214 _i32 sl_FsRead(_i32 FileHdl, _u32 Offset, _u8*  pData, _u32 Len)
00215 {
00216     _SlFsReadMsg_u      Msg;
00217     _SlCmdExt_t         ExtCtrl;
00218     _u16      ChunkLen;
00219     _SlReturnVal_t      RetVal =0;
00220     _i32                RetCount = 0;
00221 
00222     ExtCtrl.TxPayloadLen = 0;
00223     ExtCtrl.pTxPayload   = NULL;
00224 
00225     ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
00226     ExtCtrl.RxPayloadLen = ChunkLen;
00227     ExtCtrl.pRxPayload   = (_u8 *)(pData);
00228     Msg.Cmd.Offset       = Offset;
00229     Msg.Cmd.Len          = ChunkLen;
00230     Msg.Cmd.FileHandle   = FileHdl;
00231     do
00232     {
00233         RetVal = _SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsReadCmdCtrl, &Msg, &ExtCtrl);
00234         if(SL_OS_RET_CODE_OK == RetVal)
00235         {
00236             if( Msg.Rsp.status < 0)
00237             {
00238                 if( RetCount > 0)
00239                 {
00240                    return RetCount;
00241                 }
00242                 else
00243                 {
00244                    return Msg.Rsp.status;
00245                 }
00246             }
00247             RetCount += (_i32)Msg.Rsp.status;
00248             Len -= ChunkLen;
00249             Offset += ChunkLen;
00250             Msg.Cmd.Offset      = Offset;
00251             ExtCtrl.pRxPayload   += ChunkLen;
00252             ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
00253             ExtCtrl.RxPayloadLen  = ChunkLen;
00254             Msg.Cmd.Len           = ChunkLen;
00255             Msg.Cmd.FileHandle  = FileHdl;
00256         }
00257         else
00258         {
00259             return RetVal;
00260         }
00261     }while(ChunkLen > 0);
00262 
00263     return (_i32)RetCount;
00264 }
00265 #endif
00266 
00267 /*****************************************************************************/
00268 /* sl_FsWrite */ 
00269 /*****************************************************************************/
00270 typedef union
00271 {
00272     _FsWriteCommand_t       Cmd;
00273     _FsWriteResponse_t      Rsp;
00274 }_SlFsWriteMsg_u;
00275 
00276 const _SlCmdCtrl_t _SlFsWriteCmdCtrl =
00277 {
00278     SL_OPCODE_NVMEM_FILEWRITECOMMAND,
00279     sizeof(_FsWriteCommand_t),
00280     sizeof(_FsWriteResponse_t)
00281 };
00282 
00283 
00284 #if _SL_INCLUDE_FUNC(sl_FsWrite)
00285 _i32 sl_FsWrite(_i32 FileHdl, _u32 Offset, _u8*  pData, _u32 Len)
00286 {
00287     _SlFsWriteMsg_u     Msg;
00288     _SlCmdExt_t         ExtCtrl;
00289     _u16      ChunkLen;
00290     _SlReturnVal_t      RetVal;
00291     _i32                RetCount = 0;
00292 
00293     ExtCtrl.RxPayloadLen = 0;
00294     ExtCtrl.pRxPayload   = NULL;
00295 
00296     ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
00297     ExtCtrl.TxPayloadLen = ChunkLen;
00298     ExtCtrl.pTxPayload   = (_u8 *)(pData);
00299     Msg.Cmd.Offset      = Offset;
00300     Msg.Cmd.Len          = ChunkLen;
00301     Msg.Cmd.FileHandle  = FileHdl;
00302 
00303     do
00304     {
00305     
00306         RetVal = _SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsWriteCmdCtrl, &Msg, &ExtCtrl);
00307         if(SL_OS_RET_CODE_OK == RetVal)
00308         {
00309             if( Msg.Rsp.status < 0)
00310             {
00311                 if( RetCount > 0)
00312                 {
00313                    return RetCount;
00314                 }
00315                 else
00316                 {
00317                    return Msg.Rsp.status;
00318                 }
00319             }
00320 
00321             RetCount += (_i32)Msg.Rsp.status;
00322             Len -= ChunkLen;
00323             Offset += ChunkLen;
00324             Msg.Cmd.Offset        = Offset;
00325             ExtCtrl.pTxPayload   += ChunkLen;
00326             ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
00327             ExtCtrl.TxPayloadLen  = ChunkLen;
00328             Msg.Cmd.Len           = ChunkLen;
00329             Msg.Cmd.FileHandle  = FileHdl;
00330         }
00331         else
00332         {
00333             return RetVal;
00334         }
00335     }while(ChunkLen > 0);
00336 
00337     return (_i32)RetCount;
00338 }
00339 #endif
00340 
00341 /*****************************************************************************/
00342 /* sl_FsGetInfo */ 
00343 /*****************************************************************************/
00344 typedef union
00345 {
00346     _FsGetInfoCommand_t     Cmd;
00347     _FsGetInfoResponse_t    Rsp;
00348 }_SlFsGetInfoMsg_u;
00349 
00350 const _SlCmdCtrl_t _SlFsGetInfoCmdCtrl =
00351 {
00352     SL_OPCODE_NVMEM_FILEGETINFOCOMMAND,
00353     sizeof(_FsGetInfoCommand_t),
00354     sizeof(_FsGetInfoResponse_t)
00355 };
00356 
00357 #if _SL_INCLUDE_FUNC(sl_FsGetInfo)
00358 _i16 sl_FsGetInfo(_u8 *pFileName,_u32 Token,SlFsFileInfo_t* pFsFileInfo)
00359 {
00360     _SlFsGetInfoMsg_u    Msg;
00361     _SlCmdExt_t          CmdExt;
00362 
00363     CmdExt.TxPayloadLen = (_sl_Strlen(pFileName)+4) & (~3); /* add 4: 1 for NULL and the 3 for align  */
00364     CmdExt.RxPayloadLen = 0;
00365     CmdExt.pTxPayload   = pFileName;
00366     CmdExt.pRxPayload   = NULL;
00367     Msg.Cmd.Token       = Token;
00368 
00369     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsGetInfoCmdCtrl, &Msg, &CmdExt));
00370 
00371     pFsFileInfo->flags        = Msg.Rsp.flags;
00372     pFsFileInfo->FileLen      = Msg.Rsp.FileLen;
00373     pFsFileInfo->AllocatedLen = Msg.Rsp.AllocatedLen;
00374     pFsFileInfo->Token[0]     = Msg.Rsp.Token[0];
00375     pFsFileInfo->Token[1]     = Msg.Rsp.Token[1];
00376     pFsFileInfo->Token[2]     = Msg.Rsp.Token[2];
00377     pFsFileInfo->Token[3]     = Msg.Rsp.Token[3];
00378     return  (_i16)((_i16)Msg.Rsp.Status);
00379 }
00380 #endif
00381 
00382 /*****************************************************************************/
00383 /* sl_FsDel */ 
00384 /*****************************************************************************/
00385 typedef union
00386 {
00387     _FsDeleteCommand_t          Cmd;
00388     _FsDeleteResponse_t         Rsp;
00389 }_SlFsDeleteMsg_u;
00390 
00391 const _SlCmdCtrl_t _SlFsDeleteCmdCtrl =
00392 {
00393     SL_OPCODE_NVMEM_FILEDELCOMMAND,
00394     sizeof(_FsDeleteCommand_t),
00395     sizeof(_FsDeleteResponse_t)
00396 };
00397 
00398 #if _SL_INCLUDE_FUNC(sl_FsDel)
00399 _i16 sl_FsDel(_u8 *pFileName,_u32 Token)
00400 {
00401     _SlFsDeleteMsg_u Msg;
00402     _SlCmdExt_t          CmdExt;
00403 
00404     CmdExt.TxPayloadLen = (_sl_Strlen(pFileName)+4) & (~3); /* add 4: 1 for NULL and the 3 for align */
00405     CmdExt.RxPayloadLen = 0;
00406     CmdExt.pTxPayload   = pFileName;
00407     CmdExt.pRxPayload   = NULL;
00408     Msg.Cmd.Token       = Token;
00409 
00410 
00411     VERIFY_RET_OK(_SlDrvCmdOp((_SlCmdCtrl_t *)&_SlFsDeleteCmdCtrl, &Msg, &CmdExt));
00412 
00413     return  (_i16)((_i16)Msg.Rsp.status);
00414 }
00415 #endif
00416