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 55 static _u16 _SlFsStrlen(
const _u8 *buffer);
57 static _u32 FsGetCreateFsMode(_u8 Mode, _u32 MaxSizeInBytes,_u32 AccessFlags);
62 static _u16 _SlFsStrlen(
const _u8 *buffer)
67 while(*buffer++) len++;
76 #define FS_CONVERT_FLAGS( ModeAndMaxSize ) (((_u32)ModeAndMaxSize & SL_FS_OPEN_FLAGS_BIT_MASK)>>SL_NUM_OF_MAXSIZE_BIT) 80 FS_MODE_OPEN_READ = 0,
83 FS_MODE_OPEN_WRITE_CREATE_IF_NOT_EXIST
84 }FsFileOpenAccessType_e;
86 #define FS_MODE_ACCESS_RESERVED_OFFSET (27) 87 #define FS_MODE_ACCESS_RESERVED_MASK (0x1F) 88 #define FS_MODE_ACCESS_FLAGS_OFFSET (16) 89 #define FS_MODE_ACCESS_FLAGS_MASK (0x7FF) 90 #define FS_MODE_ACCESS_OFFSET (12) 91 #define FS_MODE_ACCESS_MASK (0xF) 92 #define FS_MODE_OPEN_SIZE_GRAN_OFFSET (8) 93 #define FS_MODE_OPEN_SIZE_GRAN_MASK (0xF) 94 #define FS_MODE_OPEN_SIZE_OFFSET (0) 95 #define FS_MODE_OPEN_SIZE_MASK (0xFF) 96 #define FS_MAX_MODE_SIZE (0xFF) 99 #define FS_MODE(Access, SizeGran, Size,Flags) (_u32)(((_u32)((Access) &FS_MODE_ACCESS_MASK)<<FS_MODE_ACCESS_OFFSET) | \ 100 ((_u32)((SizeGran) &FS_MODE_OPEN_SIZE_GRAN_MASK)<<FS_MODE_OPEN_SIZE_GRAN_OFFSET) | \ 101 ((_u32)((Size) &FS_MODE_OPEN_SIZE_MASK)<<FS_MODE_OPEN_SIZE_OFFSET) | \ 102 ((_u32)((Flags) &FS_MODE_ACCESS_FLAGS_MASK)<<FS_MODE_ACCESS_FLAGS_OFFSET)) 107 FS_MODE_SIZE_GRAN_256B = 0,
108 FS_MODE_SIZE_GRAN_1KB,
109 FS_MODE_SIZE_GRAN_4KB,
110 FS_MODE_SIZE_GRAN_16KB,
111 FS_MODE_SIZE_GRAN_64KB,
112 FS_MAX_MODE_SIZE_GRAN
113 }FsFileOpenMaxSizeGran_e;
116 static _u32 FsGetCreateFsMode(_u8 Mode, _u32 MaxSizeInBytes,_u32 AccessFlags)
120 _u32 granTable[FS_MAX_MODE_SIZE_GRAN] = {256,1024,4096,16384,65536};
122 for(granIdx= FS_MODE_SIZE_GRAN_256B ;granIdx< FS_MAX_MODE_SIZE_GRAN;granIdx++)
124 if( granTable[granIdx]*255 >= MaxSizeInBytes )
127 granNum = MaxSizeInBytes/granTable[granIdx];
128 if( MaxSizeInBytes % granTable[granIdx] != 0 )
131 return (_u32)FS_MODE( Mode, granIdx, granNum, AccessFlags );
148 #if _SL_INCLUDE_FUNC(sl_FsOpen) 152 SL_OPCODE_NVMEM_FILEOPEN,
157 _i32
sl_FsOpen(
const _u8 *pFileName,
const _u32 ModeAndMaxSize, _u32 *pToken)
169 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
173 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
175 return SL_ERROR_FS_WRONG_FILE_NAME;
178 CmdExt.TxPayload1Len = (_u16)((_SlFsStrlen(pFileName)+4) & (~3));
179 CmdExt.pTxPayload1 = (_u8*)pFileName;
181 OpenMode = ModeAndMaxSize & SL_FS_OPEN_MODE_BIT_MASK;
184 if( OpenMode == SL_FS_READ )
186 Msg.Cmd.Mode = FS_MODE(FS_MODE_OPEN_READ, 0, 0, 0);
188 else if (( OpenMode == SL_FS_WRITE ) ||( OpenMode == SL_FS_OVERWRITE))
190 Msg.Cmd.Mode = FS_MODE(FS_MODE_OPEN_WRITE, 0, 0, FS_CONVERT_FLAGS ( ModeAndMaxSize));
193 else if ( ( OpenMode == (SL_FS_CREATE | SL_FS_OVERWRITE )) || ( OpenMode == SL_FS_CREATE) ||(OpenMode == (SL_FS_CREATE | SL_FS_WRITE )))
196 MaxSizeInBytes = (ModeAndMaxSize & SL_FS_OPEN_MAXSIZE_BIT_MASK) * 256;
197 if (MaxSizeInBytes > 0xFF0000 )
199 return SL_ERROR_FS_FILE_MAX_SIZE_EXCEEDED;
202 CreateMode = ((OpenMode == (SL_FS_CREATE | SL_FS_OVERWRITE )) ? FS_MODE_OPEN_WRITE_CREATE_IF_NOT_EXIST : FS_MODE_OPEN_CREATE );
204 Msg.Cmd.Mode = FsGetCreateFsMode( CreateMode ,MaxSizeInBytes, FS_CONVERT_FLAGS ( ModeAndMaxSize) );
208 return SL_ERROR_FS_INVALID_FILE_MODE;
213 Msg.Cmd.Token = *pToken;
220 _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsOpenCmdCtrl, &Msg, &CmdExt);
221 FileHandle = (_i32)Msg.Rsp.FileHandle;
224 *pToken = Msg.Rsp.Token;
241 #if _SL_INCLUDE_FUNC(sl_FsClose) 245 SL_OPCODE_NVMEM_FILECLOSE,
250 _i16
sl_FsClose(
const _i32 FileHdl,
const _u8* pCeritificateFileName,
const _u8* pSignature ,
const _u32 SignatureLen)
259 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
261 Msg.Cmd.FileHandle = (_u32)FileHdl;
262 if( pCeritificateFileName != NULL )
264 Msg.Cmd.CertificFileNameLength = (_u32)((_SlFsStrlen(pCeritificateFileName)+4) & (~3));
266 Msg.Cmd.SignatureLen = SignatureLen;
268 _SlDrvMemZero(&ExtCtrl, (_u16)
sizeof(
_SlCmdExt_t));
270 ExtCtrl.TxPayload1Len = (_u16)(((SignatureLen+3) & (~3)));
271 ExtCtrl.pTxPayload1 = (_u8*)pSignature;
272 ExtCtrl.RxPayloadLen = (_i16)Msg.Cmd.CertificFileNameLength;
273 ExtCtrl.pRxPayload = (_u8*)pCeritificateFileName;
275 if(ExtCtrl.pRxPayload != NULL && ExtCtrl.RxPayloadLen != 0)
277 ExtCtrl.RxPayloadLen = ExtCtrl.RxPayloadLen * (-1);
280 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsCloseCmdCtrl, &Msg, &ExtCtrl));
282 return (_i16)((_i16)Msg.Rsp.status);
296 #if _SL_INCLUDE_FUNC(sl_FsRead) 300 SL_OPCODE_NVMEM_FILEREADCOMMAND,
305 _i32
sl_FsRead(
const _i32 FileHdl,_u32 Offset, _u8* pData,_u32 Len)
310 _SlReturnVal_t RetVal =0;
315 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
317 _SlDrvMemZero(&ExtCtrl, (_u16)
sizeof(
_SlCmdExt_t));
319 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
320 ExtCtrl.RxPayloadLen = (_i16)ChunkLen;
321 ExtCtrl.pRxPayload = (_u8 *)(pData);
322 Msg.Cmd.Offset = Offset;
323 Msg.Cmd.Len = ChunkLen;
324 Msg.Cmd.FileHandle = (_u32)FileHdl;
327 RetVal = _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsReadCmdCtrl, &Msg, &ExtCtrl);
328 if(SL_OS_RET_CODE_OK == RetVal)
330 if( Msg.Rsp.status < 0)
338 return Msg.Rsp.status;
341 RetCount += (_i32)Msg.Rsp.status;
344 Msg.Cmd.Offset = Offset;
345 ExtCtrl.pRxPayload += ChunkLen;
346 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
347 ExtCtrl.RxPayloadLen = (_i16)ChunkLen;
348 Msg.Cmd.Len = ChunkLen;
349 Msg.Cmd.FileHandle = (_u32)FileHdl;
355 }
while(ChunkLen > 0);
357 return (_i32)RetCount;
370 #if _SL_INCLUDE_FUNC(sl_FsWrite) 374 SL_OPCODE_NVMEM_FILEWRITECOMMAND,
379 _i32
sl_FsWrite(
const _i32 FileHdl,_u32 Offset, _u8* pData,_u32 Len)
384 _SlReturnVal_t RetVal;
389 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
391 _SlDrvMemZero(&ExtCtrl, (_u16)
sizeof(
_SlCmdExt_t));
393 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
394 ExtCtrl.TxPayload1Len = ChunkLen;
395 ExtCtrl.pTxPayload1 = (_u8 *)(pData);
396 Msg.Cmd.Offset = Offset;
397 Msg.Cmd.Len = ChunkLen;
398 Msg.Cmd.FileHandle = (_u32)FileHdl;
402 RetVal = _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsWriteCmdCtrl, &Msg, &ExtCtrl);
403 if(SL_OS_RET_CODE_OK == RetVal)
405 if( Msg.Rsp.status < 0)
413 return Msg.Rsp.status;
417 RetCount += (_i32)Msg.Rsp.status;
420 Msg.Cmd.Offset = Offset;
421 ExtCtrl.pTxPayload1 += ChunkLen;
422 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE,Len);
423 ExtCtrl.TxPayload1Len = ChunkLen;
424 Msg.Cmd.Len = ChunkLen;
425 Msg.Cmd.FileHandle = (_u32)FileHdl;
431 }
while(ChunkLen > 0);
433 return (_i32)RetCount;
446 #if _SL_INCLUDE_FUNC(sl_FsGetInfo) 450 SL_OPCODE_NVMEM_FILEGETINFOCOMMAND,
455 const _u16 FlagsTranslate[] =
457 SL_FS_INFO_OPEN_WRITE,
458 SL_FS_INFO_OPEN_READ,
459 SL_FS_INFO_NOT_FAILSAFE,
460 SL_FS_INFO_NOT_VALID,
462 SL_FS_INFO_MUST_COMMIT,
463 SL_FS_INFO_BUNDLE_FILE,
464 SL_FS_INFO_PENDING_COMMIT,
465 SL_FS_INFO_PENDING_BUNDLE_COMMIT,
468 SL_FS_INFO_NOSIGNATURE,
469 SL_FS_INFO_PUBLIC_WRITE,
470 SL_FS_INFO_PUBLIC_READ,
477 _SlFsGetInfoMsg_u Msg;
483 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
487 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
489 return SL_ERROR_FS_WRONG_FILE_NAME;
492 CmdExt.TxPayload1Len = (_u16)((_SlFsStrlen(pFileName)+4) & (~3));
493 CmdExt.pTxPayload1 = (_u8*)pFileName;
495 Msg.Cmd.Token = Token;
497 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsGetInfoCmdCtrl, &Msg, &CmdExt));
500 pFsFileInfo->Flags = 0;
501 for (BitNum = 0; BitNum < 16; BitNum++ )
503 if (( Msg.Rsp.Flags >> BitNum) & 0x1 )
505 pFsFileInfo->Flags |= FlagsTranslate[BitNum];
509 pFsFileInfo->Len = Msg.Rsp.FileLen;
510 pFsFileInfo->MaxSize = Msg.Rsp.AllocatedLen;
511 pFsFileInfo->Token[0] = Msg.Rsp.Token[0];
512 pFsFileInfo->Token[1] = Msg.Rsp.Token[1];
513 pFsFileInfo->Token[2] = Msg.Rsp.Token[2];
514 pFsFileInfo->Token[3] = Msg.Rsp.Token[3];
515 pFsFileInfo->StorageSize = Msg.Rsp.FileStorageSize;
516 pFsFileInfo->WriteCounter = Msg.Rsp.FileWriteCounter;
518 return (_i16)((_i16)Msg.Rsp.Status);
532 #if _SL_INCLUDE_FUNC(sl_FsDel) 536 SL_OPCODE_NVMEM_FILEDELCOMMAND,
541 _i16
sl_FsDel(
const _u8 *pFileName,
const _u32 Token)
543 _SlFsDeleteMsg_u Msg;
548 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
550 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
552 return SL_ERROR_FS_WRONG_FILE_NAME;
557 CmdExt.TxPayload1Len = (_u16)((_SlFsStrlen(pFileName)+4) & (~3));
558 CmdExt.pTxPayload1 = (_u8*)pFileName;
559 Msg.Cmd.Token = Token;
561 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsDeleteCmdCtrl, &Msg, &CmdExt));
563 return (_i16)((_i16)Msg.Rsp.status);
574 }_SlFsFileSysControlMsg_u;
576 #if _SL_INCLUDE_FUNC(sl_FsCtl) 580 SL_OPCODE_NVMEM_NVMEMFILESYSTEMCONTROLCOMMAND,
585 _i32
sl_FsCtl( SlFsCtl_e Command, _u32 Token, _u8 *pFileName,
const _u8 *pData, _u16 DataLen, _u8 *pOutputData, _u16 OutputDataLen,_u32 *pNewToken )
587 _SlFsFileSysControlMsg_u Msg;
592 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
594 Msg.Cmd.Token = Token;
595 Msg.Cmd.Operation = (_u8)Command;
599 if ((SL_FS_CTL_ROLLBACK == Command) || (SL_FS_CTL_COMMIT == Command ))
601 Msg.Cmd.FileNameLength = _SlFsStrlen(pFileName) + 1 ;
603 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
605 return SL_ERROR_FS_WRONG_FILE_NAME;
609 CmdExt.RxPayloadLen = DataLen;
610 CmdExt.pRxPayload = (_u8 *)(pData);
612 CmdExt.TxPayload1Len = (_SlFsStrlen(pFileName) + 4) & (~3);
613 CmdExt.pTxPayload1 = pFileName;
615 Msg.Cmd.BufferLength = CmdExt.RxPayloadLen + CmdExt.TxPayload1Len;
617 if(CmdExt.pRxPayload != NULL && CmdExt.RxPayloadLen != 0)
619 CmdExt.RxPayloadLen = CmdExt.RxPayloadLen * (-1);
622 else if( SL_FS_CTL_RENAME == Command )
624 if ( _SlFsStrlen(pFileName) >= SL_FS_MAX_FILE_NAME_LENGTH )
626 return SL_ERROR_FS_WRONG_FILE_NAME;
629 Msg.Cmd.FileNameLength = (_SlFsStrlen(pFileName) + 4) & (~3);
632 CmdExt.RxPayloadLen = (_u16)Msg.Cmd.FileNameLength;
633 CmdExt.pRxPayload = pFileName;
636 CmdExt.TxPayload1Len = (_SlFsStrlen(pData) + 4) & (~3);;
637 CmdExt.pTxPayload1 = (_u8 *)(pData);
639 Msg.Cmd.BufferLength = CmdExt.RxPayloadLen + CmdExt.TxPayload1Len;
641 if(CmdExt.pRxPayload != NULL && CmdExt.RxPayloadLen != 0)
643 CmdExt.RxPayloadLen = CmdExt.RxPayloadLen * (-1);
648 Msg.Cmd.FileNameLength = 0;
650 CmdExt.TxPayload1Len = (DataLen + 3) & (~3);
651 CmdExt.pTxPayload1 = (_u8 *)(pData);
653 CmdExt.RxPayloadLen = OutputDataLen;
654 CmdExt.pRxPayload = pOutputData;
656 Msg.Cmd.BufferLength = CmdExt.TxPayload1Len;
659 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsFileSysControlCmdCtrl, &Msg, &CmdExt));
661 if( pNewToken != NULL )
663 *pNewToken = Msg.Rsp.Token;
666 return (_i32)((_i32)Msg.Rsp.Status);
678 }_SlFsProgrammingMsg_u;
680 #if _SL_INCLUDE_FUNC(sl_FsProgram) 684 SL_OPCODE_NVMEM_NVMEMFSPROGRAMMINGCOMMAND,
689 _i32
sl_FsProgram(
const _u8* pData , _u16 DataLen ,
const _u8 * pKey , _u32 Flags )
691 _SlFsProgrammingMsg_u Msg;
695 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
697 Msg.Cmd.Flags = (_u32)Flags;
699 _SlDrvResetCmdExt(&CmdExt);
702 if( (DataLen == 0) && (pKey == NULL) )
704 Msg.Cmd.ChunkLen = 0;
706 Msg.Cmd.Flags = Flags;
707 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsProgrammingCmdCtrl, &Msg, &CmdExt));
709 else if( (DataLen> 0) && ( pData == NULL))
711 return (SL_ERROR_FS_WRONG_INPUT_SIZE_INTERNAL_SHIFTED_16_LEFT);
713 else if( (DataLen == 0) && (pKey != NULL) )
715 Msg.Cmd.ChunkLen = 0;
717 Msg.Cmd.Flags = Flags;
718 CmdExt.pTxPayload1 = (_u8*)pKey;
719 CmdExt.TxPayload1Len =
sizeof(
SlFsKey_t);
720 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsProgrammingCmdCtrl, &Msg, &CmdExt));
724 if( (DataLen & 0xF) > 0)
726 return (SL_ERROR_FS_NOT_16_ALIGNED_INTERNAL_SHIFTED_16_LEFT);
728 Msg.Cmd.Flags = Flags;
730 CmdExt.pTxPayload1 = (_u8 *)pData;
731 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE, DataLen);
735 Msg.Cmd.ChunkLen = ChunkLen;
736 CmdExt.TxPayload1Len = ChunkLen;
741 CmdExt.pRxPayload = (_u8 *)pKey;
743 if(CmdExt.pRxPayload != NULL && CmdExt.RxPayloadLen != 0)
745 CmdExt.RxPayloadLen = CmdExt.RxPayloadLen * (-1);
751 CmdExt.RxPayloadLen = 0;
752 CmdExt.pRxPayload = NULL;
755 VERIFY_RET_OK( _SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsProgrammingCmdCtrl, &Msg, &CmdExt));
757 if( Msg.Rsp.Status <= 0 )
759 return (_i32)(Msg.Rsp.Status);
763 CmdExt.pTxPayload1 += ChunkLen;
765 ChunkLen = (_u16)sl_min(MAX_NVMEM_CHUNK_SIZE, DataLen);
769 return (_i32)(Msg.Rsp.Status);
780 }_SlFsGetFileListMsg_u;
782 #if _SL_INCLUDE_FUNC(sl_FsGetFileList) 786 SL_OPCODE_NVMEM_NVMEMGETFILELISTCOMMAND,
791 _i32
sl_FsGetFileList(_i32* pIndex, _u8 Count, _u8 MaxEntryLen , _u8* pBuff, SlFileListFlags_t Flags )
793 _SlFsGetFileListMsg_u Msg;
795 _u16 OutputBufferSize;
799 VERIFY_API_ALLOWED(SL_OPCODE_SILO_FS);
801 _SlDrvResetCmdExt(&CmdExt);
803 Msg.Cmd.Index = *pIndex;
804 Msg.Cmd.MaxEntryLen = MaxEntryLen & (~3);
805 Msg.Cmd.Count = Count;
806 Msg.Cmd.Flags = (_u8)Flags;
808 OutputBufferSize = Msg.Cmd.Count * Msg.Cmd.MaxEntryLen;
809 if( OutputBufferSize > MAX_NVMEM_CHUNK_SIZE )
811 return SL_ERROR_FS_WRONG_INPUT_SIZE;
814 CmdExt.RxPayloadLen = OutputBufferSize;
815 CmdExt.pRxPayload = pBuff;
817 VERIFY_RET_OK(_SlDrvCmdOp((
_SlCmdCtrl_t *)&_SlFsGetFileListCmdCtrl, &Msg, &CmdExt));
819 *pIndex = Msg.Rsp.Index;
821 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.