41 #include <ti/drivers/net/wifi/simplelink.h> 42 #include <ti/drivers/net/wifi/source/protocol.h> 43 #include <ti/drivers/net/wifi/source/driver.h> 48 #define sl_min(a,b) (((a) < (b)) ? (a) : (b)) 49 #define MAX_NVMEM_CHUNK_SIZE 1456 56 static _u16 _SlFsStrlen(
const _u8 *buffer);
58 static _u32 FsGetCreateFsMode(_u8 Mode, _u32 MaxSizeInBytes,_u32 AccessFlags);
63 static _u16 _SlFsStrlen(
const _u8 *buffer)
68 while(*buffer++) len++;
78 #define FS_CONVERT_FLAGS( ModeAndMaxSize ) (((_u32)ModeAndMaxSize & SL_FS_OPEN_FLAGS_BIT_MASK)>>SL_NUM_OF_MAXSIZE_BIT) 82 FS_MODE_OPEN_READ = 0,
85 FS_MODE_OPEN_WRITE_CREATE_IF_NOT_EXIST
86 }FsFileOpenAccessType_e;
88 #define FS_MODE_ACCESS_RESERVED_OFFSET (27) 89 #define FS_MODE_ACCESS_RESERVED_MASK (0x1F) 90 #define FS_MODE_ACCESS_FLAGS_OFFSET (16) 91 #define FS_MODE_ACCESS_FLAGS_MASK (0x7FF) 92 #define FS_MODE_ACCESS_OFFSET (12) 93 #define FS_MODE_ACCESS_MASK (0xF) 94 #define FS_MODE_OPEN_SIZE_GRAN_OFFSET (8) 95 #define FS_MODE_OPEN_SIZE_GRAN_MASK (0xF) 96 #define FS_MODE_OPEN_SIZE_OFFSET (0) 97 #define FS_MODE_OPEN_SIZE_MASK (0xFF) 98 #define FS_MAX_MODE_SIZE (0xFF) 101 #define FS_MODE(Access, SizeGran, Size,Flags) (_u32)(((_u32)((Access) &FS_MODE_ACCESS_MASK)<<FS_MODE_ACCESS_OFFSET) | \ 102 ((_u32)((SizeGran) &FS_MODE_OPEN_SIZE_GRAN_MASK)<<FS_MODE_OPEN_SIZE_GRAN_OFFSET) | \ 103 ((_u32)((Size) &FS_MODE_OPEN_SIZE_MASK)<<FS_MODE_OPEN_SIZE_OFFSET) | \ 104 ((_u32)((Flags) &FS_MODE_ACCESS_FLAGS_MASK)<<FS_MODE_ACCESS_FLAGS_OFFSET)) 109 FS_MODE_SIZE_GRAN_256B = 0,
110 FS_MODE_SIZE_GRAN_1KB,
111 FS_MODE_SIZE_GRAN_4KB,
112 FS_MODE_SIZE_GRAN_16KB,
113 FS_MODE_SIZE_GRAN_64KB,
114 FS_MAX_MODE_SIZE_GRAN
115 }FsFileOpenMaxSizeGran_e;
120 static _u32 FsGetCreateFsMode(_u8 Mode, _u32 MaxSizeInBytes,_u32 AccessFlags)
124 _u32 granTable[FS_MAX_MODE_SIZE_GRAN] = {256,1024,4096,16384,65536};
126 for(granIdx= FS_MODE_SIZE_GRAN_256B ;granIdx< FS_MAX_MODE_SIZE_GRAN;granIdx++)
128 if( granTable[granIdx]*255 >= MaxSizeInBytes )
131 granNum = MaxSizeInBytes/granTable[granIdx];
132 if( MaxSizeInBytes % granTable[granIdx] != 0 )
135 return (_u32)FS_MODE( Mode, granIdx, granNum, AccessFlags );
154 #if _SL_INCLUDE_FUNC(sl_FsOpen) 158 SL_OPCODE_NVMEM_FILEOPEN,
163 _i32
sl_FsOpen(
const _u8 *pFileName,
const _u32 ModeAndMaxSize, _u32 *pToken)
175 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
179 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
181 return SL_ERROR_FS_WRONG_FILE_NAME;
184 CmdExt.TxPayload1Len = (_u16)((_SlFsStrlen(pFileName)+4) & (~3));
185 CmdExt.pTxPayload1 = (_u8*)pFileName;
187 OpenMode = ModeAndMaxSize & SL_FS_OPEN_MODE_BIT_MASK;
190 if( OpenMode == SL_FS_READ )
192 Msg.Cmd.Mode = FS_MODE(FS_MODE_OPEN_READ, 0, 0, 0);
194 else if (( OpenMode == SL_FS_WRITE ) ||( OpenMode == SL_FS_OVERWRITE))
196 Msg.Cmd.Mode = FS_MODE(FS_MODE_OPEN_WRITE, 0, 0, FS_CONVERT_FLAGS ( ModeAndMaxSize));
199 else if ( ( OpenMode == (SL_FS_CREATE | SL_FS_OVERWRITE )) || ( OpenMode == SL_FS_CREATE) ||(OpenMode == (SL_FS_CREATE | SL_FS_WRITE )))
202 MaxSizeInBytes = (ModeAndMaxSize & SL_FS_OPEN_MAXSIZE_BIT_MASK) * 256;
203 if (MaxSizeInBytes > 0xFF0000 )
205 return SL_ERROR_FS_FILE_MAX_SIZE_EXCEEDED;
208 CreateMode = ((OpenMode == (SL_FS_CREATE | SL_FS_OVERWRITE )) ? FS_MODE_OPEN_WRITE_CREATE_IF_NOT_EXIST : FS_MODE_OPEN_CREATE );
210 Msg.Cmd.Mode = FsGetCreateFsMode( CreateMode ,MaxSizeInBytes, FS_CONVERT_FLAGS ( ModeAndMaxSize) );
214 return SL_ERROR_FS_UNVALID_FILE_MODE;
219 Msg.Cmd.Token = *pToken;
226 _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsOpenCmdCtrl, &Msg, &CmdExt);
227 FileHandle = (_i32)Msg.Rsp.FileHandle;
230 *pToken = Msg.Rsp.Token;
247 #if _SL_INCLUDE_FUNC(sl_FsClose) 251 SL_OPCODE_NVMEM_FILECLOSE,
256 _i16
sl_FsClose(
const _i32 FileHdl,
const _u8* pCeritificateFileName,
const _u8* pSignature ,
const _u32 SignatureLen)
265 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
267 Msg.Cmd.FileHandle = (_u32)FileHdl;
268 if( pCeritificateFileName != NULL )
270 Msg.Cmd.CertificFileNameLength = (_u32)((_SlFsStrlen(pCeritificateFileName)+4) & (~3));
272 Msg.Cmd.SignatureLen = SignatureLen;
274 _SlDrvMemZero(&ExtCtrl, (_u16)
sizeof(
_SlCmdExt_t));
276 ExtCtrl.TxPayload1Len = (_u16)(((SignatureLen+3) & (~3)));
277 ExtCtrl.pTxPayload1 = (_u8*)pSignature;
278 ExtCtrl.RxPayloadLen = (_i16)Msg.Cmd.CertificFileNameLength;
279 ExtCtrl.pRxPayload = (_u8*)pCeritificateFileName;
281 if(ExtCtrl.pRxPayload != NULL && ExtCtrl.RxPayloadLen != 0)
283 ExtCtrl.RxPayloadLen = ExtCtrl.RxPayloadLen * (-1);
286 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsCloseCmdCtrl, &Msg, &ExtCtrl));
288 return (_i16)((_i16)Msg.Rsp.status);
302 #if _SL_INCLUDE_FUNC(sl_FsRead) 306 SL_OPCODE_NVMEM_FILEREADCOMMAND,
311 _i32
sl_FsRead(
const _i32 FileHdl,_u32 Offset, _u8* pData,_u32 Len)
316 _SlReturnVal_t RetVal =0;
321 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
323 _SlDrvMemZero(&ExtCtrl, (_u16)
sizeof(
_SlCmdExt_t));
325 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
326 ExtCtrl.RxPayloadLen = (_i16)ChunkLen;
327 ExtCtrl.pRxPayload = (_u8 *)(pData);
328 Msg.Cmd.Offset = Offset;
329 Msg.Cmd.Len = ChunkLen;
330 Msg.Cmd.FileHandle = (_u32)FileHdl;
333 RetVal = _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsReadCmdCtrl, &Msg, &ExtCtrl);
334 if(SL_OS_RET_CODE_OK == RetVal)
336 if( Msg.Rsp.status < 0)
344 return Msg.Rsp.status;
347 RetCount += (_i32)Msg.Rsp.status;
350 Msg.Cmd.Offset = Offset;
351 ExtCtrl.pRxPayload += ChunkLen;
352 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
353 ExtCtrl.RxPayloadLen = (_i16)ChunkLen;
354 Msg.Cmd.Len = ChunkLen;
355 Msg.Cmd.FileHandle = (_u32)FileHdl;
361 }
while(ChunkLen > 0);
363 return (_i32)RetCount;
376 #if _SL_INCLUDE_FUNC(sl_FsWrite) 380 SL_OPCODE_NVMEM_FILEWRITECOMMAND,
385 _i32
sl_FsWrite(
const _i32 FileHdl,_u32 Offset, _u8* pData,_u32 Len)
390 _SlReturnVal_t RetVal;
395 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
397 _SlDrvMemZero(&ExtCtrl, (_u16)
sizeof(
_SlCmdExt_t));
399 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
400 ExtCtrl.TxPayload1Len = ChunkLen;
401 ExtCtrl.pTxPayload1 = (_u8 *)(pData);
402 Msg.Cmd.Offset = Offset;
403 Msg.Cmd.Len = ChunkLen;
404 Msg.Cmd.FileHandle = (_u32)FileHdl;
408 RetVal = _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsWriteCmdCtrl, &Msg, &ExtCtrl);
409 if(SL_OS_RET_CODE_OK == RetVal)
411 if( Msg.Rsp.status < 0)
419 return Msg.Rsp.status;
423 RetCount += (_i32)Msg.Rsp.status;
426 Msg.Cmd.Offset = Offset;
427 ExtCtrl.pTxPayload1 += ChunkLen;
428 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
429 ExtCtrl.TxPayload1Len = ChunkLen;
430 Msg.Cmd.Len = ChunkLen;
431 Msg.Cmd.FileHandle = (_u32)FileHdl;
437 }
while(ChunkLen > 0);
439 return (_i32)RetCount;
452 #if _SL_INCLUDE_FUNC(sl_FsGetInfo) 456 SL_OPCODE_NVMEM_FILEGETINFOCOMMAND,
461 const _u16 FlagsTranslate[] =
463 SL_FS_INFO_OPEN_WRITE,
464 SL_FS_INFO_OPEN_READ,
465 SL_FS_INFO_NOT_FAILSAFE,
466 SL_FS_INFO_NOT_VALID,
468 SL_FS_INFO_MUST_COMMIT,
469 SL_FS_INFO_BUNDLE_FILE,
470 SL_FS_INFO_PENDING_COMMIT,
471 SL_FS_INFO_PENDING_BUNDLE_COMMIT,
474 SL_FS_INFO_NOSIGNATURE,
475 SL_FS_INFO_PUBLIC_WRITE,
476 SL_FS_INFO_PUBLIC_READ,
483 _SlFsGetInfoMsg_u Msg;
489 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
493 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
495 return SL_ERROR_FS_WRONG_FILE_NAME;
498 CmdExt.TxPayload1Len = (_u16)((_SlFsStrlen(pFileName)+4) & (~3));
499 CmdExt.pTxPayload1 = (_u8*)pFileName;
501 Msg.Cmd.Token = Token;
503 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsGetInfoCmdCtrl, &Msg, &CmdExt));
506 pFsFileInfo->Flags = 0;
507 for (BitNum = 0; BitNum < 16; BitNum++ )
509 if (( Msg.Rsp.Flags >> BitNum) & 0x1 )
511 pFsFileInfo->Flags |= FlagsTranslate[BitNum];
515 pFsFileInfo->Len = Msg.Rsp.FileLen;
516 pFsFileInfo->MaxSize = Msg.Rsp.AllocatedLen;
517 pFsFileInfo->Token[0] = Msg.Rsp.Token[0];
518 pFsFileInfo->Token[1] = Msg.Rsp.Token[1];
519 pFsFileInfo->Token[2] = Msg.Rsp.Token[2];
520 pFsFileInfo->Token[3] = Msg.Rsp.Token[3];
521 pFsFileInfo->StorageSize = Msg.Rsp.FileStorageSize;
522 pFsFileInfo->WriteCounter = Msg.Rsp.FileWriteCounter;
524 return (_i16)((_i16)Msg.Rsp.Status);
538 #if _SL_INCLUDE_FUNC(sl_FsDel) 542 SL_OPCODE_NVMEM_FILEDELCOMMAND,
547 _i16
sl_FsDel(
const _u8 *pFileName,
const _u32 Token)
549 _SlFsDeleteMsg_u Msg;
554 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
556 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
558 return SL_ERROR_FS_WRONG_FILE_NAME;
563 CmdExt.TxPayload1Len = (_u16)((_SlFsStrlen(pFileName)+4) & (~3));
564 CmdExt.pTxPayload1 = (_u8*)pFileName;
565 Msg.Cmd.Token = Token;
567 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsDeleteCmdCtrl, &Msg, &CmdExt));
569 return (_i16)((_i16)Msg.Rsp.status);
580 }_SlFsFileSysControlMsg_u;
582 #if _SL_INCLUDE_FUNC(sl_FsCtl) 586 SL_OPCODE_NVMEM_NVMEMFILESYSTEMCONTROLCOMMAND,
591 _i32
sl_FsCtl( SlFsCtl_e Command, _u32 Token, _u8 *pFileName,
const _u8 *pData, _u16 DataLen, _u8 *pOutputData, _u16 OutputDataLen,_u32 *pNewToken )
593 _SlFsFileSysControlMsg_u Msg;
598 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
600 Msg.Cmd.Token = Token;
601 Msg.Cmd.Operation = (_u8)Command;
605 if ((SL_FS_CTL_ROLLBACK == Command) || (SL_FS_CTL_COMMIT == Command ))
607 Msg.Cmd.FileNameLength = _SlFsStrlen(pFileName) + 1 ;
609 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
611 return SL_ERROR_FS_WRONG_FILE_NAME;
615 CmdExt.RxPayloadLen = DataLen;
616 CmdExt.pRxPayload = (_u8 *)(pData);
618 CmdExt.TxPayload1Len = (_SlFsStrlen(pFileName) + 4) & (~3);
619 CmdExt.pTxPayload1 = pFileName;
621 Msg.Cmd.BufferLength = CmdExt.RxPayloadLen + CmdExt.TxPayload1Len;
623 if(CmdExt.pRxPayload != NULL && CmdExt.RxPayloadLen != 0)
625 CmdExt.RxPayloadLen = CmdExt.RxPayloadLen * (-1);
628 else if( SL_FS_CTL_RENAME == Command )
630 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
632 return SL_ERROR_FS_WRONG_FILE_NAME;
635 Msg.Cmd.FileNameLength = (_SlFsStrlen(pFileName) + 4) & (~3);
638 CmdExt.RxPayloadLen = (_u16)Msg.Cmd.FileNameLength;
639 CmdExt.pRxPayload = pFileName;
642 CmdExt.TxPayload1Len = (_SlFsStrlen(pData) + 4) & (~3);;
643 CmdExt.pTxPayload1 = (_u8 *)(pData);
645 Msg.Cmd.BufferLength = CmdExt.RxPayloadLen + CmdExt.TxPayload1Len;
647 if(CmdExt.pRxPayload != NULL && CmdExt.RxPayloadLen != 0)
649 CmdExt.RxPayloadLen = CmdExt.RxPayloadLen * (-1);
654 Msg.Cmd.FileNameLength = 0;
656 CmdExt.TxPayload1Len = (DataLen + 3) & (~3);
657 CmdExt.pTxPayload1 = (_u8 *)(pData);
659 CmdExt.RxPayloadLen = OutputDataLen;
660 CmdExt.pRxPayload = pOutputData;
662 Msg.Cmd.BufferLength = CmdExt.TxPayload1Len;
665 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsFileSysControlCmdCtrl, &Msg, &CmdExt));
667 if( pNewToken != NULL )
669 *pNewToken = Msg.Rsp.Token;
672 return (_i32)((_i32)Msg.Rsp.Status);
684 }_SlFsProgrammingMsg_u;
686 #if _SL_INCLUDE_FUNC(sl_FsProgram) 690 SL_OPCODE_NVMEM_NVMEMFSPROGRAMMINGCOMMAND,
695 _i32
sl_FsProgram(
const _u8* pData , _u16 DataLen ,
const _u8 * pKey , _u32 Flags )
697 _SlFsProgrammingMsg_u Msg;
701 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
703 Msg.Cmd.Flags = (_u32)Flags;
705 _SlDrvResetCmdExt(&CmdExt);
708 if( (DataLen == 0) && (pKey == NULL) )
710 Msg.Cmd.ChunkLen = 0;
712 Msg.Cmd.Flags = Flags;
713 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsProgrammingCmdCtrl, &Msg, &CmdExt));
715 else if( (DataLen> 0) && ( pData == NULL))
717 return( ((_i32)SL_ERROR_FS_WRONG_INPUT_SIZE) << 16 );
719 else if( (DataLen == 0) && (pKey != NULL) )
721 Msg.Cmd.ChunkLen = 0;
723 Msg.Cmd.Flags = Flags;
724 CmdExt.pTxPayload1 = (_u8*)pKey;
725 CmdExt.TxPayload1Len =
sizeof(
SlFsKey_t);
726 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsProgrammingCmdCtrl, &Msg, &CmdExt));
730 if( (DataLen & 0xF) > 0)
732 return( ((_i32)SL_ERROR_FS_NOT_16_ALIGNED) << 16 );
734 Msg.Cmd.Flags = Flags;
736 CmdExt.pTxPayload1 = (_u8 *)pData;
737 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE, DataLen);
741 Msg.Cmd.ChunkLen = ChunkLen;
742 CmdExt.TxPayload1Len = ChunkLen;
747 CmdExt.pRxPayload = (_u8 *)pKey;
749 if(CmdExt.pRxPayload != NULL && CmdExt.RxPayloadLen != 0)
751 CmdExt.RxPayloadLen = CmdExt.RxPayloadLen * (-1);
757 CmdExt.RxPayloadLen = 0;
758 CmdExt.pRxPayload = NULL;
761 VERIFY_RET_OK( _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsProgrammingCmdCtrl, &Msg, &CmdExt));
763 if( Msg.Rsp.Status <= 0 )
765 return (_i32)(Msg.Rsp.Status);
769 CmdExt.pTxPayload1 += ChunkLen;
771 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE, DataLen);
775 return (_i32)(Msg.Rsp.Status);
786 }_SlFsGetFileListMsg_u;
788 #if _SL_INCLUDE_FUNC(sl_FsGetFileList) 792 SL_OPCODE_NVMEM_NVMEMGETFILELISTCOMMAND,
797 _i32
sl_FsGetFileList(_i32* pIndex, _u8 Count, _u8 MaxEntryLen , _u8* pBuff, SlFileListFlags_t Flags )
799 _SlFsGetFileListMsg_u Msg;
801 _u16 OutputBufferSize;
805 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
807 _SlDrvResetCmdExt(&CmdExt);
809 Msg.Cmd.Index = *pIndex;
810 Msg.Cmd.MaxEntryLen = MaxEntryLen & (~3);
811 Msg.Cmd.Count = Count;
812 Msg.Cmd.Flags = (_u8)Flags;
814 OutputBufferSize = Msg.Cmd.Count * Msg.Cmd.MaxEntryLen;
815 if( OutputBufferSize > MAX_NVMEM_CHUNK_SIZE )
817 return SL_ERROR_FS_WRONG_INPUT_SIZE;
820 CmdExt.RxPayloadLen = OutputBufferSize;
821 CmdExt.pRxPayload = pBuff;
823 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsGetFileListCmdCtrl, &Msg, &CmdExt));
825 *pIndex = Msg.Rsp.Index;
827 return (_i32)((_i32)Msg.Rsp.NumOfEntriesOrError);
_i32 sl_FsOpen(const _u8 *pFileName, const _u32 ModeAndMaxSize, _u32 *pToken)
open file for read or write from/to storage device
_i32 sl_FsCtl(SlFsCtl_e Command, _u32 Token, _u8 *pFileName, const _u8 *pData, _u16 DataLen, _u8 *pOutputData, _u16 OutputDataLen, _u32 *pNewToken)
Controls various file system operations.
_i16 sl_FsGetInfo(const _u8 *pFileName, const _u32 Token, SlFsFileInfo_t *pFsFileInfo)
Get information of a file.
_i16 sl_FsClose(const _i32 FileHdl, const _u8 *pCeritificateFileName, const _u8 *pSignature, const _u32 SignatureLen)
Close file in storage device.
_i32 sl_FsProgram(const _u8 *pData, _u16 DataLen, const _u8 *pKey, _u32 Flags)
Enables to format and configure the device with pre-prepared configuration.
_i16 sl_FsDel(const _u8 *pFileName, const _u32 Token)
Delete specific file from a storage or all files from a storage (format)
_i32 sl_FsGetFileList(_i32 *pIndex, _u8 Count, _u8 MaxEntryLen, _u8 *pBuff, SlFileListFlags_t Flags)
The list of file names, the files are retrieve in chunks.
_i32 sl_FsWrite(const _i32 FileHdl, _u32 Offset, _u8 *pData, _u32 Len)
Write block of data to a file in storage device.
_i32 sl_FsRead(const _i32 FileHdl, _u32 Offset, _u8 *pData, _u32 Len)
Read block of data from a file in storage device.