filesystem/html/fs__evr_8h_source.html

 /*------------------------------------------------------------------------------

  * MDK Middleware - Component ::File System

  * Copyright (c) 2016-2020 Arm Limited (or its affiliates). All rights reserved.

  *------------------------------------------------------------------------------

  * Name:    fs_evr.h

  * Purpose: Definition of debug events for FileSystem

  *----------------------------------------------------------------------------*/


 /* Fs component number - available range: [0x80-0x9F] */

 #define EvtFsCore_No   (0x80 | 0)       /* FsCore component number */

 #define EvtFsFAT_No    (0x80 | 1)       /* FsFAT component number */

 #define EvtFsEFS_No    (0x80 | 2)       /* FsEFS component number */

 #define EvtFsIOC_No    (0x80 | 3)       /* FsIOC component number */

 #define EvtFsNFTL_No   (0x80 | 4)       /* FsNFTL component number */

 #define EvtFsNAND_No   (0x80 | 5)       /* FsNAND component number */

 #define EvtFsMcMCI_No  (0x80 | 6)       /* FsMcMCI component number */

 #define EvtFsMcSPI_No  (0x80 | 7)       /* FsMcSPI component number */


 #ifdef FS_DEBUG

 #include <stddef.h>

 #include "cmsis_compiler.h"

 #include "EventRecorder.h"              // Keil::Compiler:Event Recorder

 #include "rl_fs.h"


 /* Fs component IDs */

 #define EvtFsCoreId(Level,  Msg_No)     EventID(Level, EvtFsCore_No,  Msg_No)

 #define EvtFsFATId(Level,   Msg_No)     EventID(Level, EvtFsFAT_No,   Msg_No)

 #define EvtFsEFSId(Level,   Msg_No)     EventID(Level, EvtFsEFS_No,   Msg_No)

 #define EvtFsIOCId(Level,   Msg_No)     EventID(Level, EvtFsIOC_No,   Msg_No)

 #define EvtFsNFTLId(Level,  Msg_No)     EventID(Level, EvtFsNFTL_No,  Msg_No)

 #define EvtFsNANDId(Level,  Msg_No)     EventID(Level, EvtFsNAND_No,  Msg_No)

 #define EvtFsMcMCIId(Level, Msg_No)     EventID(Level, EvtFsMcMCI_No, Msg_No)

 #define EvtFsMcSPIId(Level, Msg_No)     EventID(Level, EvtFsMcSPI_No, Msg_No)


 /* Event id list for "FsCore" */

 #define EvtFsCore_sys_open              EvtFsCoreId(EventLevelAPI,     0)

 #define EvtFsCore_sys_close             EvtFsCoreId(EventLevelAPI,     1)

 #define EvtFsCore_sys_write             EvtFsCoreId(EventLevelAPI,     2)

 #define EvtFsCore_sys_read              EvtFsCoreId(EventLevelAPI,     3)

 #define EvtFsCore_sys_seek              EvtFsCoreId(EventLevelAPI,     4)

 #define EvtFsCore_sys_flen              EvtFsCoreId(EventLevelAPI,     5)

 #define EvtFsCore_sys_handle_assign     EvtFsCoreId(EventLevelOp,      6)

 #define EvtFsCore_finit                 EvtFsCoreId(EventLevelAPI,     7)

 #define EvtFsCore_funinit               EvtFsCoreId(EventLevelAPI,     8)

 #define EvtFsCore_fmount                EvtFsCoreId(EventLevelAPI,     9)

 #define EvtFsCore_funmount              EvtFsCoreId(EventLevelAPI,    10)

 #define EvtFsCore_fdelete_l             EvtFsCoreId(EventLevelAPI,    11)

 #define EvtFsCore_fdelete               EvtFsCoreId(EventLevelAPI,    12)

 #define EvtFsCore_ffind                 EvtFsCoreId(EventLevelAPI,    13)

 #define EvtFsCore_frename               EvtFsCoreId(EventLevelAPI,    14)

 #define EvtFsCore_fattrib               EvtFsCoreId(EventLevelAPI,    15)

 #define EvtFsCore_fpwd                  EvtFsCoreId(EventLevelAPI,    16)

 #define EvtFsCore_fchdir                EvtFsCoreId(EventLevelAPI,    17)

 #define EvtFsCore_fmkdir                EvtFsCoreId(EventLevelAPI,    18)

 #define EvtFsCore_frmdir                EvtFsCoreId(EventLevelAPI,    19)

 #define EvtFsCore_fchdrive              EvtFsCoreId(EventLevelAPI,    20)

 #define EvtFsCore_ffree                 EvtFsCoreId(EventLevelAPI,    21)

 #define EvtFsCore_fformat               EvtFsCoreId(EventLevelAPI,    22)

 #define EvtFsCore_fanalyse              EvtFsCoreId(EventLevelAPI,    23)

 #define EvtFsCore_fcheck                EvtFsCoreId(EventLevelAPI,    24)

 #define EvtFsCore_fdefrag               EvtFsCoreId(EventLevelAPI,    25)

 #define EvtFsCore_fmedia                EvtFsCoreId(EventLevelAPI,    26)

 #define EvtFsCore_finfo                 EvtFsCoreId(EventLevelAPI,    27)

 #define EvtFsCore_fvol                  EvtFsCoreId(EventLevelAPI,    28)

 #define EvtFsCore_InvalidDrive          EvtFsCoreId(EventLevelError,  29)

 #define EvtFsCore_CurrentDriveSelect    EvtFsCoreId(EventLevelOp,     30)

 #define EvtFsCore_ftime_set             EvtFsCoreId(EventLevelAPI,    31)

 #define EvtFsCore_ftime_get             EvtFsCoreId(EventLevelAPI,    32)

 #define EvtFsCore_fversion              EvtFsCoreId(EventLevelAPI,    33)


 /* Event id list for "FsFAT" */

 #define EvtFsFAT_InitDrive              EvtFsFATId(EventLevelOp,       0)

 #define EvtFsFAT_InitDriveSuccess       EvtFsFATId(EventLevelOp,       1)

 #define EvtFsFAT_InitDriverCfgError     EvtFsFATId(EventLevelError,    2)

 #define EvtFsFAT_InitDriverError        EvtFsFATId(EventLevelError,    3)

 #define EvtFsFAT_UninitDrive            EvtFsFATId(EventLevelOp,       4)

 #define EvtFsFAT_MountDrive             EvtFsFATId(EventLevelOp,       5)

 #define EvtFsFAT_InitMediaError         EvtFsFATId(EventLevelError,    6)

 #define EvtFsFAT_MediaInsertStatError   EvtFsFATId(EventLevelError,    7)

 #define EvtFsFAT_MediaInitStatError     EvtFsFATId(EventLevelError,    8)

 #define EvtFsFAT_VolumeReadyStatError   EvtFsFATId(EventLevelError,    9)

 #define EvtFsFAT_VolumeWriteStatError   EvtFsFATId(EventLevelError,   10)

 #define EvtFsFAT_VolumeNotMounted       EvtFsFATId(EventLevelError,   11)

 #define EvtFsFAT_ReadMBR                EvtFsFATId(EventLevelOp,      12)

 #define EvtFsFAT_InvalidMBR             EvtFsFATId(EventLevelError,   13)

 #define EvtFsFAT_NonexistentMBR         EvtFsFATId(EventLevelOp,      14)

 #define EvtFsFAT_ReadBootSector         EvtFsFATId(EventLevelOp,      15)

 #define EvtFsFAT_InvalidBootSector      EvtFsFATId(EventLevelError,   16)

 #define EvtFsFAT_InvalidFAT             EvtFsFATId(EventLevelError,   17)

 #define EvtFsFAT_ReadFSInfo             EvtFsFATId(EventLevelOp,      18)

 #define EvtFsFAT_InvalidFSInfo          EvtFsFATId(EventLevelError,   19)

 #define EvtFsFAT_InvalidFreeClusFSInfo  EvtFsFATId(EventLevelError,   20)

 #define EvtFsFAT_InvalidNextClusFSInfo  EvtFsFATId(EventLevelError,   21)

 #define EvtFsFAT_WriteFSInfo            EvtFsFATId(EventLevelOp,      22)

 #define EvtFsFAT_CountFreeClus          EvtFsFATId(EventLevelOp,      23)

 #define EvtFsFAT_MountDriveSuccess      EvtFsFATId(EventLevelOp,      24)

 #define EvtFsFAT_UnmountDrive           EvtFsFATId(EventLevelOp,      25)

 #define EvtFsFAT_UnmountDriveSuccess    EvtFsFATId(EventLevelOp,      26)

 #define EvtFsFAT_FormatDrive            EvtFsFATId(EventLevelOp,      27)

 #define EvtFsFAT_FormatDriveSuccess     EvtFsFATId(EventLevelOp,      28)

 #define EvtFsFAT_ResetHandles           EvtFsFATId(EventLevelOp,      29)

 #define EvtFsFAT_FormatOptionDetected   EvtFsFATId(EventLevelOp,      30)

 #define EvtFsFAT_FormatMediaCapacity    EvtFsFATId(EventLevelOp,      31)

 #define EvtFsFAT_FormatLowLevel         EvtFsFATId(EventLevelOp,      32)

 #define EvtFsFAT_FormatNoSpace          EvtFsFATId(EventLevelError,   33)

 #define EvtFsFAT_FormatNoSpaceFAT32     EvtFsFATId(EventLevelError,   34)

 #define EvtFsFAT_WriteMBR               EvtFsFATId(EventLevelOp,      35)

 #define EvtFsFAT_WriteBootSector        EvtFsFATId(EventLevelOp,      36)

 #define EvtFsFAT_ClearHiddenSectors     EvtFsFATId(EventLevelOp,      37)

 #define EvtFsFAT_ClearReservedSectors   EvtFsFATId(EventLevelOp,      38)

 #define EvtFsFAT_ClearRootSectors       EvtFsFATId(EventLevelOp,      39)

 #define EvtFsFAT_CreateFAT              EvtFsFATId(EventLevelOp,      40)

 #define EvtFsFAT_FormatProperties       EvtFsFATId(EventLevelOp,      41)

 #define EvtFsFAT_FileOpen               EvtFsFATId(EventLevelOp,      42)

 #define EvtFsFAT_PathInvalidChar        EvtFsFATId(EventLevelError,   43)

 #define EvtFsFAT_PathIsTooLong          EvtFsFATId(EventLevelError,   44)

 #define EvtFsFAT_PathIsDirNotFile       EvtFsFATId(EventLevelError,   45)

 #define EvtFsFAT_FileIsInUse            EvtFsFATId(EventLevelError,   46)

 #define EvtFsFAT_FileIsReadOnly         EvtFsFATId(EventLevelError,   47)

 #define EvtFsFAT_FileIsNonExistent      EvtFsFATId(EventLevelError,   48)

 #define EvtFsFAT_PathProcessing         EvtFsFATId(EventLevelOp,      49)

 #define EvtFsFAT_FileHandleUnavailable  EvtFsFATId(EventLevelError,   50)

 #define EvtFsFAT_FileHandleInvalid      EvtFsFATId(EventLevelError,   51)

 #define EvtFsFAT_LabelInvalid           EvtFsFATId(EventLevelError,   52)

 #define EvtFsFAT_LabelNotSet            EvtFsFATId(EventLevelError,   53)

 #define EvtFsFAT_SectorReadFailed       EvtFsFATId(EventLevelError,   54)

 #define EvtFsFAT_SectorWriteFailed      EvtFsFATId(EventLevelError,   55)

 #define EvtFsFAT_DiskFull               EvtFsFATId(EventLevelError,   56)

 #define EvtFsFAT_DirEntryAllocFailed    EvtFsFATId(EventLevelError,   57)

 #define EvtFsFAT_PathBufferToSmall      EvtFsFATId(EventLevelError,   58)

 #define EvtFsFAT_InitJournal            EvtFsFATId(EventLevelOp,      59)

 #define EvtFsFAT_InitJournalSuccess     EvtFsFATId(EventLevelOp,      60)

 #define EvtFsFAT_InitJournalFATError    EvtFsFATId(EventLevelOp,      61)

 #define EvtFsFAT_FileClose              EvtFsFATId(EventLevelOp,      62)

 #define EvtFsFAT_FileHandleError        EvtFsFATId(EventLevelError,   63)

 #define EvtFsFAT_FileRead               EvtFsFATId(EventLevelOp,      64)

 #define EvtFsFAT_FileWrite              EvtFsFATId(EventLevelOp,      65)

 #define EvtFsFAT_FileFlush              EvtFsFATId(EventLevelOp,      66)

 #define EvtFsFAT_FileSeek               EvtFsFATId(EventLevelOp,      67)

 #define EvtFsFAT_FileSeekIncrease       EvtFsFATId(EventLevelOp,      68)

 #define EvtFsFAT_FileDelete             EvtFsFATId(EventLevelOp,      69)

 #define EvtFsFAT_FileDeleteSuccess      EvtFsFATId(EventLevelOp,      70)

 #define EvtFsFAT_FileRename             EvtFsFATId(EventLevelOp,      71)

 #define EvtFsFAT_FileRenameSuccess      EvtFsFATId(EventLevelOp,      72)

 #define EvtFsFAT_DirCreate              EvtFsFATId(EventLevelOp,      73)

 #define EvtFsFAT_DirCreateSuccess       EvtFsFATId(EventLevelOp,      74)

 #define EvtFsFAT_DirRemove              EvtFsFATId(EventLevelOp,      75)

 #define EvtFsFAT_DirRemoveSuccess       EvtFsFATId(EventLevelOp,      76)

 #define EvtFsFAT_ChDir                  EvtFsFATId(EventLevelOp,      77)

 #define EvtFsFAT_ChDirSuccess           EvtFsFATId(EventLevelOp,      78)

 #define EvtFsFAT_Pwd                    EvtFsFATId(EventLevelOp,      79)

 #define EvtFsFAT_PwdSuccess             EvtFsFATId(EventLevelOp,      80)

 #define EvtFsFAT_AttribSet              EvtFsFATId(EventLevelOp,      81)

 #define EvtFsFAT_AttribSetSuccess       EvtFsFATId(EventLevelOp,      82)

 #define EvtFsFAT_GetFreeSpace           EvtFsFATId(EventLevelOp,      83)

 #define EvtFsFAT_FreeAmount             EvtFsFATId(EventLevelOp,      84)

 #define EvtFsFAT_FileModeRead           EvtFsFATId(EventLevelError,   85)

 #define EvtFsFAT_FileFind               EvtFsFATId(EventLevelOp,      86)

 #define EvtFsFAT_InvalidParameter       EvtFsFATId(EventLevelError,   87)

 #define EvtFsFAT_DriverNotInitialized   EvtFsFATId(EventLevelError,   88)

 #define EvtFsFAT_PathName               EvtFsFATId(EventLevelDetail,  89)

 #define EvtFsFAT_OptionsString          EvtFsFATId(EventLevelDetail,  90)

 #define EvtFsFAT_LabelString            EvtFsFATId(EventLevelDetail,  91)

 #define EvtFsFAT_NameCacheHit           EvtFsFATId(EventLevelOp,      92)

 #define EvtFsFAT_NameCacheMiss          EvtFsFATId(EventLevelOp,      93)

 #define EvtFsFAT_NameCacheEntryFound    EvtFsFATId(EventLevelDetail,  94)

 #define EvtFsFAT_NameCacheEntryInsert   EvtFsFATId(EventLevelDetail,  95)

 #define EvtFsFAT_NameCacheEntryDelete   EvtFsFATId(EventLevelDetail,  96)

 #define EvtFsFAT_TimeSet                EvtFsFATId(EventLevelOp,      97)

 #define EvtFsFAT_TimeGet                EvtFsFATId(EventLevelOp,      98)

 #define EvtFsFAT_TimeData               EvtFsFATId(EventLevelDetail,  99)


 /* Event id list for "FsEFS" */

 #define EvtFsEFS_InitDrive              EvtFsEFSId(EventLevelOp,       0)

 #define EvtFsEFS_InitDriver             EvtFsEFSId(EventLevelOp,       1)

 #define EvtFsEFS_InitDriverFailed       EvtFsEFSId(EventLevelError,    2)

 #define EvtFsEFS_UninitDrive            EvtFsEFSId(EventLevelOp,       3)

 #define EvtFsEFS_UninitDriver           EvtFsEFSId(EventLevelOp,       4)

 #define EvtFsEFS_MountDrive             EvtFsEFSId(EventLevelOp,       5)

 #define EvtFsEFS_MountDriveSuccess      EvtFsEFSId(EventLevelOp,       6)

 #define EvtFsEFS_FlashGetInfo           EvtFsEFSId(EventLevelOp,       7)

 #define EvtFsEFS_FlashProgUnitTooBig    EvtFsEFSId(EventLevelError,    8)

 #define EvtFsEFS_FlashCapacity          EvtFsEFSId(EventLevelOp,       9)

 #define EvtFsEFS_UnmountDrive           EvtFsEFSId(EventLevelOp,      10)

 #define EvtFsEFS_UnmountDriveSuccess    EvtFsEFSId(EventLevelOp,      11)

 #define EvtFsEFS_FormatDrive            EvtFsEFSId(EventLevelOp,      12)

 #define EvtFsEFS_FormatDriveSuccess     EvtFsEFSId(EventLevelOp,      13)

 #define EvtFsEFS_FlashEraseChip         EvtFsEFSId(EventLevelOp,      14)

 #define EvtFsEFS_FlashEraseChipFailed   EvtFsEFSId(EventLevelError,   15)

 #define EvtFsEFS_FlashEraseChipTimeout  EvtFsEFSId(EventLevelError,   16)

 #define EvtFsEFS_FlashEraseSectors      EvtFsEFSId(EventLevelOp,      17)

 #define EvtFsEFS_FileOpen               EvtFsEFSId(EventLevelOp,      18)

 #define EvtFsEFS_FileNameInvalid        EvtFsEFSId(EventLevelError,   19)

 #define EvtFsEFS_OpenModeUnsupported    EvtFsEFSId(EventLevelError,   20)

 #define EvtFsEFS_FileClose              EvtFsEFSId(EventLevelOp,      21)

 #define EvtFsEFS_FileNotOpened          EvtFsEFSId(EventLevelError,   22)

 #define EvtFsEFS_FileRead               EvtFsEFSId(EventLevelOp,      23)

 #define EvtFsEFS_FileOpenWriteMode      EvtFsEFSId(EventLevelError,   24)

 #define EvtFsEFS_FileWrite              EvtFsEFSId(EventLevelOp,      25)

 #define EvtFsEFS_FileOpenReadMode       EvtFsEFSId(EventLevelError,   26)

 #define EvtFsEFS_FileFlush              EvtFsEFSId(EventLevelOp,      27)

 #define EvtFsEFS_OpenModeInvalid        EvtFsEFSId(EventLevelError,   28)

 #define EvtFsEFS_FileSeek               EvtFsEFSId(EventLevelOp,      29)

 #define EvtFsEFS_FileSeekEOF            EvtFsEFSId(EventLevelError,   30)

 #define EvtFsEFS_FileDelete             EvtFsEFSId(EventLevelOp,      31)

 #define EvtFsEFS_FileRename             EvtFsEFSId(EventLevelOp,      32)

 #define EvtFsEFS_FileNotFound           EvtFsEFSId(EventLevelError,   33)

 #define EvtFsEFS_FileAlreadyExists      EvtFsEFSId(EventLevelError,   34)

 #define EvtFsEFS_FreeSpaceRetrieve      EvtFsEFSId(EventLevelOp,      35)

 #define EvtFsEFS_FreeSpaceAmount        EvtFsEFSId(EventLevelOp,      36)

 #define EvtFsEFS_DriveAnalyze           EvtFsEFSId(EventLevelOp,      37)

 #define EvtFsEFS_DriveAnalyzeSuccess    EvtFsEFSId(EventLevelOp,      38)

 #define EvtFsEFS_DriveCheck             EvtFsEFSId(EventLevelOp,      39)

 #define EvtFsEFS_DriveCheckSuccess      EvtFsEFSId(EventLevelOp,      40)

 #define EvtFsEFS_DataAreaOverlap        EvtFsEFSId(EventLevelError,   41)

 #define EvtFsEFS_FileIdInvalid          EvtFsEFSId(EventLevelError,   42)

 #define EvtFsEFS_AllocationOrderInvalid EvtFsEFSId(EventLevelError,   43)

 #define EvtFsEFS_AllocationAreaOverlap  EvtFsEFSId(EventLevelError,   44)

 #define EvtFsEFS_DriveDefrag            EvtFsEFSId(EventLevelOp,      45)

 #define EvtFsEFS_FileHandleActive       EvtFsEFSId(EventLevelError,   46)

 #define EvtFsEFS_FileHandleUnavailable  EvtFsEFSId(EventLevelError,   47)

 #define EvtFsEFS_FileHandleInvalid      EvtFsEFSId(EventLevelError,   48)

 #define EvtFsEFS_FileInUse              EvtFsEFSId(EventLevelError,   49)

 #define EvtFsEFS_FlashWriteFailed       EvtFsEFSId(EventLevelError,   50)

 #define EvtFsEFS_FlashReadFailed        EvtFsEFSId(EventLevelError,   51)

 #define EvtFsEFS_FlashReadTimeout       EvtFsEFSId(EventLevelError,   52)

 #define EvtFsEFS_FlashEraseFailed       EvtFsEFSId(EventLevelError,   53)

 #define EvtFsEFS_DiskFull               EvtFsEFSId(EventLevelError,   54)

 #define EvtFsEFS_InvalidParameter       EvtFsEFSId(EventLevelError,   55)

 #define EvtFsEFS_DriveNotMounted        EvtFsEFSId(EventLevelError,   56)

 #define EvtFsEFS_DriveNotInitialized    EvtFsEFSId(EventLevelError,   57)

 #define EvtFsEFS_FileName               EvtFsEFSId(EventLevelDetail,  58)

 #define EvtFsEFS_FileAllocWrite         EvtFsEFSId(EventLevelDetail,  59)

 #define EvtFsEFS_FileAllocRead          EvtFsEFSId(EventLevelDetail,  60)


 /* Event id list for "FsIOC" */

 #define EvtFsIOC_GetId                  EvtFsIOCId(EventLevelAPI,      0)

 #define EvtFsIOC_GetIdSuccess           EvtFsIOCId(EventLevelOp,       1)

 #define EvtFsIOC_GetIdError             EvtFsIOCId(EventLevelError,    2)

 #define EvtFsIOC_Lock                   EvtFsIOCId(EventLevelAPI,      3)

 #define EvtFsIOC_LockSuccess            EvtFsIOCId(EventLevelOp,       4)

 #define EvtFsIOC_Unlock                 EvtFsIOCId(EventLevelAPI,      5)

 #define EvtFsIOC_UnlockSuccess          EvtFsIOCId(EventLevelOp,       6)

 #define EvtFsIOC_GetCache               EvtFsIOCId(EventLevelAPI,      7)

 #define EvtFsIOC_GetCacheSuccess        EvtFsIOCId(EventLevelOp,       8)

 #define EvtFsIOC_ReadSector             EvtFsIOCId(EventLevelAPI,      9)

 #define EvtFsIOC_ReadSectorSuccess      EvtFsIOCId(EventLevelOp,      10)

 #define EvtFsIOC_ReadSectorError        EvtFsIOCId(EventLevelError,   11)

 #define EvtFsIOC_WriteSector            EvtFsIOCId(EventLevelAPI,     12)

 #define EvtFsIOC_WriteSectorSuccess     EvtFsIOCId(EventLevelOp,      13)

 #define EvtFsIOC_WriteSectorError       EvtFsIOCId(EventLevelError,   14)

 #define EvtFsIOC_ReadInfo               EvtFsIOCId(EventLevelAPI,     15)

 #define EvtFsIOC_ReadInfoSuccess        EvtFsIOCId(EventLevelOp,      16)

 #define EvtFsIOC_ReadInfoError          EvtFsIOCId(EventLevelError,   17)

 #define EvtFsIOC_DeviceControl          EvtFsIOCId(EventLevelAPI,     18)

 #define EvtFsIOC_DeviceControlSuccess   EvtFsIOCId(EventLevelOp,      19)

 #define EvtFsIOC_DriveIdInvalid         EvtFsIOCId(EventLevelError,   20)

 #define EvtFsIOC_DriveNotFAT            EvtFsIOCId(EventLevelError,   21)

 #define EvtFsIOC_NotAllowed             EvtFsIOCId(EventLevelError,   22)


 /* Event id list for "FsNFTL" */

 #define EvtFsNFTL_Init                  EvtFsNFTLId(EventLevelOp,      0)

 #define EvtFsNFTL_InitMediaFailed       EvtFsNFTLId(EventLevelError,   1)

 #define EvtFsNFTL_Mount                 EvtFsNFTLId(EventLevelOp,      2)

 #define EvtFsNFTL_MountSuccess          EvtFsNFTLId(EventLevelOp,      3)

 #define EvtFsNFTL_DeviceNotInitialized  EvtFsNFTLId(EventLevelError,   4)

 #define EvtFsNFTL_ResetDevice           EvtFsNFTLId(EventLevelOp,      5)

 #define EvtFsNFTL_ResetDeviceFailed     EvtFsNFTLId(EventLevelError,   6)

 #define EvtFsNFTL_ResetDeviceTimeout    EvtFsNFTLId(EventLevelError,   7)

 #define EvtFsNFTL_ReadBootBlock         EvtFsNFTLId(EventLevelOp,      8)

 #define EvtFsNFTL_ReadBootBlockFailed   EvtFsNFTLId(EventLevelError,   9)

 #define EvtFsNFTL_BootSignatureValid    EvtFsNFTLId(EventLevelOp,     10)

 #define EvtFsNFTL_BootSignatureInvalid  EvtFsNFTLId(EventLevelOp,     11)

 #define EvtFsNFTL_DataBlockCapacity     EvtFsNFTLId(EventLevelOp,     12)

 #define EvtFsNFTL_ReadTable             EvtFsNFTLId(EventLevelOp,     13)

 #define EvtFsNFTL_ReadTableFailed       EvtFsNFTLId(EventLevelError,  14)

 #define EvtFsNFTL_Uninit                EvtFsNFTLId(EventLevelOp,     15)

 #define EvtFsNFTL_UninitDriver          EvtFsNFTLId(EventLevelOp,     16)

 #define EvtFsNFTL_UninitDriverFailed    EvtFsNFTLId(EventLevelError,  17)

 #define EvtFsNFTL_ReadInfo              EvtFsNFTLId(EventLevelOp,     18)

 #define EvtFsNFTL_ReadInfoSuccess       EvtFsNFTLId(EventLevelOp,     19)

 #define EvtFsNFTL_DevCtrl               EvtFsNFTLId(EventLevelOp,     20)

 #define EvtFsNFTL_DevCtrlUnsupported    EvtFsNFTLId(EventLevelError,  21)

 #define EvtFsNFTL_Format                EvtFsNFTLId(EventLevelOp,     22)

 #define EvtFsNFTL_FormatSuccess         EvtFsNFTLId(EventLevelOp,     23)

 #define EvtFsNFTL_FormatLLEB            EvtFsNFTLId(EventLevelOp,     24)

 #define EvtFsNFTL_BBMPositionSet        EvtFsNFTLId(EventLevelOp,     25)

 #define EvtFsNFTL_BadBlockDetected      EvtFsNFTLId(EventLevelOp,     26)

 #define EvtFsNFTL_BadBlockMark          EvtFsNFTLId(EventLevelOp,     27)

 #define EvtFsNFTL_WriteSector           EvtFsNFTLId(EventLevelOp,     28)

 #define EvtFsNFTL_WriteSectorSuccess    EvtFsNFTLId(EventLevelOp,     29)

 #define EvtFsNFTL_ReadSector            EvtFsNFTLId(EventLevelOp,     30)

 #define EvtFsNFTL_ReadSectorSuccess     EvtFsNFTLId(EventLevelOp,     31)

 #define EvtFsNFTL_LsnToLbn              EvtFsNFTLId(EventLevelOp,     32)

 #define EvtFsNFTL_LbnToPbn              EvtFsNFTLId(EventLevelOp,     33)

 #define EvtFsNFTL_LbnOutOfRange         EvtFsNFTLId(EventLevelError,  34)

 #define EvtFsNFTL_PbnOutOfRange         EvtFsNFTLId(EventLevelError,  35)

 #define EvtFsNFTL_TableLookup           EvtFsNFTLId(EventLevelOp,     36)

 #define EvtFsNFTL_TableEntryNotFound    EvtFsNFTLId(EventLevelOp,     37)

 #define EvtFsNFTL_AllocateBlock         EvtFsNFTLId(EventLevelOp,     38)

 #define EvtFsNFTL_LsnFind               EvtFsNFTLId(EventLevelOp,     39)

 #define EvtFsNFTL_LsnFound              EvtFsNFTLId(EventLevelOp,     40)

 #define EvtFsNFTL_LsnNotFound           EvtFsNFTLId(EventLevelOp,     41)

 #define EvtFsNFTL_GarbageCollection     EvtFsNFTLId(EventLevelOp,     42)

 #define EvtFsNFTL_SetBadBlockMarker     EvtFsNFTLId(EventLevelOp,     43)

 #define EvtFsNFTL_MoveData              EvtFsNFTLId(EventLevelOp,     44)

 #define EvtFsNFTL_RelocateBlock         EvtFsNFTLId(EventLevelOp,     45)

 #define EvtFsNFTL_RelocateBlockFailed   EvtFsNFTLId(EventLevelError,  46)

 #define EvtFsNFTL_SkipBadBlock          EvtFsNFTLId(EventLevelOp,     47)

 #define EvtFsNFTL_PageReadFailed        EvtFsNFTLId(EventLevelError,  48)

 #define EvtFsNFTL_PageProgramStatusErr  EvtFsNFTLId(EventLevelOp,     49)

 #define EvtFsNFTL_PageProgramFailed     EvtFsNFTLId(EventLevelError,  50)

 #define EvtFsNFTL_PageProgramTimeout    EvtFsNFTLId(EventLevelError,  51)

 #define EvtFsNFTL_BlockEraseStatusErr   EvtFsNFTLId(EventLevelOp,     52)

 #define EvtFsNFTL_BlockEraseFailed      EvtFsNFTLId(EventLevelError,  53)

 #define EvtFsNFTL_BlockEraseTimeout     EvtFsNFTLId(EventLevelError,  54)

 #define EvtFsNFTL_BitErrorCorrected     EvtFsNFTLId(EventLevelOp,     55)

 #define EvtFsNFTL_ParameterInvalid      EvtFsNFTLId(EventLevelError,  56)

 #define EvtFsNFTL_TableUpdate           EvtFsNFTLId(EventLevelOp,     57)

 #define EvtFsNFTL_AllocatedBlock        EvtFsNFTLId(EventLevelOp,     58)

 #define EvtFsNFTL_LoadSector            EvtFsNFTLId(EventLevelDetail, 59)

 #define EvtFsNFTL_LoadTableLayout       EvtFsNFTLId(EventLevelDetail, 60)

 #define EvtFsNFTL_LoadDataLayout        EvtFsNFTLId(EventLevelDetail, 61)

 #define EvtFsNFTL_SetupPageLayout       EvtFsNFTLId(EventLevelDetail, 62)

 #define EvtFsNFTL_SetupSpareLayout      EvtFsNFTLId(EventLevelDetail, 63)

 #define EvtFsNFTL_PageWrite             EvtFsNFTLId(EventLevelDetail, 64)

 #define EvtFsNFTL_PageRead              EvtFsNFTLId(EventLevelDetail, 65)

 #define EvtFsNFTL_BlockErase            EvtFsNFTLId(EventLevelDetail, 66)

 #define EvtFsNFTL_StatusRead            EvtFsNFTLId(EventLevelDetail, 67)

 #define EvtFsNFTL_CacheWrite            EvtFsNFTLId(EventLevelDetail, 68)

 #define EvtFsNFTL_CacheRead             EvtFsNFTLId(EventLevelDetail, 69)


 /* Event id list for "FsNAND" */

 #define EvtFsNAND_Init                  EvtFsNANDId(EventLevelOp,      0)

 #define EvtFsNAND_InitDriver            EvtFsNANDId(EventLevelOp,      1)

 #define EvtFsNAND_InitDriverError       EvtFsNANDId(EventLevelError,   2)

 #define EvtFsNAND_DriverPowerCtrlError  EvtFsNANDId(EventLevelError,   3)

 #define EvtFsNAND_DriverBusModeSelect   EvtFsNANDId(EventLevelOp,      4)

 #define EvtFsNAND_DriverBusWidthSelect  EvtFsNANDId(EventLevelOp,      5)

 #define EvtFsNAND_DriverBusWidthError   EvtFsNANDId(EventLevelError,   6)

 #define EvtFsNAND_DriverDevPowerSelect  EvtFsNANDId(EventLevelOp,      7)

 #define EvtFsNAND_DriverEccInquire      EvtFsNANDId(EventLevelOp,      8)

 #define EvtFsNAND_DriverEccSelect       EvtFsNANDId(EventLevelOp,      9)

 #define EvtFsNAND_DriverEccInquireError EvtFsNANDId(EventLevelOp,     10)

 #define EvtFsNAND_DriverTimeoutError    EvtFsNANDId(EventLevelError,  11)

 #define EvtFsNAND_DeviceTimeoutError    EvtFsNANDId(EventLevelError,  12)

 #define EvtFsNAND_Uninit                EvtFsNANDId(EventLevelOp,     13)

 #define EvtFsNAND_StatusRead            EvtFsNANDId(EventLevelDetail, 14)

 #define EvtFsNAND_BlockErase            EvtFsNANDId(EventLevelOp,     15)

 #define EvtFsNAND_PageWrite             EvtFsNANDId(EventLevelOp,     16)

 #define EvtFsNAND_PageRead              EvtFsNANDId(EventLevelOp,     17)

 #define EvtFsNAND_ParamPageRead         EvtFsNANDId(EventLevelOp,     18)

 #define EvtFsNAND_IdRead                EvtFsNANDId(EventLevelOp,     19)

 #define EvtFsNAND_DeviceReset           EvtFsNANDId(EventLevelOp,     20)


 /* Event id list for "FsMcMCI" */

 #define EvtFsMcMCI_InitDriver           EvtFsMcMCIId(EventLevelOp,     0)

 #define EvtFsMcMCI_InitDriverError      EvtFsMcMCIId(EventLevelError,  1)

 #define EvtFsMcMCI_InitDriverPowerError EvtFsMcMCIId(EventLevelError,  2)

 #define EvtFsMcMCI_InitMedia            EvtFsMcMCIId(EventLevelOp,     3)

 #define EvtFsMcMCI_MediaNotInitialized  EvtFsMcMCIId(EventLevelOp,     4)

 #define EvtFsMcMCI_MediaCdActive        EvtFsMcMCIId(EventLevelOp,     5)

 #define EvtFsMcMCI_MediaCdInactive      EvtFsMcMCIId(EventLevelError,  6)

 #define EvtFsMcMCI_MediaWpActive        EvtFsMcMCIId(EventLevelOp,     7)

 #define EvtFsMcMCI_MediaWpInactive      EvtFsMcMCIId(EventLevelOp,     8)

 #define EvtFsMcMCI_MediaReset           EvtFsMcMCIId(EventLevelOp,     9)

 #define EvtFsMcMCI_MediaDetectionSD     EvtFsMcMCIId(EventLevelOp,    10)

 #define EvtFsMcMCI_MediaSD_V2           EvtFsMcMCIId(EventLevelOp,    11)

 #define EvtFsMcMCI_MediaReady           EvtFsMcMCIId(EventLevelOp,    12)

 #define EvtFsMcMCI_MediaNoResponse      EvtFsMcMCIId(EventLevelOp,    13)

 #define EvtFsMcMCI_MediaDetectionMMC    EvtFsMcMCIId(EventLevelOp,    14)

 #define EvtFsMcMCI_MediaDetectionError  EvtFsMcMCIId(EventLevelError, 15)

 #define EvtFsMcMCI_CidReadError         EvtFsMcMCIId(EventLevelError, 16)

 #define EvtFsMcMCI_RcaReadError         EvtFsMcMCIId(EventLevelError, 17)

 #define EvtFsMcMCI_RcaWriteError        EvtFsMcMCIId(EventLevelError, 18)

 #define EvtFsMcMCI_CsdReadError         EvtFsMcMCIId(EventLevelError, 19)

 #define EvtFsMcMCI_TranStateError       EvtFsMcMCIId(EventLevelError, 20)

 #define EvtFsMcMCI_BlenWriteError       EvtFsMcMCIId(EventLevelError, 21)

 #define EvtFsMcMCI_ExtCsdReadError      EvtFsMcMCIId(EventLevelError, 22)

 #define EvtFsMcMCI_HighSpeedSwitchError EvtFsMcMCIId(EventLevelError, 23)

 #define EvtFsMcMCI_DataBusSwitchError   EvtFsMcMCIId(EventLevelError, 24)

 #define EvtFsMcMCI_StbyStateError       EvtFsMcMCIId(EventLevelError, 25)

 #define EvtFsMcMCI_InitSuccess          EvtFsMcMCIId(EventLevelOp,    26)

 #define EvtFsMcMCI_UninitDriver         EvtFsMcMCIId(EventLevelOp,    27)

 #define EvtFsMcMCI_UninitMedia          EvtFsMcMCIId(EventLevelOp,    28)

 #define EvtFsMcMCI_SectorRead           EvtFsMcMCIId(EventLevelOp,    29)

 #define EvtFsMcMCI_SectorReadError      EvtFsMcMCIId(EventLevelError, 30)

 #define EvtFsMcMCI_SectorWrite          EvtFsMcMCIId(EventLevelOp,    31)

 #define EvtFsMcMCI_SectorWriteError     EvtFsMcMCIId(EventLevelError, 32)

 #define EvtFsMcMCI_TransferError        EvtFsMcMCIId(EventLevelError, 33)

 #define EvtFsMcMCI_TransferRetry        EvtFsMcMCIId(EventLevelOp,    34)

 #define EvtFsMcMCI_ReadInfo             EvtFsMcMCIId(EventLevelOp,    35)

 #define EvtFsMcMCI_ReadInfoSuccess      EvtFsMcMCIId(EventLevelOp,    36)

 #define EvtFsMcMCI_DevCtrl              EvtFsMcMCIId(EventLevelOp,    37)

 #define EvtFsMcMCI_DevCtrlUnsupported   EvtFsMcMCIId(EventLevelOp,    38)

 #define EvtFsMcMCI_LockUnlockExec       EvtFsMcMCIId(EventLevelOp,    39)

 #define EvtFsMcMCI_LockUnlockExecError  EvtFsMcMCIId(EventLevelError, 40)

 #define EvtFsMcMCI_LockActive           EvtFsMcMCIId(EventLevelOp,    41)

 #define EvtFsMcMCI_LockDeactivated      EvtFsMcMCIId(EventLevelOp,    42)

 #define EvtFsMcMCI_DeviceStateUnknown   EvtFsMcMCIId(EventLevelError, 43)

 #define EvtFsMcMCI_DeviceStateInvalid   EvtFsMcMCIId(EventLevelError, 44)

 #define EvtFsMcMCI_DeviceStateTimeout   EvtFsMcMCIId(EventLevelError, 45)

 #define EvtFsMcMCI_TransferAbort        EvtFsMcMCIId(EventLevelOp,    46)

 #define EvtFsMcMCI_SleepAwakeControl    EvtFsMcMCIId(EventLevelOp,    47)

 #define EvtFsMcMCI_SleepActive          EvtFsMcMCIId(EventLevelOp,    48)

 #define EvtFsMcMCI_AwakeActive          EvtFsMcMCIId(EventLevelOp,    49)

 #define EvtFsMcMCI_CardPowerControl     EvtFsMcMCIId(EventLevelOp,    50)

 #define EvtFsMcMCI_SendCommandError     EvtFsMcMCIId(EventLevelError, 51)

 #define EvtFsMcMCI_ReadXferSetupError   EvtFsMcMCIId(EventLevelError, 52)

 #define EvtFsMcMCI_WriteXferSetupError  EvtFsMcMCIId(EventLevelError, 53)

 #define EvtFsMcMCI_ParameterInvalid     EvtFsMcMCIId(EventLevelError, 54)

 #define EvtFsMcMCI_MediaPasswordEnabled EvtFsMcMCIId(EventLevelError, 55)


 /* Event id list for "FsMcSPI" */

 #define EvtFsMcSPI_InitDriver           EvtFsMcSPIId(EventLevelOp,     0)

 #define EvtFsMcSPI_InitDriverSuccess    EvtFsMcSPIId(EventLevelOp,     1)

 #define EvtFsMcSPI_InitDriverError      EvtFsMcSPIId(EventLevelError,  2)

 #define EvtFsMcSPI_InitDriverPowerError EvtFsMcSPIId(EventLevelError,  3)

 #define EvtFsMcSPI_InitMedia            EvtFsMcSPIId(EventLevelOp,     4)

 #define EvtFsMcSPI_InitMediaSuccess     EvtFsMcSPIId(EventLevelOp,     5)

 #define EvtFsMcSPI_MediaNotInitialized  EvtFsMcSPIId(EventLevelError,  6)

 #define EvtFsMcSPI_MediaCdActive        EvtFsMcSPIId(EventLevelOp,     7)

 #define EvtFsMcSPI_MediaCdInactive      EvtFsMcSPIId(EventLevelError,  8)

 #define EvtFsMcSPI_MediaWpActive        EvtFsMcSPIId(EventLevelOp,     9)

 #define EvtFsMcSPI_MediaWpInactive      EvtFsMcSPIId(EventLevelOp,    10)

 #define EvtFsMcSPI_MediaReset           EvtFsMcSPIId(EventLevelOp,    11)

 #define EvtFsMcSPI_MediaResetError      EvtFsMcSPIId(EventLevelError, 12)

 #define EvtFsMcSPI_MediaDetectionSD     EvtFsMcSPIId(EventLevelOp,    13)

 #define EvtFsMcSPI_MediaSD_V2           EvtFsMcSPIId(EventLevelOp,    14)

 #define EvtFsMcSPI_MediaReady           EvtFsMcSPIId(EventLevelOp,    15)

 #define EvtFsMcSPI_MediaNoResponse      EvtFsMcSPIId(EventLevelOp,    16)

 #define EvtFsMcSPI_MediaDetectionMMC    EvtFsMcSPIId(EventLevelOp,    17)

 #define EvtFsMcSPI_MediaDetectionError  EvtFsMcSPIId(EventLevelError, 18)

 #define EvtFsMcSPI_CidReadError         EvtFsMcSPIId(EventLevelError, 19)

 #define EvtFsMcSPI_CsdReadError         EvtFsMcSPIId(EventLevelError, 20)

 #define EvtFsMcSPI_BlenWriteError       EvtFsMcSPIId(EventLevelError, 21)

 #define EvtFsMcSPI_UninitDriver         EvtFsMcSPIId(EventLevelOp,    22)

 #define EvtFsMcSPI_UninitMedia          EvtFsMcSPIId(EventLevelOp,    23)

 #define EvtFsMcSPI_SectorRead           EvtFsMcSPIId(EventLevelOp,    24)

 #define EvtFsMcSPI_SectorReadError      EvtFsMcSPIId(EventLevelError, 25)

 #define EvtFsMcSPI_SectorWrite          EvtFsMcSPIId(EventLevelOp,    26)

 #define EvtFsMcSPI_SectorWriteError     EvtFsMcSPIId(EventLevelError, 27)

 #define EvtFsMcSPI_ReadInfo             EvtFsMcSPIId(EventLevelOp,    28)

 #define EvtFsMcSPI_ReadInfoSuccess      EvtFsMcSPIId(EventLevelOp,    29)

 #define EvtFsMcSPI_DevCtrl              EvtFsMcSPIId(EventLevelOp,    30)

 #define EvtFsMcSPI_DevCtrlUnsupported   EvtFsMcSPIId(EventLevelError, 31)

 #define EvtFsMcSPI_LockUnlockExec       EvtFsMcSPIId(EventLevelOp,    32)

 #define EvtFsMcSPI_LockUnlockExecError  EvtFsMcSPIId(EventLevelError, 33)

 #define EvtFsMcSPI_LockActive           EvtFsMcSPIId(EventLevelOp,    34)

 #define EvtFsMcSPI_LockDeactivated      EvtFsMcSPIId(EventLevelOp,    35)

 #define EvtFsMcSPI_BusSpeedControl      EvtFsMcSPIId(EventLevelOp,    36)

 #define EvtFsMcSPI_SlaveSelCtrlMissing  EvtFsMcSPIId(EventLevelOp,    37)

 #define EvtFsMcSPI_ReadCdMissing        EvtFsMcSPIId(EventLevelOp,    38)

 #define EvtFsMcSPI_ReadWpMissing        EvtFsMcSPIId(EventLevelOp,    39)

 #define EvtFsMcSPI_CrcDisableError      EvtFsMcSPIId(EventLevelError, 40)

 #define EvtFsMcSPI_DriverSendError      EvtFsMcSPIId(EventLevelError, 41)

 #define EvtFsMcSPI_DriverReceiveError   EvtFsMcSPIId(EventLevelError, 42)

 #define EvtFsMcSPI_CmdSendError         EvtFsMcSPIId(EventLevelError, 43)

 #define EvtFsMcSPI_CmdResponseError     EvtFsMcSPIId(EventLevelError, 44)

 #define EvtFsMcSPI_ACmdResponseError    EvtFsMcSPIId(EventLevelError, 45)

 #define EvtFsMcSPI_ParameterInvalid     EvtFsMcSPIId(EventLevelError, 46)

 #define EvtFsMcSPI_MediaPasswordEnabled EvtFsMcSPIId(EventLevelError, 47)

 #endif


 #ifdef EvtFsCore_sys_open

   __STATIC_INLINE void EvrFsCore_sys_open (const char *name, int openmode) {

     EventRecord2 (EvtFsCore_sys_open, (uint32_t)name, (uint32_t)openmode);

   }

 #else

   #define EvrFsCore_sys_open(name, openmode)

 #endif


 #ifdef EvtFsCore_sys_close

   __STATIC_INLINE void EvrFsCore_sys_close (int fh) {

     EventRecord2 (EvtFsCore_sys_close, (uint32_t)fh, 0);

   }

 #else

   #define EvrFsCore_sys_close(fh)

 #endif


 #ifdef EvtFsCore_sys_write

   __STATIC_INLINE void EvrFsCore_sys_write (int fh, const unsigned char *buf, unsigned int len) {

     EventRecord4 (EvtFsCore_sys_write, (uint32_t)fh, (uint32_t)buf, len, 0);

   }

 #else

   #define EvrFsCore_sys_write(fh, buf, len)

 #endif


 #ifdef EvtFsCore_sys_read

   __STATIC_INLINE void EvrFsCore_sys_read (int fh, unsigned char *buf, unsigned int len) {

     EventRecord4 (EvtFsCore_sys_read, (uint32_t)fh, (uint32_t)buf, len, 0);

   }

 #else

   #define EvrFsCore_sys_read(fh, buf, len)

 #endif


 #ifdef EvtFsCore_sys_seek

   __STATIC_INLINE void EvrFsCore_sys_seek (int fh, long pos) {

     EventRecord2 (EvtFsCore_sys_seek, (uint32_t)fh, (uint32_t)pos);

   }

 #else

   #define EvrFsCore_sys_seek(fh, pos)

 #endif


 #ifdef EvtFsCore_sys_flen

   __STATIC_INLINE void EvrFsCore_sys_flen (int fh) {

     EventRecord2 (EvtFsCore_sys_flen, (uint32_t)fh, 0);

   }

 #else

   #define EvrFsCore_sys_flen(fh)

 #endif


 #ifdef EvtFsCore_sys_handle_assign

   __STATIC_INLINE void EvrFsCore_sys_handle_assign (const char *name, int fh) {

     EventRecord2 (EvtFsCore_sys_handle_assign, (uint32_t)name, (uint32_t)fh);

   }

 #else

   #define EvrFsCore_sys_handle_assign(name, fh)

 #endif


 #ifdef EvtFsCore_finit

   __STATIC_INLINE void EvrFsCore_finit (const char *drive) {

     EventRecord2 (EvtFsCore_finit, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_finit(drive)

 #endif


 #ifdef EvtFsCore_funinit

   __STATIC_INLINE void EvrFsCore_funinit (const char *drive) {

     EventRecord2 (EvtFsCore_funinit, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_funinit(drive)

 #endif


 #ifdef EvtFsCore_fmount

   __STATIC_INLINE void EvrFsCore_fmount (const char *drive) {

     EventRecord2 (EvtFsCore_fmount, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_fmount(drive)

 #endif


 #ifdef EvtFsCore_funmount

   __STATIC_INLINE void EvrFsCore_funmount (const char *drive) {

     EventRecord2 (EvtFsCore_funmount, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_funmount(drive)

 #endif


 #ifdef EvtFsCore_fdelete_l

   __STATIC_INLINE void EvrFsCore_fdelete_l (const char *path) {

     EventRecord2 (EvtFsCore_fdelete_l, (uint32_t)path, 0);

   }

 #else

   #define EvrFsCore_fdelete_l(path)

 #endif


 #ifdef EvtFsCore_fdelete

   __STATIC_INLINE void EvrFsCore_fdelete (const char *path, const char *options) {

     EventRecord2 (EvtFsCore_fdelete, (uint32_t)path, (uint32_t)options);

   }

 #else

   #define EvrFsCore_fdelete(path, options)

 #endif


 #ifdef EvtFsCore_ffind

   __STATIC_INLINE void EvrFsCore_ffind (const char *pattern, fsFileInfo *info) {

     EventRecord2 (EvtFsCore_ffind, (uint32_t)pattern, (uint32_t)info);

   }

 #else

   #define EvrFsCore_ffind(pattern, info)

 #endif


 #ifdef EvtFsCore_frename

   __STATIC_INLINE void EvrFsCore_frename (const char *path, const char *newname) {

     EventRecord2 (EvtFsCore_frename, (uint32_t)path, (uint32_t)newname);

   }

 #else

   #define EvrFsCore_frename(path, newname)

 #endif


 #ifdef EvtFsCore_fattrib

   __STATIC_INLINE void EvrFsCore_fattrib (const char *path, const char *attr) {

     EventRecord2 (EvtFsCore_fattrib, (uint32_t)path, (uint32_t)attr);

   }

 #else

   #define EvrFsCore_fattrib(path, attr)

 #endif


 #ifdef EvtFsCore_fpwd

   __STATIC_INLINE void EvrFsCore_fpwd (const char *drive, char *buf, uint32_t len) {

     EventRecord4 (EvtFsCore_fpwd, (uint32_t)drive, (uint32_t)buf, len, 0);

   }

 #else

   #define EvrFsCore_fpwd(drive, buf, len)

 #endif


 #ifdef EvtFsCore_fchdir

   __STATIC_INLINE void EvrFsCore_fchdir (const char *path) {

     EventRecord2 (EvtFsCore_fchdir, (uint32_t)path, 0);

   }

 #else

   #define EvrFsCore_fchdir(path)

 #endif


 #ifdef EvtFsCore_fmkdir

   __STATIC_INLINE void EvrFsCore_fmkdir (const char *path) {

     EventRecord2 (EvtFsCore_fmkdir, (uint32_t)path, 0);

   }

 #else

   #define EvrFsCore_fmkdir(path)

 #endif


 #ifdef EvtFsCore_frmdir

   __STATIC_INLINE void EvrFsCore_frmdir (const char *path, const char *options) {

     EventRecord2 (EvtFsCore_frmdir, (uint32_t)path, (uint32_t)options);

   }

 #else

   #define EvrFsCore_frmdir(path, options)

 #endif


 #ifdef EvtFsCore_fchdrive

   __STATIC_INLINE void EvrFsCore_fchdrive (const char *drive) {

     EventRecord2 (EvtFsCore_fchdrive, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_fchdrive(drive)

 #endif


 #ifdef EvtFsCore_ffree

   __STATIC_INLINE void EvrFsCore_ffree (const char *drive) {

     EventRecord2 (EvtFsCore_ffree, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_ffree(drive)

 #endif


 #ifdef EvtFsCore_fformat

   __STATIC_INLINE void EvrFsCore_fformat (const char *drive, const char *options) {

     EventRecord2 (EvtFsCore_fformat, (uint32_t)drive, (uint32_t)options);

   }

 #else

   #define EvrFsCore_fformat(drive, options)

 #endif


 #ifdef EvtFsCore_fanalyse

   __STATIC_INLINE void EvrFsCore_fanalyse (const char *drive) {

     EventRecord2 (EvtFsCore_fanalyse, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_fanalyse(drive)

 #endif


 #ifdef EvtFsCore_fcheck

   __STATIC_INLINE void EvrFsCore_fcheck (const char *drive) {

     EventRecord2 (EvtFsCore_fcheck, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_fcheck(drive)

 #endif


 #ifdef EvtFsCore_fdefrag

   __STATIC_INLINE void EvrFsCore_fdefrag (const char *drive) {

     EventRecord2 (EvtFsCore_fdefrag, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_fdefrag(drive)

 #endif


 #ifdef EvtFsCore_fmedia

   __STATIC_INLINE void EvrFsCore_fmedia (const char *drive) {

     EventRecord2 (EvtFsCore_fmedia, (uint32_t)drive, 0);

   }

 #else

   #define EvrFsCore_fmedia(drive)

 #endif


 #ifdef EvtFsCore_finfo

   __STATIC_INLINE void EvrFsCore_finfo (const char *drive, fsDriveInfo *info) {

     EventRecord2 (EvtFsCore_finfo, (uint32_t)drive, (uint32_t)info);

   }

 #else

   #define EvrFsCore_finfo(drive, info)

 #endif


 #ifdef EvtFsCore_fvol

   __STATIC_INLINE void EvrFsCore_fvol (const char *drive, char *label, uint32_t *serial) {

     EventRecord4 (EvtFsCore_fvol, (uint32_t)drive, (uint32_t)label, (uint32_t)serial, 0);

   }

 #else

   #define EvrFsCore_fvol(drive, label, serial)

 #endif


 #ifdef EvtFsCore_InvalidDrive

   __STATIC_INLINE void EvrFsCore_InvalidDrive (uint32_t drive) {

     EventRecord2 (EvtFsCore_InvalidDrive, drive, 0);

   }

 #else

   #define EvrFsCore_InvalidDrive(drive)

 #endif


 #ifdef EvtFsCore_CurrentDriveSelect

   __STATIC_INLINE void EvrFsCore_CurrentDriveSelect (uint32_t drive) {

     EventRecord2 (EvtFsCore_CurrentDriveSelect, drive, 0);

   }

 #else

   #define EvrFsCore_CurrentDriveSelect(drive)

 #endif


 #ifdef EvtFsCore_ftime_set

   __STATIC_INLINE void EvrFsCore_ftime_set (const char *path, fsTime *create, fsTime *access, fsTime *write) {

     EventRecord4 (EvtFsCore_ftime_set, (uint32_t)path, (uint32_t)create, (uint32_t)access, (uint32_t)write);

   }

 #else

   #define EvrFsCore_ftime_set(path, create, access, write)

 #endif


 #ifdef EvtFsCore_ftime_get

   __STATIC_INLINE void EvrFsCore_ftime_get (const char *path, fsTime *create, fsTime *access, fsTime *write) {

     EventRecord4 (EvtFsCore_ftime_get, (uint32_t)path, (uint32_t)create, (uint32_t)access, (uint32_t)write);

   }

 #else

   #define EvrFsCore_ftime_get(path, create, access, write)

 #endif


 #ifdef EvtFsCore_fversion

   __STATIC_INLINE void EvrFsCore_fversion (uint32_t version) {

     uint32_t MMmm, bbbb;


     MMmm   = (((version >> 28) & 0xF)*10) + ((version >> 24) & 0xF);

     MMmm <<= 16;

     MMmm  |= (((version >> 20) & 0xF)*10) + ((version >> 16) & 0xF);


     bbbb   = ((version >> 12) & 0xF)*1000 + \

              ((version >>  8) & 0xF)*100  + \

              ((version >>  4) & 0xF)*10   + \

               (version & 0xF);


     EventRecord2 (EvtFsCore_fversion, MMmm, bbbb);

   }

 #else

   #define EvrFsCore_fversion(version)

 #endif


 #ifdef EvtFsFAT_InitDrive

   __STATIC_INLINE void EvrFsFAT_InitDrive(uint32_t drive) {

     EventRecord2(EvtFsFAT_InitDrive, drive, 0);

   }

 #else

   #define EvrFsFAT_InitDrive(drive)

 #endif


 #ifdef EvtFsFAT_InitDriveSuccess

   __STATIC_INLINE void EvrFsFAT_InitDriveSuccess(uint32_t drive) {

     EventRecord2(EvtFsFAT_InitDriveSuccess, drive, 0);

   }

 #else

   #define EvrFsFAT_InitDriveSuccess(drive)

 #endif


 #ifdef EvtFsFAT_InitDriverCfgError

   __STATIC_INLINE void EvrFsFAT_InitDriverCfgError(uint32_t drive) {

     EventRecord2(EvtFsFAT_InitDriverCfgError, drive, 0);

   }

 #else

   #define EvrFsFAT_InitDriverCfgError(drive)

 #endif


 #ifdef EvtFsFAT_InitDriverError

   __STATIC_INLINE void EvrFsFAT_InitDriverError(uint32_t drive) {

     EventRecord2(EvtFsFAT_InitDriverError, drive, 0);

   }

 #else

   #define EvrFsFAT_InitDriverError(drive)

 #endif


 #ifdef EvtFsFAT_UninitDrive

   __STATIC_INLINE void EvrFsFAT_UninitDrive(uint32_t drive) {

     EventRecord2(EvtFsFAT_UninitDrive, drive, 0);

   }

 #else

   #define EvrFsFAT_UninitDrive(drive)

 #endif


 #ifdef EvtFsFAT_MountDrive

   __STATIC_INLINE void EvrFsFAT_MountDrive(uint32_t drive) {

     EventRecord2(EvtFsFAT_MountDrive, drive, 0);

   }

 #else

   #define EvrFsFAT_MountDrive(drive)

 #endif


 #ifdef EvtFsFAT_InitMediaError

   __STATIC_INLINE void EvrFsFAT_InitMediaError(uint32_t drive) {

     EventRecord2(EvtFsFAT_InitMediaError, drive, 0);

   }

 #else

   #define EvrFsFAT_InitMediaError(drive)

 #endif


 #ifdef EvtFsFAT_MediaInsertStatError

   __STATIC_INLINE void EvrFsFAT_MediaInsertStatError(uint32_t drive) {

     EventRecord2(EvtFsFAT_MediaInsertStatError, drive, 0);

   }

 #else

   #define EvrFsFAT_MediaInsertStatError(drive)

 #endif


 #ifdef EvtFsFAT_MediaInitStatError

   __STATIC_INLINE void EvrFsFAT_MediaInitStatError(uint32_t drive) {

     EventRecord2(EvtFsFAT_MediaInitStatError, drive, 0);

   }

 #else

   #define EvrFsFAT_MediaInitStatError(drive)

 #endif


 #ifdef EvtFsFAT_VolumeReadyStatError

   __STATIC_INLINE void EvrFsFAT_VolumeReadyStatError(uint32_t drive) {

     EventRecord2(EvtFsFAT_VolumeReadyStatError, drive, 0);

   }

 #else

   #define EvrFsFAT_VolumeReadyStatError(drive)

 #endif


 #ifdef EvtFsFAT_VolumeWriteStatError

   __STATIC_INLINE void EvrFsFAT_VolumeWriteStatError(uint32_t drive) {

     EventRecord2(EvtFsFAT_VolumeWriteStatError, drive, 0);

   }

 #else

   #define EvrFsFAT_VolumeWriteStatError(drive)

 #endif


 #ifdef EvtFsFAT_VolumeNotMounted

   __STATIC_INLINE void EvrFsFAT_VolumeNotMounted (uint32_t drive) {

     EventRecord2(EvtFsFAT_VolumeNotMounted, drive, 0);

   }

 #else

   #define EvrFsFAT_VolumeNotMounted(drive)

 #endif


 #ifdef EvtFsFAT_ReadMBR

   __STATIC_INLINE void EvrFsFAT_ReadMBR (uint32_t drive, uint32_t sector) {

     EventRecord2(EvtFsFAT_ReadMBR, drive, sector);

   }

 #else

   #define EvrFsFAT_ReadMBR(drive, sector)

 #endif


 #ifdef EvtFsFAT_InvalidMBR

   __STATIC_INLINE void EvrFsFAT_InvalidMBR (uint32_t drive) {

     EventRecord2(EvtFsFAT_InvalidMBR, drive, 0);

   }

 #else

   #define EvrFsFAT_InvalidMBR(drive)

 #endif


 #ifdef EvtFsFAT_NonexistentMBR

   __STATIC_INLINE void EvrFsFAT_NonexistentMBR (uint32_t drive) {

     EventRecord2(EvtFsFAT_NonexistentMBR, drive, 0);

   }

 #else

   #define EvrFsFAT_NonexistentMBR(drive)

 #endif


 #ifdef EvtFsFAT_ReadBootSector

   __STATIC_INLINE void EvrFsFAT_ReadBootSector (uint32_t drive, uint32_t sector) {

     EventRecord2(EvtFsFAT_ReadBootSector, drive, sector);

   }

 #else

   #define EvrFsFAT_ReadBootSector(drive, sector)

 #endif


 #ifdef EvtFsFAT_InvalidBootSector

   __STATIC_INLINE void EvrFsFAT_InvalidBootSector (uint32_t drive) {

     EventRecord2(EvtFsFAT_InvalidBootSector, drive, 0);

   }

 #else

   #define EvrFsFAT_InvalidBootSector(drive)

 #endif


 #ifdef EvtFsFAT_InvalidFAT

   __STATIC_INLINE void EvrFsFAT_InvalidFAT (uint32_t drive) {

     EventRecord2(EvtFsFAT_InvalidFAT, drive, 0);

   }

 #else

   #define EvrFsFAT_InvalidFAT(drive)

 #endif


 #ifdef EvtFsFAT_ReadFSInfo

   __STATIC_INLINE void EvrFsFAT_ReadFSInfo (uint32_t drive, uint32_t sector) {

     EventRecord2(EvtFsFAT_ReadFSInfo, drive, sector);

   }

 #else

   #define EvrFsFAT_ReadFSInfo(drive, sector)

 #endif


 #ifdef EvtFsFAT_InvalidFSInfo

   __STATIC_INLINE void EvrFsFAT_InvalidFSInfo (uint32_t drive) {

     EventRecord2(EvtFsFAT_InvalidFSInfo, drive, 0);

   }

 #else

   #define EvrFsFAT_InvalidFSInfo(drive)

 #endif


 #ifdef EvtFsFAT_InvalidFreeClusFSInfo

   __STATIC_INLINE void EvrFsFAT_InvalidFreeClusFSInfo (uint32_t drive) {

     EventRecord2(EvtFsFAT_InvalidFreeClusFSInfo, drive, 0);

   }

 #else

   #define EvrFsFAT_InvalidFreeClusFSInfo(drive)

 #endif


 #ifdef EvtFsFAT_InvalidNextClusFSInfo

   __STATIC_INLINE void EvrFsFAT_InvalidNextClusFSInfo (uint32_t drive) {

     EventRecord2(EvtFsFAT_InvalidNextClusFSInfo, drive, 0);

   }

 #else

   #define EvrFsFAT_InvalidNextClusFSInfo(drive)

 #endif


 #ifdef EvtFsFAT_WriteFSInfo

   __STATIC_INLINE void EvrFsFAT_WriteFSInfo (uint32_t drive, uint32_t sector) {

     EventRecord2(EvtFsFAT_WriteFSInfo, drive, sector);

   }

 #else

   #define EvrFsFAT_WriteFSInfo(drive, sector)

 #endif


 #ifdef EvtFsFAT_CountFreeClus

   __STATIC_INLINE void EvrFsFAT_CountFreeClus (uint32_t drive) {

     EventRecord2(EvtFsFAT_CountFreeClus, drive, 0);

   }

 #else

   #define EvrFsFAT_CountFreeClus(drive)

 #endif


 #ifdef EvtFsFAT_MountDriveSuccess

   __STATIC_INLINE void EvrFsFAT_MountDriveSuccess(uint32_t drive) {

     EventRecord2(EvtFsFAT_MountDriveSuccess, drive, 0);

   }

 #else

   #define EvrFsFAT_MountDriveSuccess(drive)

 #endif


 #ifdef EvtFsFAT_UnmountDrive

   __STATIC_INLINE void EvrFsFAT_UnmountDrive(uint32_t drive) {

     EventRecord2(EvtFsFAT_UnmountDrive, drive, 0);

   }

 #else

   #define EvrFsFAT_UnmountDrive(drive)

 #endif


 #ifdef EvtFsFAT_UnmountDriveSuccess

   __STATIC_INLINE void EvrFsFAT_UnmountDriveSuccess(uint32_t drive) {

     EventRecord2(EvtFsFAT_UnmountDriveSuccess, drive, 0);

   }

 #else

   #define EvrFsFAT_UnmountDriveSuccess(drive)

 #endif


 #ifdef EvtFsFAT_FormatDrive

   __STATIC_INLINE void EvrFsFAT_FormatDrive(uint32_t drive) {

     EventRecord2(EvtFsFAT_FormatDrive, drive, 0);

   }

 #else

   #define EvrFsFAT_FormatDrive(drive)

 #endif


 #ifdef EvtFsFAT_FormatDriveSuccess

   __STATIC_INLINE void EvrFsFAT_FormatDriveSuccess(uint32_t drive) {

     EventRecord2(EvtFsFAT_FormatDriveSuccess, drive, 0);

   }

 #else

   #define EvrFsFAT_FormatDriveSuccess(drive)

 #endif


 #ifdef EvtFsFAT_ResetHandles

   __STATIC_INLINE void EvrFsFAT_ResetHandles (uint32_t drive) {

     EventRecord2(EvtFsFAT_ResetHandles, drive, 0);

   }

 #else

   #define EvrFsFAT_ResetHandles(drive)

 #endif


 #ifdef EvtFsFAT_FormatOptionDetected

   __STATIC_INLINE void EvrFsFAT_FormatOptionDetected (uint32_t drive, uint32_t option) {

     EventRecord2(EvtFsFAT_FormatOptionDetected, drive, option);

   }

 #else

   #define EvrFsFAT_FormatOptionDetected(drive, option)

 #endif


 #ifdef EvtFsFAT_FormatMediaCapacity

   __STATIC_INLINE void EvrFsFAT_FormatMediaCapacity (uint32_t drive, uint32_t sectors) {

     EventRecord2(EvtFsFAT_FormatMediaCapacity, drive, sectors);

   }

 #else

   #define EvrFsFAT_FormatMediaCapacity(drive, sectors)

 #endif


 #ifdef EvtFsFAT_FormatLowLevel

   __STATIC_INLINE void EvrFsFAT_FormatLowLevel (uint32_t drive) {

     EventRecord2(EvtFsFAT_FormatLowLevel, drive, 0);

   }

 #else

   #define EvrFsFAT_FormatLowLevel(drive)

 #endif


 #ifdef EvtFsFAT_FormatNoSpace

   __STATIC_INLINE void EvrFsFAT_FormatNoSpace (uint32_t drive) {

     EventRecord2(EvtFsFAT_FormatNoSpace, drive, 0);

   }

 #else

   #define EvrFsFAT_FormatNoSpace(drive)

 #endif


 #ifdef EvtFsFAT_FormatNoSpaceFAT32

   __STATIC_INLINE void EvrFsFAT_FormatNoSpaceFAT32 (uint32_t drive) {

     EventRecord2(EvtFsFAT_FormatNoSpaceFAT32, drive, 0);

   }

 #else

   #define EvrFsFAT_FormatNoSpaceFAT32(drive)

 #endif


 #ifdef EvtFsFAT_WriteMBR

   __STATIC_INLINE void EvrFsFAT_WriteMBR (uint32_t drive, uint32_t sector) {

     EventRecord2(EvtFsFAT_WriteMBR, drive, sector);

   }

 #else

   #define EvrFsFAT_WriteMBR(drive, sector)

 #endif


 #ifdef EvtFsFAT_WriteBootSector

   __STATIC_INLINE void EvrFsFAT_WriteBootSector (uint32_t drive, uint32_t sector) {

     EventRecord2(EvtFsFAT_WriteBootSector, drive, sector);

   }

 #else

   #define EvrFsFAT_WriteBootSector(drive, sector)

 #endif


 #ifdef EvtFsFAT_ClearHiddenSectors

   __STATIC_INLINE void EvrFsFAT_ClearHiddenSectors (uint32_t drive, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsFAT_ClearHiddenSectors, drive, sector, count, 0);

   }

 #else

   #define EvrFsFAT_ClearHiddenSectors(drive, sector, count)

 #endif


 #ifdef EvtFsFAT_ClearReservedSectors

   __STATIC_INLINE void EvrFsFAT_ClearReservedSectors (uint32_t drive, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsFAT_ClearReservedSectors, drive, sector, count, 0);

   }

 #else

   #define EvrFsFAT_ClearReservedSectors(drive, sector, count)

 #endif


 #ifdef EvtFsFAT_ClearRootSectors

   __STATIC_INLINE void EvrFsFAT_ClearRootSectors (uint32_t drive, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsFAT_ClearRootSectors, drive, sector, count, 0);

   }

 #else

   #define EvrFsFAT_ClearRootSectors(drive, sector, count)

 #endif


 #ifdef EvtFsFAT_CreateFAT

   __STATIC_INLINE void EvrFsFAT_CreateFAT (uint32_t drive, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsFAT_CreateFAT, drive, sector, count, 0);

   }

 #else

   #define EvrFsFAT_CreateFAT(drive, sector, count)

 #endif


 #ifdef EvtFsFAT_FormatProperties

   __STATIC_INLINE void EvrFsFAT_FormatProperties (uint32_t drive, uint32_t type, uint32_t clus_size, uint32_t data_clus) {

     EventRecord4 (EvtFsFAT_FormatProperties, drive, type, clus_size, data_clus);

   }

 #else

   #define EvrFsFAT_FormatProperties(drive, type, clus_size, data_clus)

 #endif


 #ifdef EvtFsFAT_FileOpen

   __STATIC_INLINE void EvrFsFAT_FileOpen (uint32_t h, const char *path, uint32_t openmode) {

     EventRecord4 (EvtFsFAT_FileOpen, h, (uint32_t)path, openmode, 0);

   }

 #else

   #define EvrFsFAT_FileOpen(h, path, openmode)

 #endif


 #ifdef EvtFsFAT_PathInvalidChar

   __STATIC_INLINE void EvrFsFAT_PathInvalidChar (const char ch) {

     EventRecord2 (EvtFsFAT_PathInvalidChar, ch, 0);

   }

 #else

   #define EvrFsFAT_PathInvalidChar(ch)

 #endif


 #ifdef EvtFsFAT_PathIsTooLong

   __STATIC_INLINE void EvrFsFAT_PathIsTooLong (uint32_t max_len) {

     EventRecord2 (EvtFsFAT_PathIsTooLong, max_len, 0);

   }

 #else

   #define EvrFsFAT_PathIsTooLong(max_len)

 #endif


 #ifdef EvtFsFAT_PathIsDirNotFile

   __STATIC_INLINE void EvrFsFAT_PathIsDirNotFile (uint32_t drive) {

     EventRecord2 (EvtFsFAT_PathIsDirNotFile, drive, 0);

   }

 #else

   #define EvrFsFAT_PathIsDirNotFile(drive)

 #endif


 #ifdef EvtFsFAT_FileIsInUse

   __STATIC_INLINE void EvrFsFAT_FileIsInUse (uint32_t drive) {

     EventRecord2 (EvtFsFAT_FileIsInUse, drive, 0);

   }

 #else

   #define EvrFsFAT_FileIsInUse(drive)

 #endif


 #ifdef EvtFsFAT_FileIsReadOnly

   __STATIC_INLINE void EvrFsFAT_FileIsReadOnly (uint32_t drive) {

     EventRecord2 (EvtFsFAT_FileIsReadOnly, drive, 0);

   }

 #else

   #define EvrFsFAT_FileIsReadOnly(drive)

 #endif


 #ifdef EvtFsFAT_FileIsNonExistent

   __STATIC_INLINE void EvrFsFAT_FileIsNonExistent (uint32_t drive) {

     EventRecord2 (EvtFsFAT_FileIsNonExistent, drive, 0);

   }

 #else

   #define EvrFsFAT_FileIsNonExistent(drive)

 #endif


 #ifdef EvtFsFAT_PathProcessing

   __STATIC_INLINE void EvrFsFAT_PathProcessing (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_PathProcessing, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_PathProcessing(drive, path)

 #endif


 #ifdef EvtFsFAT_FileHandleUnavailable

   __STATIC_INLINE void EvrFsFAT_FileHandleUnavailable (uint32_t drive) {

     EventRecord2 (EvtFsFAT_FileHandleUnavailable, drive, 0);

   }

 #else

   #define EvrFsFAT_FileHandleUnavailable(drive)

 #endif


 #ifdef EvtFsFAT_FileHandleInvalid

   __STATIC_INLINE void EvrFsFAT_FileHandleInvalid (uint32_t h) {

     EventRecord2 (EvtFsFAT_FileHandleInvalid, h, 0);

   }

 #else

   #define EvrFsFAT_FileHandleInvalid(h)

 #endif


 #ifdef EvtFsFAT_LabelInvalid

   __STATIC_INLINE void EvrFsFAT_LabelInvalid (uint32_t drive) {

     EventRecord2 (EvtFsFAT_LabelInvalid, drive, 0);

   }

 #else

   #define EvrFsFAT_LabelInvalid(drive)

 #endif


 #ifdef EvtFsFAT_LabelNotSet

   __STATIC_INLINE void EvrFsFAT_LabelNotSet (uint32_t drive) {

     EventRecord2 (EvtFsFAT_LabelNotSet, drive, 0);

   }

 #else

   #define EvrFsFAT_LabelNotSet(drive)

 #endif


 #ifdef EvtFsFAT_SectorReadFailed

   __STATIC_INLINE void EvrFsFAT_SectorReadFailed (uint32_t drive, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsFAT_SectorReadFailed, drive, sector, count, 0);

   }

 #else

   #define EvrFsFAT_SectorReadFailed(drive, sector, count)

 #endif


 #ifdef EvtFsFAT_SectorWriteFailed

   __STATIC_INLINE void EvrFsFAT_SectorWriteFailed (uint32_t drive, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsFAT_SectorWriteFailed, drive, sector, count, 0);

   }

 #else

   #define EvrFsFAT_SectorWriteFailed(drive, sector, count)

 #endif


 #ifdef EvtFsFAT_DiskFull

   __STATIC_INLINE void EvrFsFAT_DiskFull (uint32_t drive) {

     EventRecord2 (EvtFsFAT_DiskFull, drive, 0);

   }

 #else

   #define EvrFsFAT_DiskFull(drive)

 #endif


 #ifdef EvtFsFAT_DirEntryAllocFailed

   __STATIC_INLINE void EvrFsFAT_DirEntryAllocFailed (uint32_t drive, uint32_t dir_clus) {

     EventRecord2 (EvtFsFAT_DirEntryAllocFailed, drive, dir_clus);

   }

 #else

   #define EvrFsFAT_DirEntryAllocFailed(drive, dir_clus)

 #endif


 #ifdef EvtFsFAT_PathBufferToSmall

   __STATIC_INLINE void EvrFsFAT_PathBufferToSmall (uint32_t drive) {

     EventRecord2 (EvtFsFAT_PathBufferToSmall, drive, 0);

   }

 #else

   #define EvrFsFAT_PathBufferToSmall(drive)

 #endif


 #ifdef EvtFsFAT_InitJournal

   __STATIC_INLINE void EvrFsFAT_InitJournal (uint32_t drive) {

     EventRecord2 (EvtFsFAT_InitJournal, drive, 0);

   }

 #else

   #define EvrFsFAT_InitJournal(drive)

 #endif


 #ifdef EvtFsFAT_InitJournalSuccess

   __STATIC_INLINE void EvrFsFAT_InitJournalSuccess (uint32_t drive) {

     EventRecord2 (EvtFsFAT_InitJournalSuccess, drive, 0);

   }

 #else

   #define EvrFsFAT_InitJournalSuccess(drive)

 #endif


 #ifdef EvtFsFAT_InitJournalFATError

   __STATIC_INLINE void EvrFsFAT_InitJournalFATError (uint32_t drive) {

     EventRecord2 (EvtFsFAT_InitJournalFATError, drive, 0);

   }

 #else

   #define EvrFsFAT_InitJournalFATError(drive)

 #endif


 #ifdef EvtFsFAT_FileClose

   __STATIC_INLINE void EvrFsFAT_FileClose (uint32_t h) {

     EventRecord2 (EvtFsFAT_FileClose, h, 0);

   }

 #else

   #define EvrFsFAT_FileClose(h)

 #endif


 #ifdef EvtFsFAT_FileHandleError

   __STATIC_INLINE void EvrFsFAT_FileHandleError (int32_t h, uint32_t flags) {

     EventRecord2 (EvtFsFAT_FileHandleError, (uint32_t)h, flags);

   }

 #else

   #define EvrFsFAT_FileHandleError(h, flags)

 #endif


 #ifdef EvtFsFAT_FileRead

   __STATIC_INLINE void EvrFsFAT_FileRead (uint32_t h, uint8_t *buf, uint32_t len) {

     EventRecord4 (EvtFsFAT_FileRead, h, (uint32_t)buf, len, 0);

   }

 #else

   #define EvrFsFAT_FileRead(h, buf, len)

 #endif


 #ifdef EvtFsFAT_FileWrite

   __STATIC_INLINE void EvrFsFAT_FileWrite (uint32_t h, const uint8_t *buf, uint32_t len) {

     EventRecord4 (EvtFsFAT_FileWrite, h, (uint32_t)buf, len, 0);

   }

 #else

   #define EvrFsFAT_FileWrite(h, buf, len)

 #endif


 #ifdef EvtFsFAT_FileFlush

   __STATIC_INLINE void EvrFsFAT_FileFlush (uint32_t h) {

     EventRecord2 (EvtFsFAT_FileFlush, h, 0);

   }

 #else

   #define EvrFsFAT_FileFlush(h)

 #endif


 #ifdef EvtFsFAT_FileSeek

   __STATIC_INLINE void EvrFsFAT_FileSeek (uint32_t h, uint32_t pos) {

     EventRecord2 (EvtFsFAT_FileSeek, h, pos);

   }

 #else

   #define EvrFsFAT_FileSeek(h, pos)

 #endif


 #ifdef EvtFsFAT_FileSeekIncrease

   __STATIC_INLINE void EvrFsFAT_FileSeekIncrease (int32_t h, uint32_t csize, uint32_t nsize) {

     EventRecord4 (EvtFsFAT_FileSeekIncrease, (uint32_t)h, csize, nsize, 0);

   }

 #else

   #define EvrFsFAT_FileSeekIncrease(h, csize, nsize)

 #endif


 #ifdef EvtFsFAT_FileDelete

   __STATIC_INLINE void EvrFsFAT_FileDelete (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_FileDelete, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_FileDelete(drive, path)

 #endif


 #ifdef EvtFsFAT_FileDeleteSuccess

   __STATIC_INLINE void EvrFsFAT_FileDeleteSuccess (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_FileDeleteSuccess, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_FileDeleteSuccess(drive, path)

 #endif


 #ifdef EvtFsFAT_FileRename

   __STATIC_INLINE void EvrFsFAT_FileRename (uint32_t drive, const char *path, const char *newname) {

     EventRecord4 (EvtFsFAT_FileRename, drive, (uint32_t)path, (uint32_t)newname, 0);

   }

 #else

   #define EvrFsFAT_FileRename(drive, path, newname)

 #endif


 #ifdef EvtFsFAT_FileRenameSuccess

   __STATIC_INLINE void EvrFsFAT_FileRenameSuccess (uint32_t drive, const char *path, const char *newname) {

     EventRecord4 (EvtFsFAT_FileRenameSuccess, drive, (uint32_t)path, (uint32_t)newname, 0);

   }

 #else

   #define EvrFsFAT_FileRenameSuccess(drive, path, newname)

 #endif


 #ifdef EvtFsFAT_DirCreate

   __STATIC_INLINE void EvrFsFAT_DirCreate (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_DirCreate, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_DirCreate(drive, path)

 #endif


 #ifdef EvtFsFAT_DirCreateSuccess

   __STATIC_INLINE void EvrFsFAT_DirCreateSuccess (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_DirCreateSuccess, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_DirCreateSuccess(drive, path)

 #endif


 #ifdef EvtFsFAT_DirRemove

   __STATIC_INLINE void EvrFsFAT_DirRemove (uint32_t drive, const char *path, const char *options) {

     EventRecord4 (EvtFsFAT_DirRemove, drive, (uint32_t)path, (uint32_t)options, 0);

   }

 #else

   #define EvrFsFAT_DirRemove(drive, path, options)

 #endif


 #ifdef EvtFsFAT_DirRemoveSuccess

   __STATIC_INLINE void EvrFsFAT_DirRemoveSuccess (uint32_t drive, const char *path, const char *options) {

     EventRecord4 (EvtFsFAT_DirRemoveSuccess, drive, (uint32_t)path, (uint32_t)options, 0);

   }

 #else

   #define EvrFsFAT_DirRemoveSuccess(drive, path, options)

 #endif


 #ifdef EvtFsFAT_ChDir

   __STATIC_INLINE void EvrFsFAT_ChDir (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_ChDir, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_ChDir(drive, path)

 #endif


 #ifdef EvtFsFAT_ChDirSuccess

   __STATIC_INLINE void EvrFsFAT_ChDirSuccess (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_ChDirSuccess, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_ChDirSuccess(drive, path)

 #endif


 #ifdef EvtFsFAT_Pwd

   __STATIC_INLINE void EvrFsFAT_Pwd (uint32_t drive, const char *path, uint32_t len) {

     EventRecord4 (EvtFsFAT_Pwd, drive, (uint32_t)path, len, 0);

   }

 #else

   #define EvrFsFAT_Pwd(drive, path, len)

 #endif


 #ifdef EvtFsFAT_PwdSuccess

   __STATIC_INLINE void EvrFsFAT_PwdSuccess (uint32_t drive, const char *path, uint32_t len) {

     EventRecord4 (EvtFsFAT_PwdSuccess, drive, (uint32_t)path, len, 0);

   }

 #else

   #define EvrFsFAT_PwdSuccess(drive, path, len)

 #endif


 #ifdef EvtFsFAT_AttribSet

   __STATIC_INLINE void EvrFsFAT_AttribSet (uint32_t drive, const char *path, uint32_t attrib) {

     EventRecord4 (EvtFsFAT_AttribSet, drive, (uint32_t)path, attrib, 0);

   }

 #else

   #define EvrFsFAT_AttribSet(drive, path, len)

 #endif


 #ifdef EvtFsFAT_AttribSetSuccess

   __STATIC_INLINE void EvrFsFAT_AttribSetSuccess (uint32_t drive, const char *path, uint32_t attrib) {

     EventRecord4 (EvtFsFAT_AttribSetSuccess, drive, (uint32_t)path, attrib, 0);

   }

 #else

   #define EvrFsFAT_AttribSetSuccess(drive, path, len)

 #endif


 #ifdef EvtFsFAT_GetFreeSpace

   __STATIC_INLINE void EvrFsFAT_GetFreeSpace (uint32_t drive) {

     EventRecord2 (EvtFsFAT_GetFreeSpace, drive, 0);

   }

 #else

   #define EvrFsFAT_GetFreeSpace(drive)

 #endif


 #ifdef EvtFsFAT_FreeAmount

   __STATIC_INLINE void EvrFsFAT_FreeAmount (uint32_t drive, uint32_t clus, uint32_t size) {

     EventRecord4 (EvtFsFAT_FreeAmount, drive, clus, size, drive);

   }

 #else

   #define EvrFsFAT_FreeAmount(clus, size, drive)

 #endif


 #ifdef EvtFsFAT_FileModeRead

   __STATIC_INLINE void EvrFsFAT_FileModeRead (int32_t h) {

     EventRecord2 (EvtFsFAT_FileModeRead, (uint32_t)h, 0);

   }

 #else

   #define EvrFsFAT_FileModeRead(h)

 #endif


 #ifdef EvtFsFAT_FileFind

   __STATIC_INLINE void EvrFsFAT_FileFind (int32_t h) {

     EventRecord2 (EvtFsFAT_FileFind, (uint32_t)h, 0);

   }

 #else

   #define EvrFsFAT_FileFind(h)

 #endif


 #ifdef EvtFsFAT_InvalidParameter

   __STATIC_INLINE void EvrFsFAT_InvalidParameter (uint32_t drive) {

     EventRecord2 (EvtFsFAT_InvalidParameter, drive, 0);

   }

 #else

   #define EvrFsFAT_InvalidParameter(drive)

 #endif


 #ifdef EvtFsFAT_DriverNotInitialized

   __STATIC_INLINE void EvrFsFAT_DriverNotInitialized (uint32_t drive) {

     EventRecord2 (EvtFsFAT_DriverNotInitialized, drive, 0);

   }

 #else

   #define EvrFsFAT_DriverNotInitialized(drive)

 #endif


 #ifdef EvtFsFAT_PathName

   __STATIC_INLINE void EvrFsFAT_PathName (const char *buf, uint32_t len) {

     EventRecordData (EvtFsFAT_PathName, (const uint8_t *)buf, len);

   }

 #else

   #define EvrFsFAT_PathName(buf, len)

 #endif


 #ifdef EvtFsFAT_OptionsString

   __STATIC_INLINE void EvrFsFAT_OptionsString (const char *buf, uint32_t len) {

     EventRecordData (EvtFsFAT_OptionsString, (const uint8_t *)buf, len);

   }

 #else

   #define EvrFsFAT_OptionsString(buf, len)

 #endif


 #ifdef EvtFsFAT_LabelString

   __STATIC_INLINE void EvrFsFAT_LabelString (const char *buf, uint32_t len) {

     EventRecordData (EvtFsFAT_LabelString, (const uint8_t *)buf, len);

   }

 #else

   #define EvrFsFAT_LabelString(buf, len)

 #endif


 #ifdef EvtFsFAT_NameCacheHit

   __STATIC_INLINE void EvrFsFAT_NameCacheHit (uint32_t drive, const char *name, uint32_t len) {

     EventRecord4 (EvtFsFAT_NameCacheHit, drive, (uint32_t)name, len, 0);

   }

 #else

   #define EvrFsFAT_NameCacheHit(drive, name, len)

 #endif


 #ifdef EvtFsFAT_NameCacheMiss

   __STATIC_INLINE void EvrFsFAT_NameCacheMiss (uint32_t drive, const char *name, uint32_t len) {

     EventRecord4 (EvtFsFAT_NameCacheMiss, drive, (uint32_t)name, len, 0);

   }

 #else

   #define EvrFsFAT_NameCacheMiss(drive, name, len)

 #endif


 #ifdef EvtFsFAT_NameCacheEntryFound

   __STATIC_INLINE void EvrFsFAT_NameCacheEntryFound (uint32_t drive, uint32_t clus, uint32_t offs, uint32_t cnt) {

     EventRecord4 (EvtFsFAT_NameCacheEntryFound, drive, clus, offs, cnt);

   }

 #else

   #define EvrFsFAT_NameCacheEntryFound(drive, clus, offs, cnt)

 #endif


 #ifdef EvtFsFAT_NameCacheEntryInsert

   __STATIC_INLINE void EvrFsFAT_NameCacheEntryInsert (uint32_t drive, uint32_t clus, uint32_t offs, uint32_t cnt) {

     EventRecord4 (EvtFsFAT_NameCacheEntryInsert, drive, clus, offs, cnt);

   }

 #else

   #define EvrFsFAT_NameCacheEntryInsert(drive, clus, offs, cnt)

 #endif


 #ifdef EvtFsFAT_NameCacheEntryDelete

   __STATIC_INLINE void EvrFsFAT_NameCacheEntryDelete (uint32_t drive, uint32_t clus, uint32_t offs, uint32_t cnt) {

     EventRecord4 (EvtFsFAT_NameCacheEntryDelete, drive, clus, offs, cnt);

   }

 #else

   #define EvrFsFAT_NameCacheEntryDelete(drive, clus, offs, cnt);

 #endif


 #ifdef EvtFsFAT_TimeSet

   __STATIC_INLINE void EvrFsFAT_TimeSet (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_TimeSet, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_TimeSet(drive, path);

 #endif


 #ifdef EvtFsFAT_TimeGet

   __STATIC_INLINE void EvrFsFAT_TimeGet (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsFAT_TimeGet, drive, (uint32_t)path);

   }

 #else

   #define EvrFsFAT_TimeGet(drive, path);

 #endif


 #ifdef EvtFsFAT_TimeData

   __STATIC_INLINE void EvrFsFAT_TimeData (fsTime *create, fsTime *access, fsTime *write) {

     int32_t v1, v2, v3;

     fsTime  *t;


     if (create != NULL) {

       t  = create;

       v1 = 0;

       v2 = (t->sec  << 16) | (t->min << 8) | (t->hr);

       v3 = (t->year << 16) | (t->mon << 8) | (t->day);

       EventRecord4 (EvtFsFAT_TimeData, (uint32_t)v1, (uint32_t)v2, (uint32_t)v3, 0);

     }


     if (access != NULL) {

       t  = access;

       v1 = 1;

       v2 = (t->sec  << 16) | (t->min << 8) | (t->hr);

       v3 = (t->year << 16) | (t->mon << 8) | (t->day);

       EventRecord4 (EvtFsFAT_TimeData, (uint32_t)v1, (uint32_t)v2, (uint32_t)v3, 0);

     }


     if (write != NULL) {

       t  = write;

       v1 = 2;

       v2 = (t->sec  << 16) | (t->min << 8) | (t->hr);

       v3 = (t->year << 16) | (t->mon << 8) | (t->day);

       EventRecord4 (EvtFsFAT_TimeData, (uint32_t)v1, (uint32_t)v2, (uint32_t)v3, 0);

     }

   }

 #else

   #define EvrFsFAT_TimeData(create, access, write);

 #endif


 #ifdef EvtFsEFS_InitDrive

   __STATIC_INLINE void EvrFsEFS_InitDrive (uint32_t drive) {

     EventRecord2 (EvtFsEFS_InitDrive, drive, 0);

   }

 #else

   #define EvrFsEFS_InitDrive(drive)

 #endif


 #ifdef EvtFsEFS_InitDriver

   __STATIC_INLINE void EvrFsEFS_InitDriver (uint32_t drive, uint32_t driver) {

     EventRecord2 (EvtFsEFS_InitDriver, drive, driver);

   }

 #else

   #define EvrFsEFS_InitDriver(drive, driver)

 #endif


 #ifdef EvtFsEFS_InitDriverFailed

   __STATIC_INLINE void EvrFsEFS_InitDriverFailed (uint32_t drive, uint32_t driver) {

     EventRecord2 (EvtFsEFS_InitDriverFailed, drive, driver);

   }

 #else

   #define EvrFsEFS_InitDriverFailed(drive, driver)

 #endif


 #ifdef EvtFsEFS_UninitDrive

   __STATIC_INLINE void EvrFsEFS_UninitDrive (uint32_t drive) {

     EventRecord2 (EvtFsEFS_UninitDrive, drive, 0);

   }

 #else

   #define EvrFsEFS_UninitDrive(drive)

 #endif


 #ifdef EvtFsEFS_UninitDriver

   __STATIC_INLINE void EvrFsEFS_UninitDriver (uint32_t drive, uint32_t driver) {

     EventRecord2 (EvtFsEFS_UninitDrive, drive, driver);

   }

 #else

   #define EvrFsEFS_UninitDriver(drive, driver)

 #endif


 #ifdef EvtFsEFS_MountDrive

   __STATIC_INLINE void EvrFsEFS_MountDrive (uint32_t drive) {

     EventRecord2 (EvtFsEFS_MountDrive, drive, 0);

   }

 #else

   #define EvrFsEFS_MountDrive(drive)

 #endif


 #ifdef EvtFsEFS_MountDriveSuccess

   __STATIC_INLINE void EvrFsEFS_MountDriveSuccess (uint32_t drive) {

     EventRecord2 (EvtFsEFS_MountDriveSuccess, drive, 0);

   }

 #else

   #define EvrFsEFS_MountDriveSuccess(drive)

 #endif


 #ifdef EvtFsEFS_FlashGetInfo

   __STATIC_INLINE void EvrFsEFS_FlashGetInfo (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FlashGetInfo, drive, 0);

   }

 #else

   #define EvrFsEFS_FlashGetInfo(drive)

 #endif


 #ifdef EvtFsEFS_FlashProgUnitTooBig

   __STATIC_INLINE void EvrFsEFS_FlashProgUnitTooBig (uint32_t drive, uint32_t current, uint32_t required) {

     EventRecord4 (EvtFsEFS_FlashProgUnitTooBig, drive, current, required, 0);

   }

 #else

   #define EvrFsEFS_FlashProgUnitTooBig(drive, current, required)

 #endif


 #ifdef EvtFsEFS_FlashCapacity

   __STATIC_INLINE void EvrFsEFS_FlashCapacity (uint32_t drive, uint32_t capacity) {

     EventRecord2 (EvtFsEFS_FlashCapacity, drive, capacity);

   }

 #else

   #define EvrFsEFS_FlashCapacity(drive, capacity)

 #endif


 #ifdef EvtFsEFS_UnmountDrive

   __STATIC_INLINE void EvrFsEFS_UnmountDrive (uint32_t drive) {

     EventRecord2 (EvtFsEFS_UnmountDrive, drive, 0);

   }

 #else

   #define EvrFsEFS_UnmountDrive(drive)

 #endif


 #ifdef EvtFsEFS_UnmountDriveSuccess

   __STATIC_INLINE void EvrFsEFS_UnmountDriveSuccess (uint32_t drive) {

     EventRecord2 (EvtFsEFS_UnmountDriveSuccess, drive, 0);

   }

 #else

   #define EvrFsEFS_UnmountDriveSuccess(drive)

 #endif


 #ifdef EvtFsEFS_FormatDrive

   __STATIC_INLINE void EvrFsEFS_FormatDrive (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FormatDrive, drive, 0);

   }

 #else

   #define EvrFsEFS_FormatDrive(drive)

 #endif


 #ifdef EvtFsEFS_FormatDriveSuccess

   __STATIC_INLINE void EvrFsEFS_FormatDriveSuccess (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FormatDriveSuccess, drive, 0);

   }

 #else

   #define EvrFsEFS_FormatDriveSuccess(drive)

 #endif


 #ifdef EvtFsEFS_FlashEraseChip

   __STATIC_INLINE void EvrFsEFS_FlashEraseChip (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FlashEraseChip, drive, 0);

   }

 #else

   #define EvrFsEFS_FlashEraseChip(drive)

 #endif


 #ifdef EvtFsEFS_FlashEraseChipFailed

   __STATIC_INLINE void EvrFsEFS_FlashEraseChipFailed (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FlashEraseChipFailed, drive, 0);

   }

 #else

   #define EvrFsEFS_FlashEraseChipFailed(drive)

 #endif


 #ifdef EvtFsEFS_FlashEraseChipTimeout

   __STATIC_INLINE void EvrFsEFS_FlashEraseChipTimeout (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FlashEraseChipTimeout, drive, 0);

   }

 #else

   #define EvrFsEFS_FlashEraseChipTimeout(drive)

 #endif


 #ifdef EvtFsEFS_FlashEraseSectors

   __STATIC_INLINE void EvrFsEFS_FlashEraseSectors (uint32_t drive, uint32_t sector, uint32_t cnt) {

     EventRecord4 (EvtFsEFS_FlashEraseSectors, drive, sector, cnt, 0);

   }

 #else

   #define EvrFsEFS_FlashEraseSectors(drive, sector, cnt)

 #endif


 #ifdef EvtFsEFS_FileOpen

   __STATIC_INLINE void EvrFsEFS_FileOpen (uint32_t h, const char *path, uint32_t openmode) {

     EventRecord4 (EvtFsEFS_FileOpen, h, (uint32_t)path, openmode, 0);

   }

 #else

   #define EvrFsEFS_FileOpen(h, path, openmode)

 #endif


 #ifdef EvtFsEFS_FileNameInvalid

   __STATIC_INLINE void EvrFsEFS_FileNameInvalid (const char *name, uint32_t len) {

     EventRecordData (EvtFsEFS_FileNameInvalid, (const uint8_t *)name, len);

   }

 #else

   #define EvrFsEFS_FileNameInvalid(name, len)

 #endif


 #ifdef EvtFsEFS_OpenModeUnsupported

   __STATIC_INLINE void EvrFsEFS_OpenModeUnsupported (uint32_t h, uint32_t openmode) {

     EventRecord2 (EvtFsEFS_OpenModeUnsupported, h, openmode);

   }

 #else

   #define EvrFsEFS_OpenModeUnsupported(h, openmode)

 #endif


 #ifdef EvtFsEFS_FileClose

   __STATIC_INLINE void EvrFsEFS_FileClose (uint32_t h) {

     EventRecord2 (EvtFsEFS_FileClose, h, 0);

   }

 #else

   #define EvrFsEFS_FileClose(h)

 #endif


 #ifdef EvtFsEFS_FileNotOpened

   __STATIC_INLINE void EvrFsEFS_FileNotOpened (uint32_t h, uint32_t flags) {

     EventRecord2 (EvtFsEFS_FileNotOpened, h, flags);

   }

 #else

   #define EvrFsEFS_FileNotOpened(h, flags)

 #endif


 #ifdef EvtFsEFS_FileRead

   __STATIC_INLINE void EvrFsEFS_FileRead (uint32_t h, uint8_t *buf, uint32_t len) {

     EventRecord4 (EvtFsEFS_FileRead, h, (uint32_t)buf, len, 0);

   }

 #else

   #define EvrFsEFS_FileRead(h, buf, len)

 #endif


 #ifdef EvtFsEFS_FileOpenWriteMode

   __STATIC_INLINE void EvrFsEFS_FileOpenWriteMode (uint32_t h) {

     EventRecord2 (EvtFsEFS_FileOpenWriteMode, h, 0);

   }

 #else

   #define EvrFsEFS_FileOpenWriteMode(h)

 #endif


 #ifdef EvtFsEFS_FileWrite

   __STATIC_INLINE void EvrFsEFS_FileWrite (uint32_t h, const uint8_t *buf, uint32_t len) {

     EventRecord4 (EvtFsEFS_FileWrite, h, (uint32_t)buf, len, 0);

   }

 #else

   #define EvrFsEFS_FileWrite(h, buf, len)

 #endif


 #ifdef EvtFsEFS_FileOpenReadMode

   __STATIC_INLINE void EvrFsEFS_FileOpenReadMode (uint32_t h) {

     EventRecord2 (EvtFsEFS_FileOpenReadMode, h, 0);

   }

 #else

   #define EvrFsEFS_FileOpenReadMode(h)

 #endif


 #ifdef EvtFsEFS_FileFlush

   __STATIC_INLINE void EvrFsEFS_FileFlush (uint32_t h) {

     EventRecord2 (EvtFsEFS_FileFlush, h, 0);

   }

 #else

   #define EvrFsEFS_FileFlush(h)

 #endif


 #ifdef EvtFsEFS_OpenModeInvalid

   __STATIC_INLINE void EvrFsEFS_OpenModeInvalid (uint32_t h, uint32_t flags) {

     EventRecord2 (EvtFsEFS_OpenModeInvalid, h, flags);

   }

 #else

   #define EvrFsEFS_OpenModeInvalid(h, flags)

 #endif


 #ifdef EvtFsEFS_FileSeek

   __STATIC_INLINE void EvrFsEFS_FileSeek (uint32_t h, uint32_t pos) {

     EventRecord2 (EvtFsEFS_FileSeek, h, pos);

   }

 #else

   #define EvrFsEFS_FileSeek(h, pos)

 #endif


 #ifdef EvtFsEFS_FileSeekEOF

   __STATIC_INLINE void EvrFsEFS_FileSeekEOF (uint32_t h, uint32_t size, uint32_t pos) {

     EventRecord4 (EvtFsEFS_FileSeekEOF, h, size, pos, 0);

   }

 #else

   #define EvrFsEFS_FileSeekEOF(h, size, pos)

 #endif


 #ifdef EvtFsEFS_FileDelete

   __STATIC_INLINE void EvrFsEFS_FileDelete (uint32_t drive, const char *path) {

     EventRecord2 (EvtFsEFS_FileDelete, drive, (uint32_t)path);

   }

 #else

   #define EvrFsEFS_FileDelete(drive, path)

 #endif


 #ifdef EvtFsEFS_FileRename

   __STATIC_INLINE void EvrFsEFS_FileRename (uint32_t drive, const char *path, const char *newname) {

     EventRecord4 (EvtFsEFS_FileRename, drive, (uint32_t)path, (uint32_t)newname, 0);

   }

 #else

   #define EvrFsEFS_FileRename(drive, path, newname)

 #endif


 #ifdef EvtFsEFS_FileNotFound

   __STATIC_INLINE void EvrFsEFS_FileNotFound (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FileNotFound, drive, 0);

   }

 #else

   #define EvrFsEFS_FileNotFound(drive)

 #endif


 #ifdef EvtFsEFS_FileAlreadyExists

   __STATIC_INLINE void EvrFsEFS_FileAlreadyExists (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FileAlreadyExists, drive, 0);

   }

 #else

   #define EvrFsEFS_FileAlreadyExists(drive)

 #endif


 #ifdef EvtFsEFS_FreeSpaceRetrieve

   __STATIC_INLINE void EvrFsEFS_FreeSpaceRetrieve (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FreeSpaceRetrieve, drive, 0);

   }

 #else

   #define EvrFsEFS_FreeSpaceRetrieve(drive)

 #endif


 #ifdef EvtFsEFS_FreeSpaceAmount

   __STATIC_INLINE void EvrFsEFS_FreeSpaceAmount (uint32_t drive, uint32_t free) {

     EventRecord2 (EvtFsEFS_FreeSpaceAmount, drive, free);

   }

 #else

   #define EvrFsEFS_FreeSpaceAmount(drive, free)

 #endif


 #ifdef EvtFsEFS_DriveAnalyze

   __STATIC_INLINE void EvrFsEFS_DriveAnalyze (uint32_t drive) {

     EventRecord2 (EvtFsEFS_DriveAnalyze, drive, 0);

   }

 #else

   #define EvrFsEFS_DriveAnalyze(drive)

 #endif


 #ifdef EvtFsEFS_DriveAnalyzeSuccess

   __STATIC_INLINE void EvrFsEFS_DriveAnalyzeSuccess (uint32_t drive, uint32_t factor) {

     EventRecord2 (EvtFsEFS_DriveAnalyzeSuccess, drive, factor);

   }

 #else

   #define EvrFsEFS_DriveAnalyzeSuccess(drive, factor)

 #endif


 #ifdef EvtFsEFS_DriveCheck

   __STATIC_INLINE void EvrFsEFS_DriveCheck (uint32_t drive) {

     EventRecord2 (EvtFsEFS_DriveCheck, drive, 0);

   }

 #else

   #define EvrFsEFS_DriveCheck(drive)

 #endif


 #ifdef EvtFsEFS_DriveCheckSuccess

   __STATIC_INLINE void EvrFsEFS_DriveCheckSuccess (uint32_t drive) {

     EventRecord2 (EvtFsEFS_DriveCheckSuccess, drive, 0);

   }

 #else

   #define EvrFsEFS_DriveCheckSuccess(drive)

 #endif


 #ifdef EvtFsEFS_DataAreaOverlap

   __STATIC_INLINE void EvrFsEFS_DataAreaOverlap (uint32_t drive) {

     EventRecord2 (EvtFsEFS_DataAreaOverlap, drive, 0);

   }

 #else

   #define EvrFsEFS_DataAreaOverlap(drive)

 #endif


 #ifdef EvtFsEFS_FileIdInvalid

   __STATIC_INLINE void EvrFsEFS_FileIdInvalid (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FileIdInvalid, drive, 0);

   }

 #else

   #define EvrFsEFS_FileIdInvalid(drive)

 #endif


 #ifdef EvtFsEFS_AllocationOrderInvalid

   __STATIC_INLINE void EvrFsEFS_AllocationOrderInvalid (uint32_t drive) {

     EventRecord2 (EvtFsEFS_AllocationOrderInvalid, drive, 0);

   }

 #else

   #define EvrFsEFS_AllocationOrderInvalid(drive)

 #endif


 #ifdef EvtFsEFS_AllocationAreaOverlap

   __STATIC_INLINE void EvrFsEFS_AllocationAreaOverlap (uint32_t drive) {

     EventRecord2 (EvtFsEFS_AllocationAreaOverlap, drive, 0);

   }

 #else

   #define EvrFsEFS_AllocationAreaOverlap(drive)

 #endif


 #ifdef EvtFsEFS_DriveDefrag

   __STATIC_INLINE void EvrFsEFS_DriveDefrag (uint32_t drive) {

     EventRecord2 (EvtFsEFS_DriveDefrag, drive, 0);

   }

 #else

   #define EvrFsEFS_DriveDefrag(drive)

 #endif


 #ifdef EvtFsEFS_FileHandleActive

   __STATIC_INLINE void EvrFsEFS_FileHandleActive (uint32_t drive, uint32_t h) {

     EventRecord2 (EvtFsEFS_FileHandleActive, drive, h);

   }

 #else

   #define EvrFsEFS_FileHandleActive(drive, h)

 #endif


 #ifdef EvtFsEFS_FileHandleUnavailable

   __STATIC_INLINE void EvrFsEFS_FileHandleUnavailable (uint32_t drive) {

     EventRecord2 (EvtFsEFS_FileHandleUnavailable, drive, 0);

   }

 #else

   #define EvrFsEFS_FileHandleUnavailable(drive)

 #endif


 #ifdef EvtFsEFS_FileHandleInvalid

   __STATIC_INLINE void EvrFsEFS_FileHandleInvalid (uint32_t h) {

     EventRecord2 (EvtFsEFS_FileHandleInvalid, h, 0);

   }

 #else

   #define EvrFsEFS_FileHandleInvalid(h)

 #endif


 #ifdef EvtFsEFS_FileInUse

   __STATIC_INLINE void EvrFsEFS_FileInUse (uint32_t h) {

     EventRecord2 (EvtFsEFS_FileInUse, h, 0);

   }

 #else

   #define EvrFsEFS_FileInUse(h)

 #endif


 #ifdef EvtFsEFS_DiskFull

   __STATIC_INLINE void EvrFsEFS_DiskFull (uint32_t drive) {

     EventRecord2 (EvtFsEFS_DiskFull, drive, 0);

   }

 #else

   #define EvrFsEFS_DiskFull(drive)

 #endif


 #ifdef EvtFsEFS_FlashWriteFailed

   __STATIC_INLINE void EvrFsEFS_FlashWriteFailed (uint32_t drive, uint32_t addr, void *buf, uint32_t cnt) {

     EventRecord4 (EvtFsEFS_FlashWriteFailed, drive, addr, (uint32_t)buf, cnt);

   }

 #else

   #define EvrFsEFS_FlashWriteFailed(drive, addr, buf, cnt)

 #endif


 #ifdef EvtFsEFS_FlashReadFailed

   __STATIC_INLINE void EvrFsEFS_FlashReadFailed (uint32_t drive, uint32_t addr, void *buf, uint32_t cnt) {

     EventRecord4 (EvtFsEFS_FlashReadFailed, drive, addr, (uint32_t)buf, cnt);

   }

 #else

   #define EvrFsEFS_FlashReadFailed(drive, addr, buf, cnt)

 #endif


 #ifdef EvtFsEFS_FlashReadTimeout

   __STATIC_INLINE void EvrFsEFS_FlashReadTimeout (uint32_t drive, uint32_t addr, void *buf, uint32_t cnt) {

     EventRecord4 (EvtFsEFS_FlashReadTimeout, drive, addr, (uint32_t)buf, cnt);

   }

 #else

   #define EvrFsEFS_FlashReadTimeout(drive, addr, buf, cnt)

 #endif


 #ifdef EvtFsEFS_FlashEraseFailed

   __STATIC_INLINE void EvrFsEFS_FlashEraseFailed (uint32_t drive, uint32_t block, uint32_t addr) {

     EventRecord4 (EvtFsEFS_FlashEraseFailed, drive, block, addr, 0);

   }

 #else

   #define EvrFsEFS_FlashEraseFailed(drive, block, addr)

 #endif


 #ifdef EvtFsEFS_InvalidParameter

   __STATIC_INLINE void EvrFsEFS_InvalidParameter (uint32_t drive) {

     EventRecord2 (EvtFsEFS_InvalidParameter, drive, 0);

   }

 #else

   #define EvrFsEFS_InvalidParameter(drive)

 #endif


 #ifdef EvtFsEFS_DriveNotMounted

   __STATIC_INLINE void EvrFsEFS_DriveNotMounted (uint32_t drive) {

     EventRecord2 (EvtFsEFS_DriveNotMounted, drive, 0);

   }

 #else

   #define EvrFsEFS_DriveNotMounted(drive)

 #endif


 #ifdef EvtFsEFS_DriveNotInitialized

   __STATIC_INLINE void EvrFsEFS_DriveNotInitialized (uint32_t drive) {

     EventRecord2 (EvtFsEFS_DriveNotInitialized, drive, 0);

   }

 #else

   #define EvrFsEFS_DriveNotInitialized(drive)

 #endif


 #ifdef EvtFsEFS_FileName

   __STATIC_INLINE void EvrFsEFS_FileName (const char *buf, uint32_t len) {

     EventRecordData (EvtFsEFS_FileName, (const uint8_t *)buf, len);

   }

 #else

   #define EvrFsEFS_FileName(buf, len)

 #endif


 #ifdef EvtFsEFS_FileAllocWrite

   __STATIC_INLINE void EvrFsEFS_FileAllocWrite (uint32_t addr, uint32_t end, uint32_t fileID, uint32_t index) {

     EventRecord4 (EvtFsEFS_FileAllocWrite, addr, end, fileID, index);

   }

 #else

   #define EvrFsEFS_FileAllocWrite(addr, end, fileID, index)

 #endif


 #ifdef EvtFsEFS_FileAllocRead

   __STATIC_INLINE void EvrFsEFS_FileAllocRead (uint32_t addr, uint32_t end, uint32_t fileID, uint32_t index) {

     EventRecord4 (EvtFsEFS_FileAllocRead, addr, end, fileID, index);

   }

 #else

   #define EvrFsEFS_FileAllocRead(addr, end, fileID, index)

 #endif


 #ifdef EvtFsIOC_GetId

   __STATIC_INLINE void EvrFsIOC_GetId (uint32_t drive) {

     EventRecord2 (EvtFsIOC_GetId, drive, 0);

   }

 #else

   #define EvrFsIOC_GetId(drive)

 #endif


 #ifdef EvtFsIOC_GetIdSuccess

   __STATIC_INLINE void EvrFsIOC_GetIdSuccess (uint32_t drive, uint32_t drv_id) {

     EventRecord2 (EvtFsIOC_GetIdSuccess, drive, drv_id);

   }

 #else

   #define EvrFsIOC_GetIdSuccess(drive, drv_id)

 #endif


 #ifdef EvtFsIOC_GetIdError

   __STATIC_INLINE void EvrFsIOC_GetIdError (uint32_t drive) {

     EventRecord2 (EvtFsIOC_GetIdError, drive, 0);

   }

 #else

   #define EvrFsIOC_GetIdError(drive)

 #endif


 #ifdef EvtFsIOC_Lock

   __STATIC_INLINE void EvrFsIOC_Lock (uint32_t drv_id) {

     EventRecord2 (EvtFsIOC_Lock, drv_id, 0);

   }

 #else

   #define EvrFsIOC_Lock(drv_id)

 #endif


 #ifdef EvtFsIOC_LockSuccess

   __STATIC_INLINE void EvrFsIOC_LockSuccess (uint32_t drv_id) {

     EventRecord2 (EvtFsIOC_LockSuccess, drv_id, 0);

   }

 #else

   #define EvrFsIOC_LockSuccess(drv_id)

 #endif


 #ifdef EvtFsIOC_Unlock

   __STATIC_INLINE void EvrFsIOC_Unlock (uint32_t drv_id) {

     EventRecord2 (EvtFsIOC_Unlock, drv_id, 0);

   }

 #else

   #define EvrFsIOC_Unlock(drv_id)

 #endif


 #ifdef EvtFsIOC_UnlockSuccess

   __STATIC_INLINE void EvrFsIOC_UnlockSuccess (uint32_t drv_id) {

     EventRecord2 (EvtFsIOC_UnlockSuccess, drv_id, 0);

   }

 #else

   #define EvrFsIOC_UnlockSuccess(drv_id)

 #endif


 #ifdef EvtFsIOC_GetCache

   __STATIC_INLINE void EvrFsIOC_GetCache (uint32_t drv_id, uint32_t cache_info) {

     EventRecord2 (EvtFsIOC_GetCache, drv_id, cache_info);

   }

 #else

   #define EvrFsIOC_GetCache(drv_id, cache_info)

 #endif


 #ifdef EvtFsIOC_GetCacheSuccess

   __STATIC_INLINE void EvrFsIOC_GetCacheSuccess (uint32_t drv_id, uint32_t buf, uint32_t size) {

     EventRecord4 (EvtFsIOC_GetCacheSuccess, drv_id, buf, size, 0);

   }

 #else

   #define EvrFsIOC_GetCacheSuccess(drv_id, buf, size)

 #endif


 #ifdef EvtFsIOC_ReadSector

   __STATIC_INLINE void EvrFsIOC_ReadSector (uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt) {

     EventRecord4 (EvtFsIOC_ReadSector, drv_id, sect, buf, cnt);

   }

 #else

   #define EvrFsIOC_ReadSector(drv_id, sect, buf, cnt)

 #endif


 #ifdef EvtFsIOC_ReadSectorSuccess

   __STATIC_INLINE void EvrFsIOC_ReadSectorSuccess (uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt) {

     EventRecord4 (EvtFsIOC_ReadSectorSuccess, drv_id, sect, buf, cnt);

   }

 #else

   #define EvrFsIOC_ReadSectorSuccess(drv_id, sect, buf, cnt)

 #endif


 #ifdef EvtFsIOC_ReadSectorError

   __STATIC_INLINE void EvrFsIOC_ReadSectorError (uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt) {

     EventRecord4 (EvtFsIOC_ReadSectorError, drv_id, sect, buf, cnt);

   }

 #else

   #define EvrFsIOC_ReadSectorError(drv_id, sect, buf, cnt)

 #endif


 #ifdef EvtFsIOC_WriteSector

   __STATIC_INLINE void EvrFsIOC_WriteSector (uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt) {

     EventRecord4 (EvtFsIOC_WriteSector, drv_id, sect, buf, cnt);

   }

 #else

   #define EvrFsIOC_WriteSector(drv_id, sect, buf, cnt)

 #endif


 #ifdef EvtFsIOC_WriteSectorSuccess

   __STATIC_INLINE void EvrFsIOC_WriteSectorSuccess (uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt) {

     EventRecord4 (EvtFsIOC_WriteSectorSuccess, drv_id, sect, buf, cnt);

   }

 #else

   #define EvrFsIOC_WriteSectorSuccess(drv_id, sect, buf, cnt)

 #endif


 #ifdef EvtFsIOC_WriteSectorError

   __STATIC_INLINE void EvrFsIOC_WriteSectorError (uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt) {

     EventRecord4 (EvtFsIOC_WriteSectorError, drv_id, sect, buf, cnt);

   }

 #else

   #define EvrFsIOC_WriteSectorError(drv_id, sect, buf, cnt)

 #endif


 #ifdef EvtFsIOC_ReadInfo

   __STATIC_INLINE void EvrFsIOC_ReadInfo (uint32_t drv_id, uint32_t info) {

     EventRecord2 (EvtFsIOC_ReadInfo, drv_id, info);

   }

 #else

   #define EvrFsIOC_ReadInfo(drv_id, info)

 #endif


 #ifdef EvtFsIOC_ReadInfoSuccess

   __STATIC_INLINE void EvrFsIOC_ReadInfoSuccess (uint32_t drv_id, uint32_t block_count) {

     EventRecord2 (EvtFsIOC_ReadInfoSuccess, drv_id, block_count);

   }

 #else

   #define EvrFsIOC_ReadInfoSuccess(drv_id, block_count)

 #endif


 #ifdef EvtFsIOC_ReadInfoError

   __STATIC_INLINE void EvrFsIOC_ReadInfoError (uint32_t drv_id) {

     EventRecord2 (EvtFsIOC_ReadInfoError, drv_id, 0);

   }

 #else

   #define EvrFsIOC_ReadInfoError(drv_id)

 #endif


 #ifdef EvtFsIOC_DeviceControl

   __STATIC_INLINE void EvrFsIOC_DeviceControl (uint32_t drv_id, uint32_t code, uint32_t p) {

     EventRecord4 (EvtFsIOC_DeviceControl, drv_id, code, p, 0);

   }

 #else

   #define EvrFsIOC_DeviceControl(drv_id, code, p)

 #endif


 #ifdef EvtFsIOC_DeviceControlSuccess

   __STATIC_INLINE void EvrFsIOC_DeviceControlSuccess (uint32_t drv_id, uint32_t code, uint32_t p) {

     EventRecord4 (EvtFsIOC_DeviceControlSuccess, drv_id, code, p, 0);

   }

 #else

   #define EvrFsIOC_DeviceControlSuccess(drv_id, code, p)

 #endif


 #ifdef EvtFsIOC_DriveIdInvalid

   __STATIC_INLINE void EvrFsIOC_DriveIdInvalid (uint32_t drv_id) {

     EventRecord2 (EvtFsIOC_DriveIdInvalid, drv_id, 0);

   }

 #else

   #define EvrFsIOC_DriveIdInvalid(drv_id)

 #endif


 #ifdef EvtFsIOC_DriveNotFAT

   __STATIC_INLINE void EvrFsIOC_DriveNotFAT (uint32_t drv_id) {

     EventRecord2 (EvtFsIOC_DriveNotFAT, drv_id, 0);

   }

 #else

   #define EvrFsIOC_DriveNotFAT(drv_id)

 #endif


 #ifdef EvtFsIOC_NotAllowed

   __STATIC_INLINE void EvrFsIOC_NotAllowed (uint32_t drive) {

     EventRecord2 (EvtFsIOC_NotAllowed, drive, 0);

   }

 #else

   #define EvrFsIOC_NotAllowed(drive)

 #endif


 #ifdef EvtFsNFTL_Init

   __STATIC_INLINE void EvrFsNFTL_Init (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_Init, instance, 0);

   }

 #else

   #define EvrFsNFTL_Init(instance)

 #endif


 #ifdef EvtFsNFTL_InitMediaFailed

   __STATIC_INLINE void EvrFsNFTL_InitMediaFailed (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_InitMediaFailed, instance, 0);

   }

 #else

   #define EvrFsNFTL_InitMediaFailed(instance)

 #endif


 #ifdef EvtFsNFTL_Mount

   __STATIC_INLINE void EvrFsNFTL_Mount (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_Mount, instance, 0);

   }

 #else

   #define EvrFsNFTL_Mount(instance)

 #endif


 #ifdef EvtFsNFTL_MountSuccess

   __STATIC_INLINE void EvrFsNFTL_MountSuccess (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_MountSuccess, instance, 0);

   }

 #else

   #define EvrFsNFTL_MountSuccess(instance)

 #endif


 #ifdef EvtFsNFTL_DeviceNotInitialized

   __STATIC_INLINE void EvrFsNFTL_DeviceNotInitialized (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_DeviceNotInitialized, instance, 0);

   }

 #else

   #define EvrFsNFTL_DeviceNotInitialized(instance)

 #endif


 #ifdef EvtFsNFTL_ResetDevice

   __STATIC_INLINE void EvrFsNFTL_ResetDevice (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ResetDevice, instance, 0);

   }

 #else

   #define EvrFsNFTL_ResetDevice(instance)

 #endif


 #ifdef EvtFsNFTL_ResetDeviceFailed

   __STATIC_INLINE void EvrFsNFTL_ResetDeviceFailed (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ResetDeviceFailed, instance, 0);

   }

 #else

   #define EvrFsNFTL_ResetDeviceFailed(instance)

 #endif


 #ifdef EvtFsNFTL_ResetDeviceTimeout

   __STATIC_INLINE void EvrFsNFTL_ResetDeviceTimeout (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ResetDeviceTimeout, instance, 0);

   }

 #else

   #define EvrFsNFTL_ResetDeviceTimeout(instance)

 #endif


 #ifdef EvtFsNFTL_ReadBootBlock

   __STATIC_INLINE void EvrFsNFTL_ReadBootBlock (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ReadBootBlock, instance, 0);

   }

 #else

   #define EvrFsNFTL_ReadBootBlock(instance)

 #endif


 #ifdef EvtFsNFTL_ReadBootBlockFailed

   __STATIC_INLINE void EvrFsNFTL_ReadBootBlockFailed (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ReadBootBlockFailed, instance, 0);

   }

 #else

   #define EvrFsNFTL_ReadBootBlockFailed(instance)

 #endif


 #ifdef EvtFsNFTL_BootSignatureValid

   __STATIC_INLINE void EvrFsNFTL_BootSignatureValid (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_BootSignatureValid, instance, 0);

   }

 #else

   #define EvrFsNFTL_BootSignatureValid(instance)

 #endif


 #ifdef EvtFsNFTL_BootSignatureInvalid

   __STATIC_INLINE void EvrFsNFTL_BootSignatureInvalid (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_BootSignatureInvalid, instance, 0);

   }

 #else

   #define EvrFsNFTL_BootSignatureInvalid(instance)

 #endif


 #ifdef EvtFsNFTL_DataBlockCapacity

   __STATIC_INLINE void EvrFsNFTL_DataBlockCapacity (uint32_t instance, uint32_t capacity) {

     EventRecord2 (EvtFsNFTL_DataBlockCapacity, instance, capacity);

   }

 #else

   #define EvrFsNFTL_DataBlockCapacity(instance, capacity)

 #endif


 #ifdef EvtFsNFTL_ReadTable

   __STATIC_INLINE void EvrFsNFTL_ReadTable (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ReadTable, instance, 0);

   }

 #else

   #define EvrFsNFTL_ReadTable(instance)

 #endif


 #ifdef EvtFsNFTL_ReadTableFailed

   __STATIC_INLINE void EvrFsNFTL_ReadTableFailed (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ReadTableFailed, instance, 0);

   }

 #else

   #define EvrFsNFTL_ReadTableFailed(instance)

 #endif


 #ifdef EvtFsNFTL_Uninit

   __STATIC_INLINE void EvrFsNFTL_Uninit (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_Uninit, instance, 0);

   }

 #else

   #define EvrFsNFTL_Uninit(instance)

 #endif


 #ifdef EvtFsNFTL_UninitDriver

   __STATIC_INLINE void EvrFsNFTL_UninitDriver (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_UninitDriver, instance, 0);

   }

 #else

   #define EvrFsNFTL_UninitDriver(instance)

 #endif


 #ifdef EvtFsNFTL_UninitDriverFailed

   __STATIC_INLINE void EvrFsNFTL_UninitDriverFailed (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_UninitDriverFailed, instance, 0);

   }

 #else

   #define EvrFsNFTL_UninitDriverFailed(instance)

 #endif


 #ifdef EvtFsNFTL_ReadInfo

   __STATIC_INLINE void EvrFsNFTL_ReadInfo (uint32_t instance, uint32_t info) {

     EventRecord2 (EvtFsNFTL_ReadInfo, instance, info);

   }

 #else

   #define EvrFsNFTL_ReadInfo(instance, info)

 #endif


 #ifdef EvtFsNFTL_ReadInfoSuccess

   __STATIC_INLINE void EvrFsNFTL_ReadInfoSuccess (uint32_t instance, uint32_t sect_count) {

     EventRecord2 (EvtFsNFTL_ReadInfoSuccess, instance, sect_count);

   }

 #else

   #define EvrFsNFTL_ReadInfoSuccess(instance, sect_count)

 #endif


 #ifdef EvtFsNFTL_DevCtrl

   __STATIC_INLINE void EvrFsNFTL_DevCtrl (uint32_t instance, uint32_t code, void *p) {

     EventRecord4 (EvtFsNFTL_DevCtrl, instance, code, (uint32_t)p, 0);

   }

 #else

   #define EvrFsNFTL_DevCtrl(instance, code, p)

 #endif


 #ifdef EvtFsNFTL_DevCtrlUnsupported

   __STATIC_INLINE void EvrFsNFTL_DevCtrlUnsupported (uint32_t instance, uint32_t code) {

     EventRecord2 (EvtFsNFTL_DevCtrlUnsupported, instance, code);

   }

 #else

   #define EvrFsNFTL_DevCtrlUnsupported(instance, code)

 #endif


 #ifdef EvtFsNFTL_Format

   __STATIC_INLINE void EvrFsNFTL_Format (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_Format, instance, 0);

   }

 #else

   #define EvrFsNFTL_Format(instance)

 #endif


 #ifdef EvtFsNFTL_FormatSuccess

   __STATIC_INLINE void EvrFsNFTL_FormatSuccess (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_FormatSuccess, instance, 0);

   }

 #else

   #define EvrFsNFTL_FormatSuccess(instance)

 #endif


 #ifdef EvtFsNFTL_FormatLLEB

   __STATIC_INLINE void EvrFsNFTL_FormatLLEB (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_FormatLLEB, instance, 0);

   }

 #else

   #define EvrFsNFTL_FormatLLEB(instance)

 #endif


 #ifdef EvtFsNFTL_BBMPositionSet

   __STATIC_INLINE void EvrFsNFTL_BBMPositionSet (uint32_t instance, uint32_t pos) {

     EventRecord2 (EvtFsNFTL_BBMPositionSet, instance, pos);

   }

 #else

   #define EvrFsNFTL_BBMPositionSet(instance, pos)

 #endif


 #ifdef EvtFsNFTL_BadBlockDetected

   __STATIC_INLINE void EvrFsNFTL_BadBlockDetected (uint32_t instance, uint32_t block) {

     EventRecord2 (EvtFsNFTL_BadBlockDetected, instance, block);

   }

 #else

   #define EvrFsNFTL_BadBlockDetected(instance, block)

 #endif


 #ifdef EvtFsNFTL_BadBlockMark

   __STATIC_INLINE void EvrFsNFTL_BadBlockMark (uint32_t instance, uint32_t block) {

     EventRecord2 (EvtFsNFTL_BadBlockMark, instance, block);

   }

 #else

   #define EvrFsNFTL_BadBlockMark(instance, block)

 #endif


 #ifdef EvtFsNFTL_WriteSector

   __STATIC_INLINE void EvrFsNFTL_WriteSector (uint32_t instance, uint32_t sector, const uint8_t *buf, uint32_t cnt) {

     EventRecord4 (EvtFsNFTL_WriteSector, instance, sector, (uint32_t)buf, cnt);

   }

 #else

   #define EvrFsNFTL_WriteSector(instance, sector, buf, cnt)

 #endif


 #ifdef EvtFsNFTL_WriteSectorSuccess

   __STATIC_INLINE void EvrFsNFTL_WriteSectorSuccess (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_WriteSectorSuccess, instance, 0);

   }

 #else

   #define EvrFsNFTL_WriteSectorSuccess(instance)

 #endif


 #ifdef EvtFsNFTL_ReadSector

   __STATIC_INLINE void EvrFsNFTL_ReadSector (uint32_t instance, uint32_t sector, uint8_t *buf, uint32_t cnt) {

     EventRecord4 (EvtFsNFTL_ReadSector, instance, sector, (uint32_t)buf, cnt);

   }

 #else

   #define EvrFsNFTL_ReadSector(instance, sector, buf, cnt)

 #endif


 #ifdef EvtFsNFTL_ReadSectorSuccess

   __STATIC_INLINE void EvrFsNFTL_ReadSectorSuccess (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ReadSectorSuccess, instance, 0);

   }

 #else

   #define EvrFsNFTL_ReadSectorSuccess(instance)

 #endif


 #ifdef EvtFsNFTL_LsnToLbn

   __STATIC_INLINE void EvrFsNFTL_LsnToLbn (uint32_t instance, uint32_t lsn, uint32_t lbn) {

     EventRecord4 (EvtFsNFTL_LsnToLbn, instance, lsn, lbn, 0);

   }

 #else

   #define EvrFsNFTL_LsnToLbn(instance, lsn, lbn)

 #endif


 #ifdef EvtFsNFTL_LbnToPbn

   __STATIC_INLINE void EvrFsNFTL_LbnToPbn (uint32_t instance, uint32_t lbn, uint32_t pbn_0, uint32_t pbn_1) {

     EventRecord4 (EvtFsNFTL_LbnToPbn, instance, lbn, pbn_0, pbn_1);

   }

 #else

   #define EvrFsNFTL_LbnToPbn(instance, lbn, pbn_0, pbn_1)

 #endif


 #ifdef EvtFsNFTL_LbnOutOfRange

   __STATIC_INLINE void EvrFsNFTL_LbnOutOfRange (uint32_t instance, uint32_t lbn, uint32_t max) {

     EventRecord4 (EvtFsNFTL_LbnOutOfRange, instance, lbn, max, 0);

   }

 #else

   #define EvrFsNFTL_LbnOutOfRange(instance, lbn, max)

 #endif


 #ifdef EvtFsNFTL_PbnOutOfRange

   __STATIC_INLINE void EvrFsNFTL_PbnOutOfRange (uint32_t instance, uint32_t pbn, uint32_t max) {

     EventRecord4 (EvtFsNFTL_PbnOutOfRange, instance, pbn, max, 0);

   }

 #else

   #define EvrFsNFTL_PbnOutOfRange(instance, pbn, max)

 #endif


 #ifdef EvtFsNFTL_TableLookup

   __STATIC_INLINE void EvrFsNFTL_TableLookup (uint32_t instance, uint32_t lbn) {

     EventRecord2 (EvtFsNFTL_TableLookup, instance, lbn);

   }

 #else

   #define EvrFsNFTL_TableLookup(instance, lbn)

 #endif


 #ifdef EvtFsNFTL_TableEntryNotFound

   __STATIC_INLINE void EvrFsNFTL_TableEntryNotFound (uint32_t instance, uint32_t lbn) {

     EventRecord2 (EvtFsNFTL_TableEntryNotFound, instance, lbn);

   }

 #else

   #define EvrFsNFTL_TableEntryNotFound(instance, lbn)

 #endif


 #ifdef EvtFsNFTL_AllocateBlock

   __STATIC_INLINE void EvrFsNFTL_AllocateBlock (uint32_t instance, uint32_t area) {

     EventRecord2 (EvtFsNFTL_AllocateBlock, instance, area);

   }

 #else

   #define EvrFsNFTL_AllocateBlock(instance, area)

 #endif


 #ifdef EvtFsNFTL_LsnFind

   __STATIC_INLINE void EvrFsNFTL_LsnFind (uint32_t instance, uint32_t lsn, uint32_t pbn) {

     EventRecord4 (EvtFsNFTL_LsnFind, instance, lsn, pbn, 0);

   }

 #else

   #define EvrFsNFTL_LsnFind(instance, lsn, pbn)

 #endif


 #ifdef EvtFsNFTL_LsnFound

   __STATIC_INLINE void EvrFsNFTL_LsnFound (uint32_t instance, uint32_t lsn, uint32_t pbn, uint32_t pg) {

     EventRecord4 (EvtFsNFTL_LsnFound, instance, lsn, pbn, pg);

   }

 #else

   #define EvrFsNFTL_LsnFound(instance, lsn, pbn, pg)

 #endif


 #ifdef EvtFsNFTL_LsnNotFound

   __STATIC_INLINE void EvrFsNFTL_LsnNotFound (uint32_t instance, uint32_t lsn, uint32_t pbn) {

     EventRecord4 (EvtFsNFTL_LsnNotFound, instance, lsn, pbn, 0);

   }

 #else

   #define EvrFsNFTL_LsnNotFound(instance, lsn, pbn)

 #endif


 #ifdef EvtFsNFTL_GarbageCollection

   __STATIC_INLINE void EvrFsNFTL_GarbageCollection (uint32_t instance, uint32_t src_0, uint32_t src_1, uint32_t dst) {

     EventRecord4 (EvtFsNFTL_GarbageCollection, instance, src_0, src_1, dst);

   }

 #else

   #define EvrFsNFTL_GarbageCollection(instance, src_0, src_1, dst)

 #endif


 #ifdef EvtFsNFTL_SetBadBlockMarker

   __STATIC_INLINE void EvrFsNFTL_SetBadBlockMarker (uint32_t instance, uint32_t pbn) {

     EventRecord2 (EvtFsNFTL_SetBadBlockMarker, instance, pbn);

   }

 #else

   #define EvrFsNFTL_SetBadBlockMarker(instance, pbn)

 #endif


 #ifdef EvtFsNFTL_MoveData

   __STATIC_INLINE void EvrFsNFTL_MoveData (uint32_t instance, uint32_t src, uint32_t dst) {

     EventRecord4 (EvtFsNFTL_MoveData, instance, src, dst, 0);

   }

 #else

   #define EvrFsNFTL_MoveData(instance, src, dst)

 #endif


 #ifdef EvtFsNFTL_RelocateBlock

   __STATIC_INLINE void EvrFsNFTL_RelocateBlock (uint32_t instance, uint32_t pbn) {

     EventRecord2 (EvtFsNFTL_RelocateBlock, instance, pbn);

   }

 #else

   #define EvrFsNFTL_RelocateBlock(instance, pbn)

 #endif


 #ifdef EvtFsNFTL_RelocateBlockFailed

   __STATIC_INLINE void EvrFsNFTL_RelocateBlockFailed (uint32_t instance, uint32_t pbn) {

     EventRecord2 (EvtFsNFTL_RelocateBlockFailed, instance, pbn);

   }

 #else

   #define EvrFsNFTL_RelocateBlockFailed(instance, pbn)

 #endif


 #ifdef EvtFsNFTL_SkipBadBlock

   __STATIC_INLINE void EvrFsNFTL_SkipBadBlock (uint32_t instance, uint32_t pbn) {

     EventRecord2 (EvtFsNFTL_SkipBadBlock, instance, pbn);

   }

 #else

   #define EvrFsNFTL_SkipBadBlock(instance, pbn)

 #endif


 #ifdef EvtFsNFTL_PageReadFailed

   __STATIC_INLINE void EvrFsNFTL_PageReadFailed (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNFTL_PageReadFailed, instance, row);

   }

 #else

   #define EvrFsNFTL_PageReadFailed(instance, row)

 #endif


 #ifdef EvtFsNFTL_PageProgramStatusErr

   __STATIC_INLINE void EvrFsNFTL_PageProgramStatusErr (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNFTL_PageProgramStatusErr, instance, row);

   }

 #else

   #define EvrFsNFTL_PageProgramStatusErr(instance, row)

 #endif


 #ifdef EvtFsNFTL_PageProgramFailed

   __STATIC_INLINE void EvrFsNFTL_PageProgramFailed (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNFTL_PageProgramFailed, instance, row);

   }

 #else

   #define EvrFsNFTL_PageProgramFailed(instance, row)

 #endif


 #ifdef EvtFsNFTL_PageProgramTimeout

   __STATIC_INLINE void EvrFsNFTL_PageProgramTimeout (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNFTL_PageProgramTimeout, instance, row);

   }

 #else

   #define EvrFsNFTL_PageProgramTimeout(instance, row)

 #endif


 #ifdef EvtFsNFTL_BlockEraseStatusErr

   __STATIC_INLINE void EvrFsNFTL_BlockEraseStatusErr (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNFTL_BlockEraseStatusErr, instance, row);

   }

 #else

   #define EvrFsNFTL_BlockEraseStatusErr(instance, row)

 #endif


 #ifdef EvtFsNFTL_BlockEraseFailed

   __STATIC_INLINE void EvrFsNFTL_BlockEraseFailed (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNFTL_BlockEraseFailed, instance, row);

   }

 #else

   #define EvrFsNFTL_BlockEraseFailed(instance, row)

 #endif


 #ifdef EvtFsNFTL_BlockEraseTimeout

   __STATIC_INLINE void EvrFsNFTL_BlockEraseTimeout (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNFTL_BlockEraseTimeout, instance, row);

   }

 #else

   #define EvrFsNFTL_BlockEraseTimeout(instance, row)

 #endif


 #ifdef EvtFsNFTL_BitErrorCorrected

   __STATIC_INLINE void EvrFsNFTL_BitErrorCorrected (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNFTL_BitErrorCorrected, instance, row);

   }

 #else

   #define EvrFsNFTL_BitErrorCorrected(instance, row)

 #endif


 #ifdef EvtFsNFTL_ParameterInvalid

   __STATIC_INLINE void EvrFsNFTL_ParameterInvalid (uint32_t instance) {

     EventRecord2 (EvtFsNFTL_ParameterInvalid, instance, 0);

   }

 #else

   #define EvrFsNFTL_ParameterInvalid(instance)

 #endif


 #ifdef EvtFsNFTL_TableUpdate

   __STATIC_INLINE void EvrFsNFTL_TableUpdate (uint32_t instance, uint32_t lbn, uint32_t pbn_0, uint32_t pbn_1) {

     EventRecord4 (EvtFsNFTL_TableUpdate, instance, lbn, pbn_0, pbn_1);

   }

 #else

   #define EvrFsNFTL_TableUpdate(instance, lbn, pbn_0, pbn_1)

 #endif


 #ifdef EvtFsNFTL_AllocatedBlock

   __STATIC_INLINE void EvrFsNFTL_AllocatedBlock (uint32_t instance, uint32_t pbn) {

     EventRecord2 (EvtFsNFTL_AllocatedBlock, instance, pbn);

   }

 #else

   #define EvrFsNFTL_AllocatedBlock(instance, pbn)

 #endif


 #ifdef EvtFsNFTL_LoadSector

   __STATIC_INLINE void EvrFsNFTL_LoadSector (uint32_t instance, uint32_t lsn, uint32_t offs, uint32_t spare) {

     EventRecord4 (EvtFsNFTL_LoadSector, instance, lsn, offs, spare);

   }

 #else

   #define EvrFsNFTL_LoadSector(instance, lsn, offs, spare)

 #endif


 #ifdef EvtFsNFTL_LoadTableLayout

   __STATIC_INLINE void EvrFsNFTL_LoadTableLayout (uint32_t instance, uint32_t pbn_0, uint32_t pbn_1) {

     EventRecord4 (EvtFsNFTL_LoadTableLayout, instance, pbn_0, pbn_1, 0);

   }

 #else

   #define EvrFsNFTL_LoadTableLayout(instance, pbn_0, pbn_1)

 #endif


 #ifdef EvtFsNFTL_LoadDataLayout

   __STATIC_INLINE void EvrFsNFTL_LoadDataLayout (uint32_t instance, uint32_t pbn_0, uint32_t pbn_1) {

     EventRecord4 (EvtFsNFTL_LoadDataLayout, instance, pbn_0, pbn_1, 0);

   }

 #else

   #define EvrFsNFTL_LoadDataLayout(instance, pbn_0, pbn_1)

 #endif


 #ifdef EvtFsNFTL_SetupPageLayout

   __STATIC_INLINE void EvrFsNFTL_SetupPageLayout (uint32_t instance, uint32_t sector_inc, uint32_t spare_ofs, uint32_t spare_inc) {

     EventRecord4 (EvtFsNFTL_SetupPageLayout, instance, sector_inc, spare_ofs, spare_inc);

   }

 #else

   #define EvrFsNFTL_SetupPageLayout(instance, sector_inc, spare_ofs, spare_inc);

 #endif


 #ifdef EvtFsNFTL_SetupSpareLayout

   __STATIC_INLINE void EvrFsNFTL_SetupSpareLayout (uint32_t instance, uint32_t ofs_lsn, uint32_t ofs_dcm, uint32_t ofs_bbm, uint32_t ofs_ecc) {

     EventRecord4 (EvtFsNFTL_SetupSpareLayout, instance, (ofs_dcm << 16) | ofs_lsn, ofs_bbm, ofs_ecc);

   }

 #else

   #define EvrFsNFTL_SetupSpareLayout(instance, ofs_lsn, ofs_dcm, ofs_bbm, ofs_ecc);

 #endif


 #ifdef EvtFsNFTL_PageWrite

   __STATIC_INLINE void EvrFsNFTL_PageWrite (uint32_t instance, uint32_t pbn, uint32_t pg) {

     EventRecord4 (EvtFsNFTL_PageWrite, instance, pbn, pg, 0);

   }

 #else

   #define EvrFsNFTL_PageWrite(instance, pbn, pg);

 #endif


 #ifdef EvtFsNFTL_PageRead

   __STATIC_INLINE void EvrFsNFTL_PageRead (uint32_t instance, uint32_t pbn, uint32_t pg) {

     EventRecord4 (EvtFsNFTL_PageRead, instance, pbn, pg, 0);

   }

 #else

   #define EvrFsNFTL_PageRead(instance, pbn, pg);

 #endif


 #ifdef EvtFsNFTL_BlockErase

   __STATIC_INLINE void EvrFsNFTL_BlockErase (uint32_t instance, uint32_t pbn) {

     EventRecord2 (EvtFsNFTL_BlockErase, instance, pbn);

   }

 #else

   #define EvrFsNFTL_BlockErase(instance, pbn);

 #endif


 #ifdef EvtFsNFTL_StatusRead

   __STATIC_INLINE void EvrFsNFTL_StatusRead (uint32_t instance, uint32_t status) {

     EventRecord2 (EvtFsNFTL_StatusRead, instance, status);

   }

 #else

   #define EvrFsNFTL_StatusRead(instance, status);

 #endif


 #ifdef EvtFsNFTL_CacheWrite

   __STATIC_INLINE void EvrFsNFTL_CacheWrite (uint32_t instance, uint32_t pbn, uint32_t pg) {

     EventRecord4 (EvtFsNFTL_CacheWrite, instance, pbn, pg, 0);

   }

 #else

   #define EvrFsNFTL_CacheWrite(instance, pbn, pg);

 #endif


 #ifdef EvtFsNFTL_CacheRead

   __STATIC_INLINE void EvrFsNFTL_CacheRead (uint32_t instance, uint32_t pbn, uint32_t pg, uint32_t col) {

     EventRecord4 (EvtFsNFTL_CacheRead, instance, pbn, pg, col);

   }

 #else

   #define EvrFsNFTL_CacheRead(instance, pbn, pg, col);

 #endif


 #ifdef EvtFsNAND_Init

   __STATIC_INLINE void EvrFsNAND_Init (uint32_t instance) {

     EventRecord2 (EvtFsNAND_Init, instance, 0);

   }

 #else

   #define EvrFsNAND_Init(instance)

 #endif


 #ifdef EvtFsNAND_InitDriver

   __STATIC_INLINE void EvrFsNAND_InitDriver (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsNAND_InitDriver, instance, driver);

   }

 #else

   #define EvrFsNAND_InitDriver(instance, driver)

 #endif


 #ifdef EvtFsNAND_InitDriverError

   __STATIC_INLINE void EvrFsNAND_InitDriverError (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsNAND_InitDriverError, instance, driver);

   }

 #else

   #define EvrFsNAND_InitDriverError(instance, driver)

 #endif


 #ifdef EvtFsNAND_DriverPowerCtrlError

   __STATIC_INLINE void EvrFsNAND_DriverPowerCtrlError (uint32_t instance, uint32_t driver, uint32_t state) {

     EventRecord4 (EvtFsNAND_DriverPowerCtrlError, instance, driver, state, 0);

   }

 #else

   #define EvrFsNAND_DriverPowerCtrlError(instance, driver, state)

 #endif


 #ifdef EvtFsNAND_DriverBusModeSelect

   __STATIC_INLINE void EvrFsNAND_DriverBusModeSelect (uint32_t instance, uint32_t driver, uint32_t mode) {

     EventRecord4 (EvtFsNAND_DriverBusModeSelect, instance, driver, mode, 0);

   }

 #else

   #define EvrFsNAND_DriverBusModeSelect(instance, driver, mode)

 #endif


 #ifdef EvtFsNAND_DriverBusWidthSelect

   __STATIC_INLINE void EvrFsNAND_DriverBusWidthSelect (uint32_t instance, uint32_t driver, uint32_t width) {

     EventRecord4 (EvtFsNAND_DriverBusWidthSelect, instance, driver, width, 0);

   }

 #else

   #define EvrFsNAND_DriverBusWidthSelect(instance, driver, width)

 #endif


 #ifdef EvtFsNAND_DriverBusWidthError

   __STATIC_INLINE void EvrFsNAND_DriverBusWidthError (uint32_t instance, uint32_t driver, uint32_t width) {

     EventRecord4 (EvtFsNAND_DriverBusWidthError, instance, driver, width, 0);

   }

 #else

   #define EvrFsNAND_DriverBusWidthError(instance, driver, width)

 #endif


 #ifdef EvtFsNAND_DriverDevPowerSelect

   __STATIC_INLINE void EvrFsNAND_DriverDevPowerSelect (uint32_t instance, uint32_t driver, uint32_t volt) {

     EventRecord4 (EvtFsNAND_DriverDevPowerSelect, instance, driver, volt, 0);

   }

 #else

   #define EvrFsNAND_DriverDevPowerSelect(instance, driver, volt)

 #endif


 #ifdef EvtFsNAND_DriverEccInquire

   __STATIC_INLINE void EvrFsNAND_DriverEccInquire (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsNAND_DriverEccInquire, instance, driver);

   }

 #else

   #define EvrFsNAND_DriverEccInquire(instance, driver)

 #endif


 #ifdef EvtFsNAND_DriverEccSelect

   __STATIC_INLINE void EvrFsNAND_DriverEccSelect (uint32_t instance, uint32_t driver, uint32_t index) {

     EventRecord4 (EvtFsNAND_DriverEccSelect, instance, driver, index, 0);

   }

 #else

   #define EvrFsNAND_DriverEccSelect(instance, driver, index)

 #endif


 #ifdef EvtFsNAND_DriverEccInquireError

   __STATIC_INLINE void EvrFsNAND_DriverEccInquireError (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsNAND_DriverEccInquireError, instance, driver);

   }

 #else

   #define EvrFsNAND_DriverEccInquireError(instance, driver)

 #endif


 #ifdef EvtFsNAND_DriverTimeoutError

   __STATIC_INLINE void EvrFsNAND_DriverTimeoutError (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsNAND_DriverTimeoutError, instance, driver);

   }

 #else

   #define EvrFsNAND_DriverTimeoutError(instance, driver)

 #endif


 #ifdef EvtFsNAND_DeviceTimeoutError

   __STATIC_INLINE void EvrFsNAND_DeviceTimeoutError (uint32_t instance, uint32_t driver, uint32_t device) {

     EventRecord4 (EvtFsNAND_DeviceTimeoutError, instance, driver, device, 0);

   }

 #else

   #define EvrFsNAND_DeviceTimeoutError(instance, driver, device)

 #endif


 #ifdef EvtFsNAND_Uninit

   __STATIC_INLINE void EvrFsNAND_Uninit (uint32_t instance) {

     EventRecord2 (EvtFsNAND_Uninit, instance, 0);

   }

 #else

   #define EvrFsNAND_Uninit(instance)

 #endif


 #ifdef EvtFsNAND_StatusRead

   __STATIC_INLINE void EvrFsNAND_StatusRead (uint32_t instance, uint32_t status) {

     EventRecord2 (EvtFsNAND_StatusRead, instance, status);

   }

 #else

   #define EvrFsNAND_StatusRead(instance, status)

 #endif


 #ifdef EvtFsNAND_BlockErase

   __STATIC_INLINE void EvrFsNAND_BlockErase (uint32_t instance, uint32_t row) {

     EventRecord2 (EvtFsNAND_BlockErase, instance, row);

   }

 #else

   #define EvrFsNAND_BlockErase(instance, row)

 #endif


 #ifdef EvtFsNAND_PageWrite

   __STATIC_INLINE void EvrFsNAND_PageWrite (uint32_t instance, uint32_t row, uint32_t col, uint32_t len) {

     EventRecord4 (EvtFsNAND_PageWrite, instance, row, col, len);

   }

 #else

   #define EvrFsNAND_PageWrite(instance, row, col, len)

 #endif


 #ifdef EvtFsNAND_PageRead

   __STATIC_INLINE void EvrFsNAND_PageRead (uint32_t instance, uint32_t row, uint32_t col, uint32_t len) {

     EventRecord4 (EvtFsNAND_PageRead, instance, row, col, len);

   }

 #else

   #define EvrFsNAND_PageRead(instance, row, col, len)

 #endif


 #ifdef EvtFsNAND_ParamPageRead

   __STATIC_INLINE void EvrFsNAND_ParamPageRead (uint32_t instance, uint32_t col, uint32_t len) {

     EventRecord4 (EvtFsNAND_ParamPageRead, instance, col, len, 0);

   }

 #else

   #define EvrFsNAND_ParamPageRead(instance, col, len)

 #endif


 #ifdef EvtFsNAND_IdRead

   __STATIC_INLINE void EvrFsNAND_IdRead (uint32_t instance, uint32_t addr, uint32_t len) {

     EventRecord4 (EvtFsNAND_IdRead, instance, addr, len, 0);

   }

 #else

   #define EvrFsNAND_IdRead(instance, addr, len)

 #endif


 #ifdef EvtFsNAND_DeviceReset

   __STATIC_INLINE void EvrFsNAND_DeviceReset (uint32_t instance) {

     EventRecord2 (EvtFsNAND_DeviceReset, instance, 0);

   }

 #else

   #define EvrFsNAND_DeviceReset(instance)

 #endif


 #ifdef EvtFsMcMCI_InitDriver

   __STATIC_INLINE void EvrFsMcMCI_InitDriver (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsMcMCI_InitDriver, instance, driver);

   }

 #else

   #define EvrFsMcMCI_InitDriver(instance, driver)

 #endif


 #ifdef EvtFsMcMCI_InitDriverError

   __STATIC_INLINE void EvrFsMcMCI_InitDriverError (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsMcMCI_InitDriverError, instance, driver);

   }

 #else

   #define EvrFsMcMCI_InitDriverError(instance, driver)

 #endif


 #ifdef EvtFsMcMCI_InitDriverPowerError

   __STATIC_INLINE void EvrFsMcMCI_InitDriverPowerError (uint32_t instance, uint32_t driver, uint32_t state) {

     EventRecord4 (EvtFsMcMCI_InitDriverPowerError, instance, driver, state, 0);

   }

 #else

   #define EvrFsMcMCI_InitDriverPowerError(instance, driver, state)

 #endif


 #ifdef EvtFsMcMCI_InitMedia

   __STATIC_INLINE void EvrFsMcMCI_InitMedia (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_InitMedia, instance, 0);

   }

 #else

   #define EvrFsMcMCI_InitMedia(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaNotInitialized

   __STATIC_INLINE void EvrFsMcMCI_MediaNotInitialized (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaNotInitialized, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaNotInitialized(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaCdActive

   __STATIC_INLINE void EvrFsMcMCI_MediaCdActive (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaCdActive, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaCdActive(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaCdInactive

   __STATIC_INLINE void EvrFsMcMCI_MediaCdInactive (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaCdInactive, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaCdInactive(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaWpActive

   __STATIC_INLINE void EvrFsMcMCI_MediaWpActive (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaWpActive, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaWpActive(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaWpInactive

   __STATIC_INLINE void EvrFsMcMCI_MediaWpInactive (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaWpInactive, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaWpInactive(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaReset

   __STATIC_INLINE void EvrFsMcMCI_MediaReset (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaReset, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaReset(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaDetectionSD

   __STATIC_INLINE void EvrFsMcMCI_MediaDetectionSD (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaDetectionSD, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaDetectionSD(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaSD_V2

   __STATIC_INLINE void EvrFsMcMCI_MediaSD_V2 (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaSD_V2, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaSD_V2(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaReady

   __STATIC_INLINE void EvrFsMcMCI_MediaReady (uint32_t instance, uint32_t ocr) {

     EventRecord2 (EvtFsMcMCI_MediaReady, instance, ocr);

   }

 #else

   #define EvrFsMcMCI_MediaReady(instance, ocr)

 #endif


 #ifdef EvtFsMcMCI_MediaNoResponse

   __STATIC_INLINE void EvrFsMcMCI_MediaNoResponse (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaNoResponse, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaNoResponse(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaDetectionMMC

   __STATIC_INLINE void EvrFsMcMCI_MediaDetectionMMC (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaDetectionMMC, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaDetectionMMC(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaDetectionError

   __STATIC_INLINE void EvrFsMcMCI_MediaDetectionError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaDetectionError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaDetectionError(instance)

 #endif


 #ifdef EvtFsMcMCI_CidReadError

   __STATIC_INLINE void EvrFsMcMCI_CidReadError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_CidReadError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_CidReadError(instance)

 #endif


 #ifdef EvtFsMcMCI_RcaReadError

   __STATIC_INLINE void EvrFsMcMCI_RcaReadError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_RcaReadError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_RcaReadError(instance)

 #endif


 #ifdef EvtFsMcMCI_RcaWriteError

   __STATIC_INLINE void EvrFsMcMCI_RcaWriteError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_RcaWriteError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_RcaWriteError(instance)

 #endif


 #ifdef EvtFsMcMCI_CsdReadError

   __STATIC_INLINE void EvrFsMcMCI_CsdReadError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_CsdReadError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_CsdReadError(instance)

 #endif


 #ifdef EvtFsMcMCI_TranStateError

   __STATIC_INLINE void EvrFsMcMCI_TranStateError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_TranStateError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_TranStateError(instance)

 #endif


 #ifdef EvtFsMcMCI_BlenWriteError

   __STATIC_INLINE void EvrFsMcMCI_BlenWriteError (uint32_t instance, uint32_t blen) {

     EventRecord2 (EvtFsMcMCI_BlenWriteError, instance, blen);

   }

 #else

   #define EvrFsMcMCI_BlenWriteError(instance, blen)

 #endif


 #ifdef EvtFsMcMCI_ExtCsdReadError

   __STATIC_INLINE void EvrFsMcMCI_ExtCsdReadError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_ExtCsdReadError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_ExtCsdReadError(instance)

 #endif


 #ifdef EvtFsMcMCI_HighSpeedSwitchError

   __STATIC_INLINE void EvrFsMcMCI_HighSpeedSwitchError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_HighSpeedSwitchError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_HighSpeedSwitchError(instance)

 #endif


 #ifdef EvtFsMcMCI_DataBusSwitchError

   __STATIC_INLINE void EvrFsMcMCI_DataBusSwitchError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_DataBusSwitchError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_DataBusSwitchError(instance)

 #endif


 #ifdef EvtFsMcMCI_StbyStateError

   __STATIC_INLINE void EvrFsMcMCI_StbyStateError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_StbyStateError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_StbyStateError(instance)

 #endif


 #ifdef EvtFsMcMCI_InitSuccess

   __STATIC_INLINE void EvrFsMcMCI_InitSuccess (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_InitSuccess, instance, 0);

   }

 #else

   #define EvrFsMcMCI_InitSuccess(instance)

 #endif


 #ifdef EvtFsMcMCI_UninitDriver

   __STATIC_INLINE void EvrFsMcMCI_UninitDriver (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsMcMCI_UninitDriver, instance, driver);

   }

 #else

   #define EvrFsMcMCI_UninitDriver(instance, driver)

 #endif


 #ifdef EvtFsMcMCI_UninitMedia

   __STATIC_INLINE void EvrFsMcMCI_UninitMedia (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_UninitMedia, instance, 0);

   }

 #else

   #define EvrFsMcMCI_UninitMedia(instance)

 #endif


 #ifdef EvtFsMcMCI_SectorRead

   __STATIC_INLINE void EvrFsMcMCI_SectorRead (uint32_t instance, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsMcMCI_SectorRead, instance, sector, count, 0);

   }

 #else

   #define EvrFsMcMCI_SectorRead(instance, sector, count)

 #endif


 #ifdef EvtFsMcMCI_SectorReadError

   __STATIC_INLINE void EvrFsMcMCI_SectorReadError (uint32_t instance, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsMcMCI_SectorReadError, instance, sector, count, 0);

   }

 #else

   #define EvrFsMcMCI_SectorReadError(instance, sector, count)

 #endif


 #ifdef EvtFsMcMCI_SectorWrite

   __STATIC_INLINE void EvrFsMcMCI_SectorWrite (uint32_t instance, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsMcMCI_SectorWrite, instance, sector, count, 0);

   }

 #else

   #define EvrFsMcMCI_SectorWrite(instance, sector, count)

 #endif


 #ifdef EvtFsMcMCI_SectorWriteError

   __STATIC_INLINE void EvrFsMcMCI_SectorWriteError (uint32_t instance, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsMcMCI_SectorWriteError, instance, sector, count, 0);

   }

 #else

   #define EvrFsMcMCI_SectorWriteError(instance, sector, count)

 #endif


 #ifdef EvtFsMcMCI_TransferError

   __STATIC_INLINE void EvrFsMcMCI_TransferError (uint32_t instance, uint32_t events) {

     EventRecord2 (EvtFsMcMCI_TransferError, instance, events);

   }

 #else

   #define EvrFsMcMCI_TransferError(instance, events)

 #endif


 #ifdef EvtFsMcMCI_TransferRetry

   __STATIC_INLINE void EvrFsMcMCI_TransferRetry (uint32_t instance, uint32_t retry) {

     EventRecord2 (EvtFsMcMCI_TransferRetry, instance, retry);

   }

 #else

   #define EvrFsMcMCI_TransferRetry(instance, retry)

 #endif


 #ifdef EvtFsMcMCI_ReadInfo

   __STATIC_INLINE void EvrFsMcMCI_ReadInfo (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_ReadInfo, instance, 0);

   }

 #else

   #define EvrFsMcMCI_ReadInfo(instance)

 #endif


 #ifdef EvtFsMcMCI_ReadInfoSuccess

   __STATIC_INLINE void EvrFsMcMCI_ReadInfoSuccess (uint32_t instance, uint32_t sect_count) {

     EventRecord2 (EvtFsMcMCI_ReadInfoSuccess, instance, sect_count);

   }

 #else

   #define EvrFsMcMCI_ReadInfoSuccess(instance, sect_count)

 #endif


 #ifdef EvtFsMcMCI_DevCtrl

   __STATIC_INLINE void EvrFsMcMCI_DevCtrl (uint32_t instance, uint32_t code, uint32_t p) {

     EventRecord4 (EvtFsMcMCI_DevCtrl, instance, code, p, 0);

   }

 #else

   #define EvrFsMcMCI_DevCtrl(instance, code, p)

 #endif


 #ifdef EvtFsMcMCI_DevCtrlUnsupported

   __STATIC_INLINE void EvrFsMcMCI_DevCtrlUnsupported (uint32_t instance, uint32_t code) {

     EventRecord2 (EvtFsMcMCI_DevCtrlUnsupported, instance, code);

   }

 #else

   #define EvrFsMcMCI_DevCtrlUnsupported(instance, code)

 #endif


 #ifdef EvtFsMcMCI_LockUnlockExec

   __STATIC_INLINE void EvrFsMcMCI_LockUnlockExec (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_LockUnlockExec, instance, 0);

   }

 #else

   #define EvrFsMcMCI_LockUnlockExec(instance)

 #endif


 #ifdef EvtFsMcMCI_LockUnlockExecError

   __STATIC_INLINE void EvrFsMcMCI_LockUnlockExecError (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_LockUnlockExecError, instance, 0);

   }

 #else

   #define EvrFsMcMCI_LockUnlockExecError(instance)

 #endif


 #ifdef EvtFsMcMCI_LockActive

   __STATIC_INLINE void EvrFsMcMCI_LockActive (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_LockActive, instance, 0);

   }

 #else

   #define EvrFsMcMCI_LockActive(instance)

 #endif


 #ifdef EvtFsMcMCI_LockDeactivated

   __STATIC_INLINE void EvrFsMcMCI_LockDeactivated (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_LockDeactivated, instance, 0);

   }

 #else

   #define EvrFsMcMCI_LockDeactivated(instance)

 #endif


 #ifdef EvtFsMcMCI_DeviceStateUnknown

   __STATIC_INLINE void EvrFsMcMCI_DeviceStateUnknown (uint32_t instance, uint32_t state) {

     EventRecord2 (EvtFsMcMCI_DeviceStateUnknown, instance, state);

   }

 #else

   #define EvrFsMcMCI_DeviceStateUnknown(instance, state)

 #endif


 #ifdef EvtFsMcMCI_DeviceStateInvalid

   __STATIC_INLINE void EvrFsMcMCI_DeviceStateInvalid (uint32_t instance, uint32_t state) {

     EventRecord2 (EvtFsMcMCI_DeviceStateInvalid, instance, state);

   }

 #else

   #define EvrFsMcMCI_DeviceStateInvalid(instance, state)

 #endif


 #ifdef EvtFsMcMCI_DeviceStateTimeout

   __STATIC_INLINE void EvrFsMcMCI_DeviceStateTimeout (uint32_t instance, uint32_t cstate, uint32_t nstate) {

     EventRecord4 (EvtFsMcMCI_DeviceStateTimeout, instance, cstate, nstate, 0);

   }

 #else

   #define EvrFsMcMCI_DeviceStateTimeout(instance, cstate, nstate)

 #endif


 #ifdef EvtFsMcMCI_TransferAbort

   __STATIC_INLINE void EvrFsMcMCI_TransferAbort (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_TransferAbort, instance, 0);

   }

 #else

   #define EvrFsMcMCI_TransferAbort(instance)

 #endif


 #ifdef EvtFsMcMCI_SleepAwakeControl

   __STATIC_INLINE void EvrFsMcMCI_SleepAwakeControl (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_SleepAwakeControl, instance, 0);

   }

 #else

   #define EvrFsMcMCI_SleepAwakeControl(instance)

 #endif


 #ifdef EvtFsMcMCI_SleepActive

   __STATIC_INLINE void EvrFsMcMCI_SleepActive (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_SleepActive, instance, 0);

   }

 #else

   #define EvrFsMcMCI_SleepActive(instance)

 #endif


 #ifdef EvtFsMcMCI_AwakeActive

   __STATIC_INLINE void EvrFsMcMCI_AwakeActive (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_AwakeActive, instance, 0);

   }

 #else

   #define EvrFsMcMCI_AwakeActive(instance)

 #endif


 #ifdef EvtFsMcMCI_CardPowerControl

   __STATIC_INLINE void EvrFsMcMCI_CardPowerControl (uint32_t instance, uint32_t voltage) {

     EventRecord2 (EvtFsMcMCI_CardPowerControl, instance, voltage);

   }

 #else

   #define EvrFsMcMCI_CardPowerControl(instance, voltage)

 #endif


 #ifdef EvtFsMcMCI_SendCommandError

   __STATIC_INLINE void EvrFsMcMCI_SendCommandError (uint32_t instance, uint32_t cmd, uint32_t arg) {

     EventRecord4 (EvtFsMcMCI_SendCommandError, instance, cmd, arg, 0);

   }

 #else

   #define EvrFsMcMCI_SendCommandError(instance, cmd, arg)

 #endif


 #ifdef EvtFsMcMCI_ReadXferSetupError

   __STATIC_INLINE void EvrFsMcMCI_ReadXferSetupError (uint32_t instance, uint8_t *buf, uint32_t cnt, uint32_t size) {

     EventRecord4 (EvtFsMcMCI_ReadXferSetupError, instance, (uint32_t)buf, cnt, size);

   }

 #else

   #define EvrFsMcMCI_ReadXferSetupError(instance, buf, cnt, size)

 #endif


 #ifdef EvtFsMcMCI_WriteXferSetupError

   __STATIC_INLINE void EvrFsMcMCI_WriteXferSetupError (uint32_t instance, uint8_t *buf, uint32_t cnt, uint32_t size) {

     EventRecord4 (EvtFsMcMCI_WriteXferSetupError, instance, (uint32_t)buf, cnt, size);

   }

 #else

   #define EvrFsMcMCI_WriteXferSetupError(instance, buf, cnt, size)

 #endif


 #ifdef EvtFsMcMCI_ParameterInvalid

   __STATIC_INLINE void EvrFsMcMCI_ParameterInvalid (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_ParameterInvalid, instance, 0);

   }

 #else

   #define EvrFsMcMCI_ParameterInvalid(instance)

 #endif


 #ifdef EvtFsMcMCI_MediaPasswordEnabled

   __STATIC_INLINE void EvrFsMcMCI_MediaPasswordEnabled (uint32_t instance) {

     EventRecord2 (EvtFsMcMCI_MediaPasswordEnabled, instance, 0);

   }

 #else

   #define EvrFsMcMCI_MediaPasswordEnabled(instance)

 #endif


 #ifdef EvtFsMcSPI_InitDriver

   __STATIC_INLINE void EvrFsMcSPI_InitDriver (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsMcSPI_InitDriver, instance, driver);

   }

 #else

   #define EvrFsMcSPI_InitDriver(instance, driver)

 #endif


 #ifdef EvtFsMcSPI_InitDriverSuccess

   __STATIC_INLINE void EvrFsMcSPI_InitDriverSuccess (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsMcSPI_InitDriverSuccess, instance, driver);

   }

 #else

   #define EvrFsMcSPI_InitDriverSuccess(instance, driver)

 #endif


 #ifdef EvtFsMcSPI_InitDriverError

   __STATIC_INLINE void EvrFsMcSPI_InitDriverError (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsMcSPI_InitDriverError, instance, driver);

   }

 #else

   #define EvrFsMcSPI_InitDriverError(instance, driver)

 #endif


 #ifdef EvtFsMcSPI_InitDriverPowerError

   __STATIC_INLINE void EvrFsMcSPI_InitDriverPowerError (uint32_t instance, uint32_t driver, uint32_t state) {

     EventRecord4 (EvtFsMcSPI_InitDriverPowerError, instance, driver, state, 0);

   }

 #else

   #define EvrFsMcSPI_InitDriverPowerError(instance, driver, state)

 #endif


 #ifdef EvtFsMcSPI_InitMedia

   __STATIC_INLINE void EvrFsMcSPI_InitMedia (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_InitMedia, instance, 0);

   }

 #else

   #define EvrFsMcSPI_InitMedia(instance)

 #endif


 #ifdef EvtFsMcSPI_InitMediaSuccess

   __STATIC_INLINE void EvrFsMcSPI_InitMediaSuccess (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_InitMediaSuccess, instance, 0);

   }

 #else

   #define EvrFsMcSPI_InitMediaSuccess(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaNotInitialized

   __STATIC_INLINE void EvrFsMcSPI_MediaNotInitialized (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaNotInitialized, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaNotInitialized(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaCdActive

   __STATIC_INLINE void EvrFsMcSPI_MediaCdActive (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaCdActive, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaCdActive(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaCdInactive

   __STATIC_INLINE void EvrFsMcSPI_MediaCdInactive (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaCdInactive, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaCdInactive(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaWpActive

   __STATIC_INLINE void EvrFsMcSPI_MediaWpActive (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaWpActive, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaWpActive(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaWpInactive

   __STATIC_INLINE void EvrFsMcSPI_MediaWpInactive (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaWpInactive, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaWpInactive(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaReset

   __STATIC_INLINE void EvrFsMcSPI_MediaReset (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaReset, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaReset(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaResetError

   __STATIC_INLINE void EvrFsMcSPI_MediaResetError (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaResetError, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaResetError(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaDetectionSD

   __STATIC_INLINE void EvrFsMcSPI_MediaDetectionSD (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaDetectionSD, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaDetectionSD(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaSD_V2

   __STATIC_INLINE void EvrFsMcSPI_MediaSD_V2 (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaSD_V2, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaSD_V2(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaReady

   __STATIC_INLINE void EvrFsMcSPI_MediaReady (uint32_t instance, uint32_t ocr) {

     EventRecord2 (EvtFsMcSPI_MediaReady, instance, ocr);

   }

 #else

   #define EvrFsMcSPI_MediaReady(instance, ocr)

 #endif


 #ifdef EvtFsMcSPI_MediaNoResponse

   __STATIC_INLINE void EvrFsMcSPI_MediaNoResponse (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaNoResponse, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaNoResponse(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaDetectionMMC

   __STATIC_INLINE void EvrFsMcSPI_MediaDetectionMMC (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaDetectionMMC, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaDetectionMMC(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaDetectionError

   __STATIC_INLINE void EvrFsMcSPI_MediaDetectionError (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaDetectionError, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaDetectionError(instance)

 #endif


 #ifdef EvtFsMcSPI_CidReadError

   __STATIC_INLINE void EvrFsMcSPI_CidReadError (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_CidReadError, instance, 0);

   }

 #else

   #define EvrFsMcSPI_CidReadError(instance)

 #endif


 #ifdef EvtFsMcSPI_CsdReadError

   __STATIC_INLINE void EvrFsMcSPI_CsdReadError (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_CsdReadError, instance, 0);

   }

 #else

   #define EvrFsMcSPI_CsdReadError(instance)

 #endif


 #ifdef EvtFsMcSPI_BlenWriteError

   __STATIC_INLINE void EvrFsMcSPI_BlenWriteError (uint32_t instance, uint32_t blen) {

     EventRecord2 (EvtFsMcSPI_BlenWriteError, instance, blen);

   }

 #else

   #define EvrFsMcSPI_BlenWriteError(instance, blen)

 #endif


 #ifdef EvtFsMcSPI_UninitDriver

   __STATIC_INLINE void EvrFsMcSPI_UninitDriver (uint32_t instance, uint32_t driver) {

     EventRecord2 (EvtFsMcSPI_UninitDriver, instance, driver);

   }

 #else

   #define EvrFsMcSPI_UninitDriver(instance, driver)

 #endif


 #ifdef EvtFsMcSPI_UninitMedia

   __STATIC_INLINE void EvrFsMcSPI_UninitMedia (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_UninitMedia, instance, 0);

   }

 #else

   #define EvrFsMcSPI_UninitMedia(instance)

 #endif


 #ifdef EvtFsMcSPI_SectorRead

   __STATIC_INLINE void EvrFsMcSPI_SectorRead (uint32_t instance, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsMcSPI_SectorRead, instance, sector, count, 0);

   }

 #else

   #define EvrFsMcSPI_SectorRead(instance, sector, count)

 #endif


 #ifdef EvtFsMcSPI_SectorReadError

   __STATIC_INLINE void EvrFsMcSPI_SectorReadError (uint32_t instance, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsMcSPI_SectorReadError, instance, sector, count, 0);

   }

 #else

   #define EvrFsMcSPI_SectorReadError(instance, sector, count)

 #endif


 #ifdef EvtFsMcSPI_SectorWrite

   __STATIC_INLINE void EvrFsMcSPI_SectorWrite (uint32_t instance, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsMcSPI_SectorWrite, instance, sector, count, 0);

   }

 #else

   #define EvrFsMcSPI_SectorWrite(instance, sector, count)

 #endif


 #ifdef EvtFsMcSPI_SectorWriteError

   __STATIC_INLINE void EvrFsMcSPI_SectorWriteError (uint32_t instance, uint32_t sector, uint32_t count) {

     EventRecord4 (EvtFsMcSPI_SectorWriteError, instance, sector, count, 0);

   }

 #else

   #define EvrFsMcSPI_SectorWriteError(instance, sector, count)

 #endif


 #ifdef EvtFsMcSPI_ReadInfo

   __STATIC_INLINE void EvrFsMcSPI_ReadInfo (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_ReadInfo, instance, 0);

   }

 #else

   #define EvrFsMcSPI_ReadInfo(instance)

 #endif


 #ifdef EvtFsMcSPI_ReadInfoSuccess

   __STATIC_INLINE void EvrFsMcSPI_ReadInfoSuccess (uint32_t instance, uint32_t sect_count) {

     EventRecord2 (EvtFsMcSPI_ReadInfoSuccess, instance, sect_count);

   }

 #else

   #define EvrFsMcSPI_ReadInfoSuccess(instance, sect_count)

 #endif


 #ifdef EvtFsMcSPI_DevCtrl

   __STATIC_INLINE void EvrFsMcSPI_DevCtrl (uint32_t instance, uint32_t code, uint32_t p) {

     EventRecord4 (EvtFsMcSPI_DevCtrl, instance, code, p, 0);

   }

 #else

   #define EvrFsMcSPI_DevCtrl(instance, code, p)

 #endif


 #ifdef EvtFsMcSPI_DevCtrlUnsupported

   __STATIC_INLINE void EvrFsMcSPI_DevCtrlUnsupported (uint32_t instance, uint32_t code) {

     EventRecord2 (EvtFsMcSPI_DevCtrlUnsupported, instance, code);

   }

 #else

   #define EvrFsMcSPI_DevCtrlUnsupported(instance, code)

 #endif


 #ifdef EvtFsMcSPI_LockUnlockExec

   __STATIC_INLINE void EvrFsMcSPI_LockUnlockExec (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_LockUnlockExec, instance, 0);

   }

 #else

   #define EvrFsMcSPI_LockUnlockExec(instance)

 #endif


 #ifdef EvtFsMcSPI_LockUnlockExecError

   __STATIC_INLINE void EvrFsMcSPI_LockUnlockExecError (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_LockUnlockExecError, instance, 0);

   }

 #else

   #define EvrFsMcSPI_LockUnlockExecError(instance)

 #endif


 #ifdef EvtFsMcSPI_LockActive

   __STATIC_INLINE void EvrFsMcSPI_LockActive (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_LockActive, instance, 0);

   }

 #else

   #define EvrFsMcSPI_LockActive(instance)

 #endif


 #ifdef EvtFsMcSPI_LockDeactivated

   __STATIC_INLINE void EvrFsMcSPI_LockDeactivated (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_LockDeactivated, instance, 0);

   }

 #else

   #define EvrFsMcSPI_LockDeactivated(instance)

 #endif


 #ifdef EvtFsMcSPI_BusSpeedControl

   __STATIC_INLINE void EvrFsMcSPI_BusSpeedControl (uint32_t instance, uint32_t speed) {

     EventRecord2 (EvtFsMcSPI_BusSpeedControl, instance, speed);

   }

 #else

   #define EvrFsMcSPI_BusSpeedControl(instance, speed)

 #endif


 #ifdef EvtFsMcSPI_SlaveSelCtrlMissing

   __STATIC_INLINE void EvrFsMcSPI_SlaveSelCtrlMissing (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_SlaveSelCtrlMissing, instance, 0);

   }

 #else

   #define EvrFsMcSPI_SlaveSelCtrlMissing(instance)

 #endif


 #ifdef EvtFsMcSPI_ReadWpMissing

   __STATIC_INLINE void EvrFsMcSPI_ReadWpMissing (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_ReadWpMissing, instance, 0);

   }

 #else

   #define EvrFsMcSPI_ReadWpMissing(instance)

 #endif


 #ifdef EvtFsMcSPI_ReadCdMissing

   __STATIC_INLINE void EvrFsMcSPI_ReadCdMissing (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_ReadCdMissing, instance, 0);

   }

 #else

   #define EvrFsMcSPI_ReadCdMissing(instance)

 #endif


 #ifdef EvtFsMcSPI_CrcDisableError

   __STATIC_INLINE void EvrFsMcSPI_CrcDisableError (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_CrcDisableError, instance, 0);

   }

 #else

   #define EvrFsMcSPI_CrcDisableError(instance)

 #endif


 #ifdef EvtFsMcSPI_DriverSendError

   __STATIC_INLINE void EvrFsMcSPI_DriverSendError (uint32_t instance, uint32_t event) {

     EventRecord2 (EvtFsMcSPI_DriverSendError, instance, event);

   }

 #else

   #define EvrFsMcSPI_DriverSendError(instance, event)

 #endif


 #ifdef EvtFsMcSPI_DriverReceiveError

   __STATIC_INLINE void EvrFsMcSPI_DriverReceiveError (uint32_t instance, uint32_t event) {

     EventRecord2 (EvtFsMcSPI_DriverReceiveError, instance, event);

   }

 #else

   #define EvrFsMcSPI_DriverReceiveError(instance, event)

 #endif


 #ifdef EvtFsMcSPI_CmdSendError

   __STATIC_INLINE void EvrFsMcSPI_CmdSendError (uint32_t instance, uint32_t cmd, uint32_t arg) {

     EventRecord4 (EvtFsMcSPI_CmdSendError, instance, cmd, arg, 0);

   }

 #else

   #define EvrFsMcSPI_CmdSendError(instance, cmd, arg)

 #endif


 #ifdef EvtFsMcSPI_CmdResponseError

   __STATIC_INLINE void EvrFsMcSPI_CmdResponseError (uint32_t instance, uint32_t cmd) {

     EventRecord2 (EvtFsMcSPI_CmdResponseError, instance, cmd);

   }

 #else

   #define EvrFsMcSPI_CmdResponseError(instance, cmd)

 #endif


 #ifdef EvtFsMcSPI_ACmdResponseError

   __STATIC_INLINE void EvrFsMcSPI_ACmdResponseError (uint32_t instance, uint32_t cmd) {

     EventRecord2 (EvtFsMcSPI_ACmdResponseError, instance, cmd);

   }

 #else

   #define EvrFsMcSPI_ACmdResponseError(instance, cmd)

 #endif


 #ifdef EvtFsMcSPI_ParameterInvalid

   __STATIC_INLINE void EvrFsMcSPI_ParameterInvalid (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_ParameterInvalid, instance, 0);

   }

 #else

   #define EvrFsMcSPI_ParameterInvalid(instance)

 #endif


 #ifdef EvtFsMcSPI_MediaPasswordEnabled

   __STATIC_INLINE void EvrFsMcSPI_MediaPasswordEnabled (uint32_t instance) {

     EventRecord2 (EvtFsMcSPI_MediaPasswordEnabled, instance, 0);

   }

 #else

   #define EvrFsMcSPI_MediaPasswordEnabled(instance)

 #endif

EvrFsFAT_TimeSet
__STATIC_INLINE void EvrFsFAT_TimeSet(uint32_t drive, const char *path)
Event on FAT timestamp set (Op)
Definition: fs_evr.h:2156

EvtFsFAT_NonexistentMBR
#define EvtFsFAT_NonexistentMBR
Definition: fs_evr.h:86

EvrFsFAT_FormatMediaCapacity
__STATIC_INLINE void EvrFsFAT_FormatMediaCapacity(uint32_t drive, uint32_t sectors)
Event on FAT media capacity read (Op)
Definition: fs_evr.h:1294

EvtFsIOC_GetCache
#define EvtFsIOC_GetCache
Definition: fs_evr.h:244

EvrFsFAT_CountFreeClus
__STATIC_INLINE void EvrFsFAT_CountFreeClus(uint32_t drive)
Event on count number of free clusters operation (Op)
Definition: fs_evr.h:1196

EvtFsEFS_DataAreaOverlap
#define EvtFsEFS_DataAreaOverlap
Definition: fs_evr.h:215

EvrFsEFS_FileAllocRead
__STATIC_INLINE void EvrFsEFS_FileAllocRead(uint32_t addr, uint32_t end, uint32_t fileID, uint32_t index)
Event on EFS file allocation info read (Detail)
Definition: fs_evr.h:2985

EvtFsMcSPI_ACmdResponseError
#define EvtFsMcSPI_ACmdResponseError
Definition: fs_evr.h:460

EvrFsMcMCI_LockUnlockExecError
__STATIC_INLINE void EvrFsMcMCI_LockUnlockExecError(uint32_t instance)
Event on Lock/Unlock command execution error (Error)
Definition: fs_evr.h:5007

EvrFsIOC_Unlock
__STATIC_INLINE void EvrFsIOC_Unlock(uint32_t drv_id)
Event on call of fs_ioc_unlock function (API)
Definition: fs_evr.h:3059

EvtFsFAT_FileIsReadOnly
#define EvtFsFAT_FileIsReadOnly
Definition: fs_evr.h:119

EvrFsCore_fdelete_l
__STATIC_INLINE void EvrFsCore_fdelete_l(const char *path)
Event on file delete (API)
Definition: fs_evr.h:610

EvtFsFAT_PathIsDirNotFile
#define EvtFsFAT_PathIsDirNotFile
Definition: fs_evr.h:117

EvtFsEFS_UnmountDrive
#define EvtFsEFS_UnmountDrive
Definition: fs_evr.h:184

EvrFsFAT_DirEntryAllocFailed
__STATIC_INLINE void EvrFsFAT_DirEntryAllocFailed(uint32_t drive, uint32_t dir_clus)
Event on directory entry allocation error (Error)
Definition: fs_evr.h:1627

EvtFsFAT_FormatNoSpace
#define EvtFsFAT_FormatNoSpace
Definition: fs_evr.h:105

EvrFsCore_sys_write
__STATIC_INLINE void EvrFsCore_sys_write(int fh, const unsigned char *buf, unsigned int len)
Event on write to a file (API)
Definition: fs_evr.h:498

EvtFsMcSPI_MediaNotInitialized
#define EvtFsMcSPI_MediaNotInitialized
Definition: fs_evr.h:421

EvtFsFAT_WriteBootSector
#define EvtFsFAT_WriteBootSector
Definition: fs_evr.h:108

EvrFsMcMCI_MediaDetectionSD
__STATIC_INLINE void EvrFsMcMCI_MediaDetectionSD(uint32_t instance)
Event on start of SD memory card detection operation (Op)
Definition: fs_evr.h:4629

EvtFsFAT_FileClose
#define EvtFsFAT_FileClose
Definition: fs_evr.h:134

EvtFsNFTL_WriteSector
#define EvtFsNFTL_WriteSector
Definition: fs_evr.h:290

EvrFsIOC_DriveIdInvalid
__STATIC_INLINE void EvrFsIOC_DriveIdInvalid(uint32_t drv_id)
Event on invalid drive ID specifier (Error)
Definition: fs_evr.h:3266

EvrFsIOC_ReadSectorSuccess
__STATIC_INLINE void EvrFsIOC_ReadSectorSuccess(uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt)
Event on successful read sector operation (Op)
Definition: fs_evr.h:3128

EvrFsFAT_MountDrive
__STATIC_INLINE void EvrFsFAT_MountDrive(uint32_t drive)
Event on FAT drive mount operation (Op)
Definition: fs_evr.h:976

EvtFsEFS_FormatDriveSuccess
#define EvtFsEFS_FormatDriveSuccess
Definition: fs_evr.h:187

EvrFsEFS_FlashEraseFailed
__STATIC_INLINE void EvrFsEFS_FlashEraseFailed(uint32_t drive, uint32_t block, uint32_t addr)
Event on Flash driver read data error (Error)
Definition: fs_evr.h:2906

EvtFsFAT_GetFreeSpace
#define EvtFsFAT_GetFreeSpace
Definition: fs_evr.h:155

EvtFsNAND_DriverEccInquire
#define EvtFsNAND_DriverEccInquire
Definition: fs_evr.h:342

EvrFsMcSPI_ReadInfo
__STATIC_INLINE void EvrFsMcSPI_ReadInfo(uint32_t instance)
Event on media capacity retrieval operation (Op)
Definition: fs_evr.h:5565

EvrFsFAT_VolumeWriteStatError
__STATIC_INLINE void EvrFsFAT_VolumeWriteStatError(uint32_t drive)
Event on FAT volume write protection active status error (Error)
Definition: fs_evr.h:1036

EvrFsIOC_ReadSectorError
__STATIC_INLINE void EvrFsIOC_ReadSectorError(uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt)
Event on read sector operation error (Error)
Definition: fs_evr.h:3143

EvtFsNFTL_DevCtrlUnsupported
#define EvtFsNFTL_DevCtrlUnsupported
Definition: fs_evr.h:283

EvrFsIOC_WriteSectorError
__STATIC_INLINE void EvrFsIOC_WriteSectorError(uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt)
Event on write sector operation error (Error)
Definition: fs_evr.h:3188

EvtFsMcSPI_MediaWpActive
#define EvtFsMcSPI_MediaWpActive
Definition: fs_evr.h:424

EvrFsEFS_FileSeek
__STATIC_INLINE void EvrFsEFS_FileSeek(uint32_t h, uint32_t pos)
Event on EFS file seek (Op)
Definition: fs_evr.h:2587

EvrFsIOC_ReadInfo
__STATIC_INLINE void EvrFsIOC_ReadInfo(uint32_t drv_id, uint32_t info)
Event on call of fs_ioc_read_info function (API)
Definition: fs_evr.h:3201

EvtFsEFS_FlashWriteFailed
#define EvtFsEFS_FlashWriteFailed
Definition: fs_evr.h:224

EvrFsMcMCI_DeviceStateInvalid
__STATIC_INLINE void EvrFsMcMCI_DeviceStateInvalid(uint32_t instance, uint32_t state)
Event on discovery of invalid device state (Error)
Definition: fs_evr.h:5057

EvtFsMcMCI_CardPowerControl
#define EvtFsMcMCI_CardPowerControl
Definition: fs_evr.h:407

EvtFsMcSPI_InitDriverSuccess
#define EvtFsMcSPI_InitDriverSuccess
Definition: fs_evr.h:416

EvtFsNFTL_PageProgramStatusErr
#define EvtFsNFTL_PageProgramStatusErr
Definition: fs_evr.h:311

EvtFsMcMCI_UninitDriver
#define EvtFsMcMCI_UninitDriver
Definition: fs_evr.h:384

EvtFsMcMCI_LockUnlockExec
#define EvtFsMcMCI_LockUnlockExec
Definition: fs_evr.h:396

EvtFsFAT_OptionsString
#define EvtFsFAT_OptionsString
Definition: fs_evr.h:162

EvrFsEFS_FlashReadTimeout
__STATIC_INLINE void EvrFsEFS_FlashReadTimeout(uint32_t drive, uint32_t addr, void *buf, uint32_t cnt)
Event on Flash driver read data timeout (Error)
Definition: fs_evr.h:2892

EvrFsEFS_DriveCheckSuccess
__STATIC_INLINE void EvrFsEFS_DriveCheckSuccess(uint32_t drive)
Event on EFS drive check completed without errors (Error)
Definition: fs_evr.h:2726

EvrFsEFS_FormatDriveSuccess
__STATIC_INLINE void EvrFsEFS_FormatDriveSuccess(uint32_t drive)
Event on successful EFS drive format operation (Op)
Definition: fs_evr.h:2382

EvrFsMcMCI_LockUnlockExec
__STATIC_INLINE void EvrFsMcMCI_LockUnlockExec(uint32_t instance)
Event on Lock/Unlock command execution (Op)
Definition: fs_evr.h:4995

EvrFsFAT_FileSeek
__STATIC_INLINE void EvrFsFAT_FileSeek(uint32_t h, uint32_t pos)
Event on FAT file seek (Op)
Definition: fs_evr.h:1753

EvrFsFAT_InvalidMBR
__STATIC_INLINE void EvrFsFAT_InvalidMBR(uint32_t drive)
Event on invalid Master Boot Record (Error)
Definition: fs_evr.h:1073

EvrFsFAT_ChDirSuccess
__STATIC_INLINE void EvrFsFAT_ChDirSuccess(uint32_t drive, const char *path)
Event on successful FAT directory remove operation (Op)
Definition: fs_evr.h:1901

EvtFsFAT_ChDir
#define EvtFsFAT_ChDir
Definition: fs_evr.h:149

EvrFsFAT_FileHandleError
__STATIC_INLINE void EvrFsFAT_FileHandleError(int32_t h, uint32_t flags)
Event on FAT file handle error (Error)
Definition: fs_evr.h:1700

EvtFsMcSPI_CidReadError
#define EvtFsMcSPI_CidReadError
Definition: fs_evr.h:434

EvrFsMcMCI_MediaWpInactive
__STATIC_INLINE void EvrFsMcMCI_MediaWpInactive(uint32_t instance)
Event on inactive write protection switch (Op)
Definition: fs_evr.h:4605

EvrFsEFS_FileAllocWrite
__STATIC_INLINE void EvrFsEFS_FileAllocWrite(uint32_t addr, uint32_t end, uint32_t fileID, uint32_t index)
Event on EFS file allocation info write (Detail)
Definition: fs_evr.h:2970

EvrFsFAT_FormatLowLevel
__STATIC_INLINE void EvrFsFAT_FormatLowLevel(uint32_t drive)
Event on FAT media low level format operation (Op)
Definition: fs_evr.h:1306

EvtFsFAT_DirRemoveSuccess
#define EvtFsFAT_DirRemoveSuccess
Definition: fs_evr.h:148

EvrFsFAT_ReadBootSector
__STATIC_INLINE void EvrFsFAT_ReadBootSector(uint32_t drive, uint32_t sector)
Event on Boot Sector read operation (Op)
Definition: fs_evr.h:1098

EvrFsMcSPI_MediaResetError
__STATIC_INLINE void EvrFsMcSPI_MediaResetError(uint32_t instance)
Event on memory card device reset error (Op)
Definition: fs_evr.h:5361

EvrFsIOC_GetCacheSuccess
__STATIC_INLINE void EvrFsIOC_GetCacheSuccess(uint32_t drv_id, uint32_t buf, uint32_t size)
Event on successful cache buffer information retrieve operation (Op)
Definition: fs_evr.h:3098

EvtFsEFS_OpenModeUnsupported
#define EvtFsEFS_OpenModeUnsupported
Definition: fs_evr.h:194

EvtFsNFTL_ReadInfoSuccess
#define EvtFsNFTL_ReadInfoSuccess
Definition: fs_evr.h:281

EvtFsCore_fattrib
#define EvtFsCore_fattrib
Definition: fs_evr.h:51

EvtFsIOC_ReadInfoSuccess
#define EvtFsIOC_ReadInfoSuccess
Definition: fs_evr.h:253

EvtFsCore_CurrentDriveSelect
#define EvtFsCore_CurrentDriveSelect
Definition: fs_evr.h:66

EvtFsIOC_ReadInfoError
#define EvtFsIOC_ReadInfoError
Definition: fs_evr.h:254

EvtFsNFTL_TableUpdate
#define EvtFsNFTL_TableUpdate
Definition: fs_evr.h:319

EvrFsNFTL_LoadSector
__STATIC_INLINE void EvrFsNFTL_LoadSector(uint32_t instance, uint32_t lsn, uint32_t offs, uint32_t spare)
Event on loading sector data from/to NAND page buffer (Detail)
Definition: fs_evr.h:4068

EvtFsCore_sys_open
#define EvtFsCore_sys_open
Definition: fs_evr.h:36

EvrFsMcMCI_TransferAbort
__STATIC_INLINE void EvrFsMcMCI_TransferAbort(uint32_t instance)
Event on data transfer abort operation (Op)
Definition: fs_evr.h:5083

EvrFsFAT_InitJournalFATError
__STATIC_INLINE void EvrFsFAT_InitJournalFATError(uint32_t drive)
Event on invalid FAT formatting to complete journal initialization (Error)
Definition: fs_evr.h:1675

EvrFsEFS_OpenModeInvalid
__STATIC_INLINE void EvrFsEFS_OpenModeInvalid(uint32_t h, uint32_t flags)
Event on invalid EFS file handle open mode (Error)
Definition: fs_evr.h:2574

EvrFsMcMCI_HighSpeedSwitchError
__STATIC_INLINE void EvrFsMcMCI_HighSpeedSwitchError(uint32_t instance)
Event on high speed mode switch error (Error)
Definition: fs_evr.h:4787

EvtFsFAT_WriteFSInfo
#define EvtFsFAT_WriteFSInfo
Definition: fs_evr.h:94

EvtFsFAT_DriverNotInitialized
#define EvtFsFAT_DriverNotInitialized
Definition: fs_evr.h:160

EvtFsNFTL_SetupSpareLayout
#define EvtFsNFTL_SetupSpareLayout
Definition: fs_evr.h:325

EvrFsFAT_ClearRootSectors
__STATIC_INLINE void EvrFsFAT_ClearRootSectors(uint32_t drive, uint32_t sector, uint32_t count)
Event on FAT root sectors clear operation (Op)
Definition: fs_evr.h:1398

EvtFsMcMCI_LockUnlockExecError
#define EvtFsMcMCI_LockUnlockExecError
Definition: fs_evr.h:397

EvrFsMcSPI_UninitMedia
__STATIC_INLINE void EvrFsMcSPI_UninitMedia(uint32_t instance)
Event on memory card device uninitialization (Op)
Definition: fs_evr.h:5497

EvrFsFAT_DriverNotInitialized
__STATIC_INLINE void EvrFsFAT_DriverNotInitialized(uint32_t drive)
Event on EFS when media driver is not initialized (Error)
Definition: fs_evr.h:2031

EvtFsMcSPI_MediaCdInactive
#define EvtFsMcSPI_MediaCdInactive
Definition: fs_evr.h:423

EvrFsNFTL_PageWrite
__STATIC_INLINE void EvrFsNFTL_PageWrite(uint32_t instance, uint32_t pbn, uint32_t pg)
Event on page write (Op)
Definition: fs_evr.h:4141

EvtFsMcSPI_MediaReady
#define EvtFsMcSPI_MediaReady
Definition: fs_evr.h:430

EvtFsCore_frmdir
#define EvtFsCore_frmdir
Definition: fs_evr.h:55

EvrFsEFS_FlashEraseChipTimeout
__STATIC_INLINE void EvrFsEFS_FlashEraseChipTimeout(uint32_t drive)
Event on Flash chip erase operation timeout (Error)
Definition: fs_evr.h:2418

EvrFsFAT_VolumeReadyStatError
__STATIC_INLINE void EvrFsFAT_VolumeReadyStatError(uint32_t drive)
Event on FAT volume ready status error (Error)
Definition: fs_evr.h:1024

EvrFsNFTL_FormatLLEB
__STATIC_INLINE void EvrFsNFTL_FormatLLEB(uint32_t instance)
Event on NFTL format operation with option LLEB (Op)
Definition: fs_evr.h:3596

EvrFsMcSPI_ReadCdMissing
__STATIC_INLINE void EvrFsMcSPI_ReadCdMissing(uint32_t instance)
Event on missing fs_mc_read_cd function (Op)
Definition: fs_evr.h:5702

EvrFsNFTL_PageReadFailed
__STATIC_INLINE void EvrFsNFTL_PageReadFailed(uint32_t instance, uint32_t row)
Event on NAND page read error (Error)
Definition: fs_evr.h:3922

EvrFsCore_frename
__STATIC_INLINE void EvrFsCore_frename(const char *path, const char *newname)
Event on file or directory rename (API)
Definition: fs_evr.h:649

EvrFsMcSPI_MediaDetectionError
__STATIC_INLINE void EvrFsMcSPI_MediaDetectionError(uint32_t instance)
Event on media device detection error (Error)
Definition: fs_evr.h:5434

EvrFsMcMCI_MediaNoResponse
__STATIC_INLINE void EvrFsMcMCI_MediaNoResponse(uint32_t instance)
Event on nonresponsive media device (Error)
Definition: fs_evr.h:4666

EvtFsMcMCI_ExtCsdReadError
#define EvtFsMcMCI_ExtCsdReadError
Definition: fs_evr.h:379

fsTime::year
uint16_t year
Year [1980..2107].
Definition: rl_fs.h:138

EvtFsFAT_ReadBootSector
#define EvtFsFAT_ReadBootSector
Definition: fs_evr.h:87

EvtFsFAT_PathIsTooLong
#define EvtFsFAT_PathIsTooLong
Definition: fs_evr.h:116

EvrFsFAT_NameCacheHit
__STATIC_INLINE void EvrFsFAT_NameCacheHit(uint32_t drive, const char *name, uint32_t len)
Event on FAT name cache hit (Op)
Definition: fs_evr.h:2084

EvrFsFAT_MountDriveSuccess
__STATIC_INLINE void EvrFsFAT_MountDriveSuccess(uint32_t drive)
Event on successful mount of a FAT drive (Op)
Definition: fs_evr.h:1208

EvtFsNAND_DriverDevPowerSelect
#define EvtFsNAND_DriverDevPowerSelect
Definition: fs_evr.h:341

EvrFsNFTL_LsnFound
__STATIC_INLINE void EvrFsNFTL_LsnFound(uint32_t instance, uint32_t lsn, uint32_t pbn, uint32_t pg)
Event when logical sector is found within NAND block (Op)
Definition: fs_evr.h:3814

EvrFsCore_fpwd
__STATIC_INLINE void EvrFsCore_fpwd(const char *drive, char *buf, uint32_t len)
Event on working directory retrieval (API)
Definition: fs_evr.h:676

EvtFsFAT_DirRemove
#define EvtFsFAT_DirRemove
Definition: fs_evr.h:147

EvtFsMcSPI_SectorWriteError
#define EvtFsMcSPI_SectorWriteError
Definition: fs_evr.h:442

EvtFsNAND_InitDriver
#define EvtFsNAND_InitDriver
Definition: fs_evr.h:335

EvrFsNFTL_ReadTableFailed
__STATIC_INLINE void EvrFsNFTL_ReadTableFailed(uint32_t instance)
Event on NFTL (Error)
Definition: fs_evr.h:3471

EvtFsMcSPI_MediaWpInactive
#define EvtFsMcSPI_MediaWpInactive
Definition: fs_evr.h:425

EvrFsEFS_InitDrive
__STATIC_INLINE void EvrFsEFS_InitDrive(uint32_t drive)
Event on EFS drive initialization (Op)
Definition: fs_evr.h:2220

EvrFsIOC_DriveNotFAT
__STATIC_INLINE void EvrFsIOC_DriveNotFAT(uint32_t drv_id)
Event on non-FAT drive specifier (Error)
Definition: fs_evr.h:3278

EvtFsFAT_TimeData
#define EvtFsFAT_TimeData
Definition: fs_evr.h:171

EvrFsNFTL_TableUpdate
__STATIC_INLINE void EvrFsNFTL_TableUpdate(uint32_t instance, uint32_t lbn, uint32_t pbn_0, uint32_t pbn_1)
Event on translation table update (Op)
Definition: fs_evr.h:4040

EvrFsFAT_DiskFull
__STATIC_INLINE void EvrFsFAT_DiskFull(uint32_t drive)
Event on out of free space error (Error)
Definition: fs_evr.h:1614

EvrFsFAT_FileRenameSuccess
__STATIC_INLINE void EvrFsFAT_FileRenameSuccess(uint32_t drive, const char *path, const char *newname)
Event on successful FAT file rename operation (Op)
Definition: fs_evr.h:1821

EvrFsEFS_UnmountDriveSuccess
__STATIC_INLINE void EvrFsEFS_UnmountDriveSuccess(uint32_t drive)
Event on successful EFS drive unmount operation (Op)
Definition: fs_evr.h:2358

EvrFsNFTL_ParameterInvalid
__STATIC_INLINE void EvrFsNFTL_ParameterInvalid(uint32_t instance)
Event on invalid function parameter(s) (Error)
Definition: fs_evr.h:4025

EvtFsMcMCI_InitDriverError
#define EvtFsMcMCI_InitDriverError
Definition: fs_evr.h:358

EvrFsMcSPI_DriverReceiveError
__STATIC_INLINE void EvrFsMcSPI_DriverReceiveError(uint32_t instance, uint32_t event)
Event on SPI driver Receive function error (Error)
Definition: fs_evr.h:5740

EvrFsMcMCI_InitDriver
__STATIC_INLINE void EvrFsMcMCI_InitDriver(uint32_t instance, uint32_t driver)
Event on memory card driver initialization (Op)
Definition: fs_evr.h:4506

EvrFsEFS_FileInUse
__STATIC_INLINE void EvrFsEFS_FileInUse(uint32_t h)
Event on EFS file busy (Error)
Definition: fs_evr.h:2835

EvrFsCore_sys_open
__STATIC_INLINE void EvrFsCore_sys_open(const char *name, int openmode)
Event on file open (API)
Definition: fs_evr.h:472

EvrFsFAT_DirRemoveSuccess
__STATIC_INLINE void EvrFsFAT_DirRemoveSuccess(uint32_t drive, const char *path, const char *options)
Event on successful FAT directory remove operation (Op)
Definition: fs_evr.h:1875

EvtFsFAT_LabelString
#define EvtFsFAT_LabelString
Definition: fs_evr.h:163

EvrFsEFS_FileSeekEOF
__STATIC_INLINE void EvrFsEFS_FileSeekEOF(uint32_t h, uint32_t size, uint32_t pos)
Event on EFS file seek beyond EOF (Error)
Definition: fs_evr.h:2601

EvrFsMcMCI_RcaWriteError
__STATIC_INLINE void EvrFsMcMCI_RcaWriteError(uint32_t instance)
Event on RCA (Relative Card Address) register write error (Error)
Definition: fs_evr.h:4726

EvtFsNAND_BlockErase
#define EvtFsNAND_BlockErase
Definition: fs_evr.h:349

EvrFsNFTL_BlockEraseTimeout
__STATIC_INLINE void EvrFsNFTL_BlockEraseTimeout(uint32_t instance, uint32_t row)
Event on NAND block erase timeout (Error)
Definition: fs_evr.h:4000

EvtFsMcMCI_SectorReadError
#define EvtFsMcMCI_SectorReadError
Definition: fs_evr.h:387

EvrFsMcSPI_MediaReady
__STATIC_INLINE void EvrFsMcSPI_MediaReady(uint32_t instance, uint32_t ocr)
Event on received response from SD memory card V2 (Op)
Definition: fs_evr.h:5398

EvrFsCore_sys_read
__STATIC_INLINE void EvrFsCore_sys_read(int fh, unsigned char *buf, unsigned int len)
Event on read from a file (API)
Definition: fs_evr.h:512

EvtFsFAT_FileDelete
#define EvtFsFAT_FileDelete
Definition: fs_evr.h:141

EvrFsNFTL_ReadTable
__STATIC_INLINE void EvrFsNFTL_ReadTable(uint32_t instance)
Event on NFTL invalid boot signatures (Op)
Definition: fs_evr.h:3459

EvtFsNFTL_ResetDeviceTimeout
#define EvtFsNFTL_ResetDeviceTimeout
Definition: fs_evr.h:269

EvrFsFAT_InvalidFSInfo
__STATIC_INLINE void EvrFsFAT_InvalidFSInfo(uint32_t drive)
Event on invalid FAT FSInfo signature (Error)
Definition: fs_evr.h:1147

EvtFsMcMCI_DeviceStateInvalid
#define EvtFsMcMCI_DeviceStateInvalid
Definition: fs_evr.h:401

EvtFsFAT_InitJournalSuccess
#define EvtFsFAT_InitJournalSuccess
Definition: fs_evr.h:132

EvtFsNFTL_WriteSectorSuccess
#define EvtFsNFTL_WriteSectorSuccess
Definition: fs_evr.h:291

EvrFsNFTL_SetBadBlockMarker
__STATIC_INLINE void EvrFsNFTL_SetBadBlockMarker(uint32_t instance, uint32_t pbn)
Event on setting NAND block as bad (Op)
Definition: fs_evr.h:3856

EvrFsFAT_UnmountDrive
__STATIC_INLINE void EvrFsFAT_UnmountDrive(uint32_t drive)
Event on FAT drive unmount operation (Op)
Definition: fs_evr.h:1220

EvtFsMcMCI_TransferAbort
#define EvtFsMcMCI_TransferAbort
Definition: fs_evr.h:403

EvrFsNFTL_LsnNotFound
__STATIC_INLINE void EvrFsNFTL_LsnNotFound(uint32_t instance, uint32_t lsn, uint32_t pbn)
Event when logical sector is not found within NAND block (Op)
Definition: fs_evr.h:3828

EvtFsMcMCI_RcaReadError
#define EvtFsMcMCI_RcaReadError
Definition: fs_evr.h:374

EvtFsNFTL_BlockEraseFailed
#define EvtFsNFTL_BlockEraseFailed
Definition: fs_evr.h:315

EvrFsFAT_PathIsDirNotFile
__STATIC_INLINE void EvrFsFAT_PathIsDirNotFile(uint32_t drive)
Event on FAT directory found instead of file (Error)
Definition: fs_evr.h:1477

EvrFsMcSPI_CmdSendError
__STATIC_INLINE void EvrFsMcSPI_CmdSendError(uint32_t instance, uint32_t cmd, uint32_t arg)
Event on command send error (Error)
Definition: fs_evr.h:5754

EvrFsCore_fchdrive
__STATIC_INLINE void EvrFsCore_fchdrive(const char *drive)
Event on current drive change (API)
Definition: fs_evr.h:725

EvrFsNAND_Uninit
__STATIC_INLINE void EvrFsNAND_Uninit(uint32_t instance)
Event on NAND media layer uninitialization (Op)
Definition: fs_evr.h:4397

EvtFsNFTL_ReadBootBlockFailed
#define EvtFsNFTL_ReadBootBlockFailed
Definition: fs_evr.h:271

EvtFsIOC_GetId
#define EvtFsIOC_GetId
Definition: fs_evr.h:237

EvtFsFAT_UnmountDrive
#define EvtFsFAT_UnmountDrive
Definition: fs_evr.h:97

EvrFsEFS_MountDriveSuccess
__STATIC_INLINE void EvrFsEFS_MountDriveSuccess(uint32_t drive)
Event on successful EFS drive mount (Op)
Definition: fs_evr.h:2295

EvrFsMcSPI_BlenWriteError
__STATIC_INLINE void EvrFsMcSPI_BlenWriteError(uint32_t instance, uint32_t blen)
Event on failed block length setting (Error)
Definition: fs_evr.h:5471

EvtFsFAT_FileFind
#define EvtFsFAT_FileFind
Definition: fs_evr.h:158

EvtFsCore_finit
#define EvtFsCore_finit
Definition: fs_evr.h:43

EvrFsIOC_LockSuccess
__STATIC_INLINE void EvrFsIOC_LockSuccess(uint32_t drv_id)
Event on successful drive lock operation (Op)
Definition: fs_evr.h:3047

EvrFsFAT_PathBufferToSmall
__STATIC_INLINE void EvrFsFAT_PathBufferToSmall(uint32_t drive)
Event on directory/file path buffer size error (Error)
Definition: fs_evr.h:1639

EvtFsIOC_ReadSectorError
#define EvtFsIOC_ReadSectorError
Definition: fs_evr.h:248

EvrFsMcMCI_MediaReset
__STATIC_INLINE void EvrFsMcMCI_MediaReset(uint32_t instance)
Event on memory card device reset (Op)
Definition: fs_evr.h:4617

EvrFsMcMCI_MediaReady
__STATIC_INLINE void EvrFsMcMCI_MediaReady(uint32_t instance, uint32_t ocr)
Event on received response from SD memory card V2 (Op)
Definition: fs_evr.h:4654

EvtFsMcMCI_SendCommandError
#define EvtFsMcMCI_SendCommandError
Definition: fs_evr.h:408

EvtFsMcSPI_SectorRead
#define EvtFsMcSPI_SectorRead
Definition: fs_evr.h:439

EvrFsCore_fchdir
__STATIC_INLINE void EvrFsCore_fchdir(const char *path)
Event on working directory change (API)
Definition: fs_evr.h:688

EvtFsFAT_FileHandleError
#define EvtFsFAT_FileHandleError
Definition: fs_evr.h:135

EvrFsCore_InvalidDrive
__STATIC_INLINE void EvrFsCore_InvalidDrive(uint32_t drive)
Event on invalid or disabled drive specifier (Error)
Definition: fs_evr.h:837

EvrFsNFTL_ReadBootBlockFailed
__STATIC_INLINE void EvrFsNFTL_ReadBootBlockFailed(uint32_t instance)
Event on NFTL boot block error (Error)
Definition: fs_evr.h:3410

EvrFsFAT_SectorReadFailed
__STATIC_INLINE void EvrFsFAT_SectorReadFailed(uint32_t drive, uint32_t sector, uint32_t count)
Event on sector read error (Error)
Definition: fs_evr.h:1588

EvtFsEFS_FileInUse
#define EvtFsEFS_FileInUse
Definition: fs_evr.h:223

EvrFsMcMCI_WriteXferSetupError
__STATIC_INLINE void EvrFsMcMCI_WriteXferSetupError(uint32_t instance, uint8_t *buf, uint32_t cnt, uint32_t size)
Event on TransferSetup error for write operation (Op)
Definition: fs_evr.h:5176

EvtFsCore_ftime_get
#define EvtFsCore_ftime_get
Definition: fs_evr.h:68

EvtFsEFS_FileOpen
#define EvtFsEFS_FileOpen
Definition: fs_evr.h:192

EvtFsFAT_ClearRootSectors
#define EvtFsFAT_ClearRootSectors
Definition: fs_evr.h:111

EvrFsEFS_FlashWriteFailed
__STATIC_INLINE void EvrFsEFS_FlashWriteFailed(uint32_t drive, uint32_t addr, void *buf, uint32_t cnt)
Event on Flash driver write data error (Error)
Definition: fs_evr.h:2862

EvrFsNFTL_LsnFind
__STATIC_INLINE void EvrFsNFTL_LsnFind(uint32_t instance, uint32_t lsn, uint32_t pbn)
Event on search of logical sector within NAND block (Op)
Definition: fs_evr.h:3799

EvrFsMcMCI_InitDriverError
__STATIC_INLINE void EvrFsMcMCI_InitDriverError(uint32_t instance, uint32_t driver)
Event on memory card driver initialization error (Op)
Definition: fs_evr.h:4519

EvrFsMcSPI_MediaPasswordEnabled
__STATIC_INLINE void EvrFsMcSPI_MediaPasswordEnabled(uint32_t instance)
Event on detection of enabled media password protection (Error)
Definition: fs_evr.h:5804

EvtFsEFS_DiskFull
#define EvtFsEFS_DiskFull
Definition: fs_evr.h:228

EvrFsEFS_FileHandleInvalid
__STATIC_INLINE void EvrFsEFS_FileHandleInvalid(uint32_t h)
Event on invalid handle (Error)
Definition: fs_evr.h:2823

EvrFsFAT_WriteBootSector
__STATIC_INLINE void EvrFsFAT_WriteBootSector(uint32_t drive, uint32_t sector)
Event on Boot Sector write operation (Op)
Definition: fs_evr.h:1356

EvrFsNFTL_LoadDataLayout
__STATIC_INLINE void EvrFsNFTL_LoadDataLayout(uint32_t instance, uint32_t pbn_0, uint32_t pbn_1)
Event on file data layout configuration read (Detail)
Definition: fs_evr.h:4096

EvrFsFAT_NameCacheEntryFound
__STATIC_INLINE void EvrFsFAT_NameCacheEntryFound(uint32_t drive, uint32_t clus, uint32_t offs, uint32_t cnt)
Event on found file name entry in FAT name cache (Detail)
Definition: fs_evr.h:2113

EvtFsFAT_FileDeleteSuccess
#define EvtFsFAT_FileDeleteSuccess
Definition: fs_evr.h:142

EvrFsMcMCI_DataBusSwitchError
__STATIC_INLINE void EvrFsMcMCI_DataBusSwitchError(uint32_t instance)
Event on data bus width switch error (Error)
Definition: fs_evr.h:4799

EvrFsFAT_InvalidFAT
__STATIC_INLINE void EvrFsFAT_InvalidFAT(uint32_t drive)
Event on invalid FAT volume description (Error)
Definition: fs_evr.h:1122

EvrFsMcMCI_RcaReadError
__STATIC_INLINE void EvrFsMcMCI_RcaReadError(uint32_t instance)
Event on RCA (Relative Card Address) register read error (Error)
Definition: fs_evr.h:4714

EvrFsFAT_PathProcessing
__STATIC_INLINE void EvrFsFAT_PathProcessing(uint32_t drive, const char *path)
Event on FAT path processing (Op)
Definition: fs_evr.h:1526

EvrFsFAT_PathInvalidChar
__STATIC_INLINE void EvrFsFAT_PathInvalidChar(const char ch)
Event on invalid FAT path character (Error)
Definition: fs_evr.h:1453

EvtFsFAT_ReadMBR
#define EvtFsFAT_ReadMBR
Definition: fs_evr.h:84

EvtFsFAT_WriteMBR
#define EvtFsFAT_WriteMBR
Definition: fs_evr.h:107

EvtFsNFTL_Init
#define EvtFsNFTL_Init
Definition: fs_evr.h:262

EvtFsFAT_InvalidFreeClusFSInfo
#define EvtFsFAT_InvalidFreeClusFSInfo
Definition: fs_evr.h:92

EvrFsCore_fmkdir
__STATIC_INLINE void EvrFsCore_fmkdir(const char *path)
Event on directory create (API)
Definition: fs_evr.h:700

EvtFsFAT_InvalidFSInfo
#define EvtFsFAT_InvalidFSInfo
Definition: fs_evr.h:91

EvrFsFAT_InitJournalSuccess
__STATIC_INLINE void EvrFsFAT_InitJournalSuccess(uint32_t drive)
Event on successful FAT journal initialization (Op)
Definition: fs_evr.h:1663

EvtFsFAT_FileSeek
#define EvtFsFAT_FileSeek
Definition: fs_evr.h:139

EvrFsNAND_BlockErase
__STATIC_INLINE void EvrFsNAND_BlockErase(uint32_t instance, uint32_t row)
Event on NAND erase block operation (Op)
Definition: fs_evr.h:4423

EvtFsEFS_FreeSpaceAmount
#define EvtFsEFS_FreeSpaceAmount
Definition: fs_evr.h:210

EvtFsEFS_UnmountDriveSuccess
#define EvtFsEFS_UnmountDriveSuccess
Definition: fs_evr.h:185

EvrFsCore_sys_seek
__STATIC_INLINE void EvrFsCore_sys_seek(int fh, long pos)
Event on file position move (API)
Definition: fs_evr.h:525

EvtFsMcMCI_MediaDetectionError
#define EvtFsMcMCI_MediaDetectionError
Definition: fs_evr.h:372

EvtFsMcMCI_MediaNoResponse
#define EvtFsMcMCI_MediaNoResponse
Definition: fs_evr.h:370

EvrFsEFS_FlashProgUnitTooBig
__STATIC_INLINE void EvrFsEFS_FlashProgUnitTooBig(uint32_t drive, uint32_t current, uint32_t required)
Event on Flash program unit too big (Error)
Definition: fs_evr.h:2321

EvtFsFAT_FileModeRead
#define EvtFsFAT_FileModeRead
Definition: fs_evr.h:157

EvtFsCore_fpwd
#define EvtFsCore_fpwd
Definition: fs_evr.h:52

EvrFsEFS_FileClose
__STATIC_INLINE void EvrFsEFS_FileClose(uint32_t h)
Event on EFS file close (Op)
Definition: fs_evr.h:2484

EvrFsFAT_FileSeekIncrease
__STATIC_INLINE void EvrFsFAT_FileSeekIncrease(int32_t h, uint32_t csize, uint32_t nsize)
Event on FAT file increase using fseek (Op)
Definition: fs_evr.h:1767

EvrFsEFS_UninitDriver
__STATIC_INLINE void EvrFsEFS_UninitDriver(uint32_t drive, uint32_t driver)
Event on EFS driver uninitialization (Op)
Definition: fs_evr.h:2271

EvrFsNFTL_AllocatedBlock
__STATIC_INLINE void EvrFsNFTL_AllocatedBlock(uint32_t instance, uint32_t pbn)
Event on successful block allocation (Op)
Definition: fs_evr.h:4053

EvtFsCore_finfo
#define EvtFsCore_finfo
Definition: fs_evr.h:63

EvrFsNFTL_Uninit
__STATIC_INLINE void EvrFsNFTL_Uninit(uint32_t instance)
Event on NFTL device uninitialization (Op)
Definition: fs_evr.h:3483

EvtFsMcSPI_ParameterInvalid
#define EvtFsMcSPI_ParameterInvalid
Definition: fs_evr.h:461

EvtFsIOC_ReadSectorSuccess
#define EvtFsIOC_ReadSectorSuccess
Definition: fs_evr.h:247

EvtFsMcMCI_CsdReadError
#define EvtFsMcMCI_CsdReadError
Definition: fs_evr.h:376

EvtFsNFTL_LsnFind
#define EvtFsNFTL_LsnFind
Definition: fs_evr.h:301

EvrFsMcSPI_MediaDetectionSD
__STATIC_INLINE void EvrFsMcSPI_MediaDetectionSD(uint32_t instance)
Event on start of SD memory card detection operation (Op)
Definition: fs_evr.h:5373

EvtFsEFS_FileRead
#define EvtFsEFS_FileRead
Definition: fs_evr.h:197

EvtFsMcMCI_TransferError
#define EvtFsMcMCI_TransferError
Definition: fs_evr.h:390

EvrFsNFTL_BBMPositionSet
__STATIC_INLINE void EvrFsNFTL_BBMPositionSet(uint32_t instance, uint32_t pos)
Event on NFTL bad block position setting (Op)
Definition: fs_evr.h:3609

EvtFsEFS_FileName
#define EvtFsEFS_FileName
Definition: fs_evr.h:232

EvtFsEFS_FlashGetInfo
#define EvtFsEFS_FlashGetInfo
Definition: fs_evr.h:181

EvrFsCore_finfo
__STATIC_INLINE void EvrFsCore_finfo(const char *drive, fsDriveInfo *info)
Event on drive information read (API)
Definition: fs_evr.h:811

EvrFsFAT_FileOpen
__STATIC_INLINE void EvrFsFAT_FileOpen(uint32_t h, const char *path, uint32_t openmode)
Event on FAT file open (Op)
Definition: fs_evr.h:1441

EvtFsNFTL_LbnOutOfRange
#define EvtFsNFTL_LbnOutOfRange
Definition: fs_evr.h:296

EvtFsCore_fvol
#define EvtFsCore_fvol
Definition: fs_evr.h:64

EvrFsFAT_FileHandleUnavailable
__STATIC_INLINE void EvrFsFAT_FileHandleUnavailable(uint32_t drive)
Event on FAT file handle not available (Error)
Definition: fs_evr.h:1538

EvrFsNFTL_CacheRead
__STATIC_INLINE void EvrFsNFTL_CacheRead(uint32_t instance, uint32_t pbn, uint32_t pg, uint32_t col)
Event on page cache read (Op)
Definition: fs_evr.h:4210

EvrFsMcSPI_MediaCdInactive
__STATIC_INLINE void EvrFsMcSPI_MediaCdInactive(uint32_t instance)
Event on card detect switch check and media is not present (Op)
Definition: fs_evr.h:5313

EvrFsFAT_ResetHandles
__STATIC_INLINE void EvrFsFAT_ResetHandles(uint32_t drive)
Event on reset of all FAT file handles (Op)
Definition: fs_evr.h:1268

EvtFsNFTL_DeviceNotInitialized
#define EvtFsNFTL_DeviceNotInitialized
Definition: fs_evr.h:266

EvtFsEFS_MountDriveSuccess
#define EvtFsEFS_MountDriveSuccess
Definition: fs_evr.h:180

EvtFsMcMCI_HighSpeedSwitchError
#define EvtFsMcMCI_HighSpeedSwitchError
Definition: fs_evr.h:380

EvtFsMcMCI_InitDriver
#define EvtFsMcMCI_InitDriver
Definition: fs_evr.h:357

EvtFsFAT_InvalidNextClusFSInfo
#define EvtFsFAT_InvalidNextClusFSInfo
Definition: fs_evr.h:93

EvrFsMcSPI_LockActive
__STATIC_INLINE void EvrFsMcSPI_LockActive(uint32_t instance)
Event on active password protection status (Op)
Definition: fs_evr.h:5641

EvrFsFAT_InvalidNextClusFSInfo
__STATIC_INLINE void EvrFsFAT_InvalidNextClusFSInfo(uint32_t drive)
Event on invalid next free cluster in FAT FSInfo signature (Error)
Definition: fs_evr.h:1171

EvtFsMcMCI_InitMedia
#define EvtFsMcMCI_InitMedia
Definition: fs_evr.h:360

EvrFsMcMCI_MediaCdInactive
__STATIC_INLINE void EvrFsMcMCI_MediaCdInactive(uint32_t instance)
Event on card detect switch check and media is not present (Op)
Definition: fs_evr.h:4581

EvrFsNAND_DriverBusModeSelect
__STATIC_INLINE void EvrFsNAND_DriverBusModeSelect(uint32_t instance, uint32_t driver, uint32_t mode)
Event on NAND driver initialization error (Error)
Definition: fs_evr.h:4276

EvtFsFAT_UninitDrive
#define EvtFsFAT_UninitDrive
Definition: fs_evr.h:76

EvrFsCore_funmount
__STATIC_INLINE void EvrFsCore_funmount(const char *drive)
Event on drive unmount (API)
Definition: fs_evr.h:598

EvtFsFAT_InvalidFAT
#define EvtFsFAT_InvalidFAT
Definition: fs_evr.h:89

EvrFsFAT_PathName
__STATIC_INLINE void EvrFsFAT_PathName(const char *buf, uint32_t len)
Event on FAT path specification (Detail)
Definition: fs_evr.h:2044

EvrFsMcSPI_SectorRead
__STATIC_INLINE void EvrFsMcSPI_SectorRead(uint32_t instance, uint32_t sector, uint32_t count)
Event on sector read operation (Op)
Definition: fs_evr.h:5511

EvtFsFAT_VolumeReadyStatError
#define EvtFsFAT_VolumeReadyStatError
Definition: fs_evr.h:81

EvtFsFAT_UnmountDriveSuccess
#define EvtFsFAT_UnmountDriveSuccess
Definition: fs_evr.h:98

EvtFsFAT_AttribSetSuccess
#define EvtFsFAT_AttribSetSuccess
Definition: fs_evr.h:154

EvtFsFAT_FormatProperties
#define EvtFsFAT_FormatProperties
Definition: fs_evr.h:113

EvrFsMcSPI_CsdReadError
__STATIC_INLINE void EvrFsMcSPI_CsdReadError(uint32_t instance)
Event on CSD register read error (Error)
Definition: fs_evr.h:5458

EvrFsMcSPI_MediaWpActive
__STATIC_INLINE void EvrFsMcSPI_MediaWpActive(uint32_t instance)
Event on active write protection switch (Op)
Definition: fs_evr.h:5325

EvrFsEFS_InvalidParameter
__STATIC_INLINE void EvrFsEFS_InvalidParameter(uint32_t drive)
Event on EFS invalid function parameter error (Error)
Definition: fs_evr.h:2918

EvtFsMcSPI_DevCtrl
#define EvtFsMcSPI_DevCtrl
Definition: fs_evr.h:445

EvrFsEFS_FileRename
__STATIC_INLINE void EvrFsEFS_FileRename(uint32_t drive, const char *path, const char *newname)
Event on EFS file rename (Op)
Definition: fs_evr.h:2628

EvtFsEFS_InvalidParameter
#define EvtFsEFS_InvalidParameter
Definition: fs_evr.h:229

EvrFsCore_frmdir
__STATIC_INLINE void EvrFsCore_frmdir(const char *path, const char *options)
Event on directory remove (API)
Definition: fs_evr.h:713

EvtFsEFS_UninitDrive
#define EvtFsEFS_UninitDrive
Definition: fs_evr.h:177

EvrFsFAT_ChDir
__STATIC_INLINE void EvrFsFAT_ChDir(uint32_t drive, const char *path)
Event on FAT current directory change (Op)
Definition: fs_evr.h:1888

EvtFsFAT_FormatDrive
#define EvtFsFAT_FormatDrive
Definition: fs_evr.h:99

EvtFsNFTL_Mount
#define EvtFsNFTL_Mount
Definition: fs_evr.h:264

EvtFsIOC_DeviceControl
#define EvtFsIOC_DeviceControl
Definition: fs_evr.h:255

EvrFsNFTL_BlockErase
__STATIC_INLINE void EvrFsNFTL_BlockErase(uint32_t instance, uint32_t pbn)
Event on block erase (Op)
Definition: fs_evr.h:4168

EvrFsNAND_DeviceReset
__STATIC_INLINE void EvrFsNAND_DeviceReset(uint32_t instance)
Event on NAND device reset operation (Op)
Definition: fs_evr.h:4493

EvtFsEFS_FileHandleInvalid
#define EvtFsEFS_FileHandleInvalid
Definition: fs_evr.h:222

EvrFsMcSPI_LockUnlockExecError
__STATIC_INLINE void EvrFsMcSPI_LockUnlockExecError(uint32_t instance)
Event on Lock/Unlock command execution error (Error)
Definition: fs_evr.h:5629

EvrFsFAT_NameCacheEntryInsert
__STATIC_INLINE void EvrFsFAT_NameCacheEntryInsert(uint32_t drive, uint32_t clus, uint32_t offs, uint32_t cnt)
Event on FAT name cache entry insert (Detail)
Definition: fs_evr.h:2128

EvtFsCore_sys_read
#define EvtFsCore_sys_read
Definition: fs_evr.h:39

EvrFsMcSPI_SectorWrite
__STATIC_INLINE void EvrFsMcSPI_SectorWrite(uint32_t instance, uint32_t sector, uint32_t count)
Event on sector write operation (Op)
Definition: fs_evr.h:5539

EvtFsIOC_LockSuccess
#define EvtFsIOC_LockSuccess
Definition: fs_evr.h:241

EvtFsMcMCI_LockActive
#define EvtFsMcMCI_LockActive
Definition: fs_evr.h:398

EvrFsNFTL_ReadInfoSuccess
__STATIC_INLINE void EvrFsNFTL_ReadInfoSuccess(uint32_t instance, uint32_t sect_count)
Event on succesful media capacity retrieval (Op)
Definition: fs_evr.h:3533

EvrFsMcSPI_ACmdResponseError
__STATIC_INLINE void EvrFsMcSPI_ACmdResponseError(uint32_t instance, uint32_t cmd)
Event on missing or invalid application command response (Error)
Definition: fs_evr.h:5780

EvtFsCore_fdefrag
#define EvtFsCore_fdefrag
Definition: fs_evr.h:61

EvtFsIOC_UnlockSuccess
#define EvtFsIOC_UnlockSuccess
Definition: fs_evr.h:243

EvtFsFAT_PwdSuccess
#define EvtFsFAT_PwdSuccess
Definition: fs_evr.h:152

EvrFsIOC_ReadSector
__STATIC_INLINE void EvrFsIOC_ReadSector(uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt)
Event on call of fs_ioc_read_sector function (API)
Definition: fs_evr.h:3113

EvrFsMcMCI_LockDeactivated
__STATIC_INLINE void EvrFsMcMCI_LockDeactivated(uint32_t instance)
Event on deactivated password protection status (Op)
Definition: fs_evr.h:5031

EvrFsNAND_Init
__STATIC_INLINE void EvrFsNAND_Init(uint32_t instance)
Event on NAND media layer initialization (Op)
Definition: fs_evr.h:4222

EvtFsNFTL_LoadSector
#define EvtFsNFTL_LoadSector
Definition: fs_evr.h:321

EvtFsEFS_FileIdInvalid
#define EvtFsEFS_FileIdInvalid
Definition: fs_evr.h:216

EvtFsFAT_NameCacheEntryDelete
#define EvtFsFAT_NameCacheEntryDelete
Definition: fs_evr.h:168

EvrFsNFTL_Mount
__STATIC_INLINE void EvrFsNFTL_Mount(uint32_t instance)
Event on NFTL mount (Op)
Definition: fs_evr.h:3326

EvtFsFAT_InitDrive
#define EvtFsFAT_InitDrive
Definition: fs_evr.h:72

EvrFsNAND_PageRead
__STATIC_INLINE void EvrFsNAND_PageRead(uint32_t instance, uint32_t row, uint32_t col, uint32_t len)
Event on NAND page read operation (Op)
Definition: fs_evr.h:4453

EvrFsMcSPI_MediaWpInactive
__STATIC_INLINE void EvrFsMcSPI_MediaWpInactive(uint32_t instance)
Event on inactive write protection switch (Op)
Definition: fs_evr.h:5337

EvrFsFAT_FormatProperties
__STATIC_INLINE void EvrFsFAT_FormatProperties(uint32_t drive, uint32_t type, uint32_t clus_size, uint32_t data_clus)
Event on setting FAT format properties (Op)
Definition: fs_evr.h:1427

EvtFsMcSPI_ReadInfo
#define EvtFsMcSPI_ReadInfo
Definition: fs_evr.h:443

EvtFsEFS_FlashReadFailed
#define EvtFsEFS_FlashReadFailed
Definition: fs_evr.h:225

EvrFsEFS_FlashEraseSectors
__STATIC_INLINE void EvrFsEFS_FlashEraseSectors(uint32_t drive, uint32_t sector, uint32_t cnt)
Event on Flash sectors erase operation (Op)
Definition: fs_evr.h:2432

EvtFsMcMCI_DevCtrlUnsupported
#define EvtFsMcMCI_DevCtrlUnsupported
Definition: fs_evr.h:395

EvrFsMcSPI_MediaDetectionMMC
__STATIC_INLINE void EvrFsMcSPI_MediaDetectionMMC(uint32_t instance)
Event on start of MMC/eMMC device detection procedure (Op)
Definition: fs_evr.h:5422

EvtFsIOC_WriteSectorSuccess
#define EvtFsIOC_WriteSectorSuccess
Definition: fs_evr.h:250

EvtFsFAT_FileRenameSuccess
#define EvtFsFAT_FileRenameSuccess
Definition: fs_evr.h:144

EvrFsIOC_UnlockSuccess
__STATIC_INLINE void EvrFsIOC_UnlockSuccess(uint32_t drv_id)
Event on successful drive unlock operation (Op)
Definition: fs_evr.h:3071

EvtFsIOC_GetCacheSuccess
#define EvtFsIOC_GetCacheSuccess
Definition: fs_evr.h:245

EvtFsEFS_FlashEraseChip
#define EvtFsEFS_FlashEraseChip
Definition: fs_evr.h:188

EvrFsEFS_FlashReadFailed
__STATIC_INLINE void EvrFsEFS_FlashReadFailed(uint32_t drive, uint32_t addr, void *buf, uint32_t cnt)
Event on Flash driver read data error (Error)
Definition: fs_evr.h:2877

EvrFsMcMCI_TranStateError
__STATIC_INLINE void EvrFsMcMCI_TranStateError(uint32_t instance)
Event on failed switch to TRAN state (Error)
Definition: fs_evr.h:4750

EvtFsMcSPI_CmdResponseError
#define EvtFsMcSPI_CmdResponseError
Definition: fs_evr.h:459

EvtFsNAND_DeviceTimeoutError
#define EvtFsNAND_DeviceTimeoutError
Definition: fs_evr.h:346

EvtFsCore_fcheck
#define EvtFsCore_fcheck
Definition: fs_evr.h:60

EvtFsFAT_LabelInvalid
#define EvtFsFAT_LabelInvalid
Definition: fs_evr.h:124

EvrFsMcMCI_UninitDriver
__STATIC_INLINE void EvrFsMcMCI_UninitDriver(uint32_t instance, uint32_t driver)
Event on MCI driver uninitialization (Op)
Definition: fs_evr.h:4836

EvrFsMcMCI_ParameterInvalid
__STATIC_INLINE void EvrFsMcMCI_ParameterInvalid(uint32_t instance)
Event on invalid function parameter(s) (Error)
Definition: fs_evr.h:5188

EvrFsMcMCI_SectorReadError
__STATIC_INLINE void EvrFsMcMCI_SectorReadError(uint32_t instance, uint32_t sector, uint32_t count)
Event on sector read operation error (Op)
Definition: fs_evr.h:4877

EvtFsCore_ffree
#define EvtFsCore_ffree
Definition: fs_evr.h:57

EvtFsCore_fchdrive
#define EvtFsCore_fchdrive
Definition: fs_evr.h:56

EvrFsMcMCI_BlenWriteError
__STATIC_INLINE void EvrFsMcMCI_BlenWriteError(uint32_t instance, uint32_t blen)
Event on failed block length setting (Error)
Definition: fs_evr.h:4763

EvtFsNFTL_PageReadFailed
#define EvtFsNFTL_PageReadFailed
Definition: fs_evr.h:310

EvrFsNFTL_UninitDriverFailed
__STATIC_INLINE void EvrFsNFTL_UninitDriverFailed(uint32_t instance)
Event on NFTL driver uninitialization error (Error)
Definition: fs_evr.h:3507

EvrFsFAT_GetFreeSpace
__STATIC_INLINE void EvrFsFAT_GetFreeSpace(uint32_t drive)
Event on FAT free space retrieve request (Op)
Definition: fs_evr.h:1969

rl_fs.h

EvrFsMcMCI_MediaNotInitialized
__STATIC_INLINE void EvrFsMcMCI_MediaNotInitialized(uint32_t instance)
Event on using uninitialized memory card device (Error)
Definition: fs_evr.h:4557

EvrFsNFTL_PageProgramStatusErr
__STATIC_INLINE void EvrFsNFTL_PageProgramStatusErr(uint32_t instance, uint32_t row)
Event on invalid page program status value (Error)
Definition: fs_evr.h:3935

EvtFsIOC_ReadSector
#define EvtFsIOC_ReadSector
Definition: fs_evr.h:246

EvrFsCore_fattrib
__STATIC_INLINE void EvrFsCore_fattrib(const char *path, const char *attr)
Event on file or directory attribute change (API)
Definition: fs_evr.h:662

EvtFsEFS_FileOpenWriteMode
#define EvtFsEFS_FileOpenWriteMode
Definition: fs_evr.h:198

EvtFsFAT_MountDrive
#define EvtFsFAT_MountDrive
Definition: fs_evr.h:77

EvtFsEFS_FileSeek
#define EvtFsEFS_FileSeek
Definition: fs_evr.h:203

EvrFsMcMCI_InitMedia
__STATIC_INLINE void EvrFsMcMCI_InitMedia(uint32_t instance)
Event on memory card device initialization (Op)
Definition: fs_evr.h:4545

EvtFsCore_fmount
#define EvtFsCore_fmount
Definition: fs_evr.h:45

EvtFsFAT_FileOpen
#define EvtFsFAT_FileOpen
Definition: fs_evr.h:114

EvtFsMcSPI_MediaReset
#define EvtFsMcSPI_MediaReset
Definition: fs_evr.h:426

EvtFsEFS_MountDrive
#define EvtFsEFS_MountDrive
Definition: fs_evr.h:179

EvrFsMcSPI_MediaReset
__STATIC_INLINE void EvrFsMcSPI_MediaReset(uint32_t instance)
Event on start of memory card device reset operation (Op)
Definition: fs_evr.h:5349

EvrFsMcMCI_SleepActive
__STATIC_INLINE void EvrFsMcMCI_SleepActive(uint32_t instance)
Event on SLEEP mode active status (Op)
Definition: fs_evr.h:5107

EvrFsNFTL_DevCtrlUnsupported
__STATIC_INLINE void EvrFsNFTL_DevCtrlUnsupported(uint32_t instance, uint32_t code)
Event on NFTL device control code unsupported error (Error)
Definition: fs_evr.h:3560

EvrFsFAT_NameCacheEntryDelete
__STATIC_INLINE void EvrFsFAT_NameCacheEntryDelete(uint32_t drive, uint32_t clus, uint32_t offs, uint32_t cnt)
Event on FAT name cache entry delete (Detail)
Definition: fs_evr.h:2143

EvrFsFAT_SectorWriteFailed
__STATIC_INLINE void EvrFsFAT_SectorWriteFailed(uint32_t drive, uint32_t sector, uint32_t count)
Event on sector write error (Error)
Definition: fs_evr.h:1602

EvrFsNFTL_InitMediaFailed
__STATIC_INLINE void EvrFsNFTL_InitMediaFailed(uint32_t instance)
Event on NFTL memory media initialization error (Error)
Definition: fs_evr.h:3314

EvrFsFAT_PwdSuccess
__STATIC_INLINE void EvrFsFAT_PwdSuccess(uint32_t drive, const char *path, uint32_t len)
Event on successful FAT current directory print (Op)
Definition: fs_evr.h:1929

EvtFsNFTL_RelocateBlock
#define EvtFsNFTL_RelocateBlock
Definition: fs_evr.h:307

EvtFsFAT_ClearReservedSectors
#define EvtFsFAT_ClearReservedSectors
Definition: fs_evr.h:110

EvrFsNFTL_StatusRead
__STATIC_INLINE void EvrFsNFTL_StatusRead(uint32_t instance, uint32_t status)
Event on status read (Op)
Definition: fs_evr.h:4181

EvtFsNAND_DriverBusWidthSelect
#define EvtFsNAND_DriverBusWidthSelect
Definition: fs_evr.h:339

EvtFsMcMCI_MediaPasswordEnabled
#define EvtFsMcMCI_MediaPasswordEnabled
Definition: fs_evr.h:412

EvrFsEFS_FileOpenReadMode
__STATIC_INLINE void EvrFsEFS_FileOpenReadMode(uint32_t h)
Event on EFS when writing to read only file (Error)
Definition: fs_evr.h:2549

EvrFsFAT_MediaInitStatError
__STATIC_INLINE void EvrFsFAT_MediaInitStatError(uint32_t drive)
Event on FAT media init status error (Error)
Definition: fs_evr.h:1012

EvrFsIOC_GetCache
__STATIC_INLINE void EvrFsIOC_GetCache(uint32_t drv_id, uint32_t cache_info)
Event on call of fs_ioc_get_cache function (API)
Definition: fs_evr.h:3084

EvtFsNFTL_PageProgramFailed
#define EvtFsNFTL_PageProgramFailed
Definition: fs_evr.h:312

EvrFsNAND_IdRead
__STATIC_INLINE void EvrFsNAND_IdRead(uint32_t instance, uint32_t addr, uint32_t len)
Event on NAND device ID read operation (Op)
Definition: fs_evr.h:4481

EvrFsNFTL_AllocateBlock
__STATIC_INLINE void EvrFsNFTL_AllocateBlock(uint32_t instance, uint32_t area)
Event on NAND block allocation operation (Op)
Definition: fs_evr.h:3785

EvrFsNFTL_MoveData
__STATIC_INLINE void EvrFsNFTL_MoveData(uint32_t instance, uint32_t src, uint32_t dst)
Event on block content move (Op)
Definition: fs_evr.h:3870

EvrFsMcMCI_DeviceStateUnknown
__STATIC_INLINE void EvrFsMcMCI_DeviceStateUnknown(uint32_t instance, uint32_t state)
Event on discovery of unknown device state (Error)
Definition: fs_evr.h:5044

EvtFsFAT_SectorWriteFailed
#define EvtFsFAT_SectorWriteFailed
Definition: fs_evr.h:127

EvtFsFAT_NameCacheEntryFound
#define EvtFsFAT_NameCacheEntryFound
Definition: fs_evr.h:166

EvtFsMcSPI_MediaDetectionError
#define EvtFsMcSPI_MediaDetectionError
Definition: fs_evr.h:433

EvrFsMcMCI_AwakeActive
__STATIC_INLINE void EvrFsMcMCI_AwakeActive(uint32_t instance)
Event on AWAKE mode active status (Op)
Definition: fs_evr.h:5119

EvtFsEFS_FileWrite
#define EvtFsEFS_FileWrite
Definition: fs_evr.h:199

EvtFsEFS_FileClose
#define EvtFsEFS_FileClose
Definition: fs_evr.h:195

EvtFsFAT_TimeGet
#define EvtFsFAT_TimeGet
Definition: fs_evr.h:170

EvrFsNFTL_WriteSectorSuccess
__STATIC_INLINE void EvrFsNFTL_WriteSectorSuccess(uint32_t instance)
Event on successful NFTL write sector operation (Op)
Definition: fs_evr.h:3662

EvrFsNFTL_ResetDevice
__STATIC_INLINE void EvrFsNFTL_ResetDevice(uint32_t instance)
Event on NAND device reset (Op)
Definition: fs_evr.h:3362

EvrFsFAT_FormatDrive
__STATIC_INLINE void EvrFsFAT_FormatDrive(uint32_t drive)
Event on FAT drive format operation (Op)
Definition: fs_evr.h:1244

EvrFsMcSPI_SectorReadError
__STATIC_INLINE void EvrFsMcSPI_SectorReadError(uint32_t instance, uint32_t sector, uint32_t count)
Event on sector read operation error (Op)
Definition: fs_evr.h:5525

EvtFsMcSPI_ReadCdMissing
#define EvtFsMcSPI_ReadCdMissing
Definition: fs_evr.h:453

EvtFsFAT_NameCacheEntryInsert
#define EvtFsFAT_NameCacheEntryInsert
Definition: fs_evr.h:167

EvrFsNAND_DriverBusWidthError
__STATIC_INLINE void EvrFsNAND_DriverBusWidthError(uint32_t instance, uint32_t driver, uint32_t width)
Event on NAND driver initialization error (Error)
Definition: fs_evr.h:4304

EvtFsNFTL_StatusRead
#define EvtFsNFTL_StatusRead
Definition: fs_evr.h:329

EvrFsEFS_FileHandleActive
__STATIC_INLINE void EvrFsEFS_FileHandleActive(uint32_t drive, uint32_t h)
Event (Error)
Definition: fs_evr.h:2799

EvtFsMcSPI_CmdSendError
#define EvtFsMcSPI_CmdSendError
Definition: fs_evr.h:458

EvtFsNFTL_AllocatedBlock
#define EvtFsNFTL_AllocatedBlock
Definition: fs_evr.h:320

EvtFsCore_fdelete
#define EvtFsCore_fdelete
Definition: fs_evr.h:48

EvtFsCore_sys_write
#define EvtFsCore_sys_write
Definition: fs_evr.h:38

EvrFsFAT_InitDriverCfgError
__STATIC_INLINE void EvrFsFAT_InitDriverCfgError(uint32_t drive)
Event on FAT driver configuration error (Error)
Definition: fs_evr.h:940

EvtFsMcMCI_ReadXferSetupError
#define EvtFsMcMCI_ReadXferSetupError
Definition: fs_evr.h:409

EvrFsNFTL_LoadTableLayout
__STATIC_INLINE void EvrFsNFTL_LoadTableLayout(uint32_t instance, uint32_t pbn_0, uint32_t pbn_1)
Event on translation table layout configuration read (Detail)
Definition: fs_evr.h:4082

EvrFsMcMCI_DevCtrlUnsupported
__STATIC_INLINE void EvrFsMcMCI_DevCtrlUnsupported(uint32_t instance, uint32_t code)
Event on memory card device control code unsupported error (Error)
Definition: fs_evr.h:4983

EvrFsFAT_FileIsNonExistent
__STATIC_INLINE void EvrFsFAT_FileIsNonExistent(uint32_t drive)
Event on specification of nonexistent FAT file (Error)
Definition: fs_evr.h:1513

EvrFsCore_fvol
__STATIC_INLINE void EvrFsCore_fvol(const char *drive, char *label, uint32_t *serial)
Event on drive label and serial number read (API)
Definition: fs_evr.h:825

EvtFsMcSPI_LockActive
#define EvtFsMcSPI_LockActive
Definition: fs_evr.h:449

EvrFsMcMCI_CsdReadError
__STATIC_INLINE void EvrFsMcMCI_CsdReadError(uint32_t instance)
Event on CSD register read error (Error)
Definition: fs_evr.h:4738

EvtFsCore_fanalyse
#define EvtFsCore_fanalyse
Definition: fs_evr.h:59

EvrFsMcSPI_InitMediaSuccess
__STATIC_INLINE void EvrFsMcSPI_InitMediaSuccess(uint32_t instance)
Event on successful memory card device initialization (Op)
Definition: fs_evr.h:5277

EvtFsMcSPI_SectorReadError
#define EvtFsMcSPI_SectorReadError
Definition: fs_evr.h:440

EvtFsEFS_FileFlush
#define EvtFsEFS_FileFlush
Definition: fs_evr.h:201

EvtFsCore_frename
#define EvtFsCore_frename
Definition: fs_evr.h:50

fsTime::mon
uint8_t mon
Month [1..12].
Definition: rl_fs.h:137

EvtFsFAT_VolumeNotMounted
#define EvtFsFAT_VolumeNotMounted
Definition: fs_evr.h:83

EvtFsNFTL_LsnFound
#define EvtFsNFTL_LsnFound
Definition: fs_evr.h:302

EvrFsFAT_MediaInsertStatError
__STATIC_INLINE void EvrFsFAT_MediaInsertStatError(uint32_t drive)
Event on FAT media not present status error (Error)
Definition: fs_evr.h:1000

EvtFsFAT_FileWrite
#define EvtFsFAT_FileWrite
Definition: fs_evr.h:137

EvrFsFAT_FileFind
__STATIC_INLINE void EvrFsFAT_FileFind(int32_t h)
Event on FAT file find operation (Op)
Definition: fs_evr.h:2007

EvtFsFAT_InitDriverCfgError
#define EvtFsFAT_InitDriverCfgError
Definition: fs_evr.h:74

EvrFsNFTL_CacheWrite
__STATIC_INLINE void EvrFsNFTL_CacheWrite(uint32_t instance, uint32_t pbn, uint32_t pg)
Event on page cache write (Op)
Definition: fs_evr.h:4195

EvtFsEFS_DriveNotMounted
#define EvtFsEFS_DriveNotMounted
Definition: fs_evr.h:230

EvrFsIOC_ReadInfoError
__STATIC_INLINE void EvrFsIOC_ReadInfoError(uint32_t drv_id)
Event on read info operation error (Error)
Definition: fs_evr.h:3226

EvtFsMcSPI_ReadInfoSuccess
#define EvtFsMcSPI_ReadInfoSuccess
Definition: fs_evr.h:444

EvtFsNFTL_TableLookup
#define EvtFsNFTL_TableLookup
Definition: fs_evr.h:298

EvtFsNAND_PageWrite
#define EvtFsNAND_PageWrite
Definition: fs_evr.h:350

EvrFsEFS_FileOpen
__STATIC_INLINE void EvrFsEFS_FileOpen(uint32_t h, const char *path, uint32_t openmode)
Event on EFS file open (Op)
Definition: fs_evr.h:2446

EvrFsNFTL_LbnOutOfRange
__STATIC_INLINE void EvrFsNFTL_LbnOutOfRange(uint32_t instance, uint32_t lbn, uint32_t max)
Event when logical block number is out of range (Error)
Definition: fs_evr.h:3732

EvrFsMcSPI_ReadInfoSuccess
__STATIC_INLINE void EvrFsMcSPI_ReadInfoSuccess(uint32_t instance, uint32_t sect_count)
Event on media capacity retrieval operation (Op)
Definition: fs_evr.h:5578

EvtFsMcSPI_MediaSD_V2
#define EvtFsMcSPI_MediaSD_V2
Definition: fs_evr.h:429

EvtFsEFS_FileNotFound
#define EvtFsEFS_FileNotFound
Definition: fs_evr.h:207

EvtFsMcMCI_MediaWpInactive
#define EvtFsMcMCI_MediaWpInactive
Definition: fs_evr.h:365

EvtFsEFS_DriveDefrag
#define EvtFsEFS_DriveDefrag
Definition: fs_evr.h:219

EvtFsNAND_StatusRead
#define EvtFsNAND_StatusRead
Definition: fs_evr.h:348

EvtFsFAT_ResetHandles
#define EvtFsFAT_ResetHandles
Definition: fs_evr.h:101

EvrFsIOC_NotAllowed
__STATIC_INLINE void EvrFsIOC_NotAllowed(uint32_t drive)
Event on specifying drive without IOC support (Error)
Definition: fs_evr.h:3290

EvrFsIOC_GetIdError
__STATIC_INLINE void EvrFsIOC_GetIdError(uint32_t drive)
Event on invalid or nonexisting drive specifier (Error)
Definition: fs_evr.h:3023

EvtFsMcMCI_SectorWriteError
#define EvtFsMcMCI_SectorWriteError
Definition: fs_evr.h:389

EvtFsNFTL_SetupPageLayout
#define EvtFsNFTL_SetupPageLayout
Definition: fs_evr.h:324

EvtFsNFTL_Format
#define EvtFsNFTL_Format
Definition: fs_evr.h:284

EvtFsNFTL_ReadBootBlock
#define EvtFsNFTL_ReadBootBlock
Definition: fs_evr.h:270

fsDriveInfo
Drive information.
Definition: rl_fs.h:151

EvtFsEFS_DriveCheck
#define EvtFsEFS_DriveCheck
Definition: fs_evr.h:213

EvtFsNFTL_AllocateBlock
#define EvtFsNFTL_AllocateBlock
Definition: fs_evr.h:300

EvtFsFAT_MountDriveSuccess
#define EvtFsFAT_MountDriveSuccess
Definition: fs_evr.h:96

EvtFsNFTL_FormatLLEB
#define EvtFsNFTL_FormatLLEB
Definition: fs_evr.h:286

EvrFsIOC_GetId
__STATIC_INLINE void EvrFsIOC_GetId(uint32_t drive)
Event on call of fs_ioc_get_id function (API)
Definition: fs_evr.h:2998

EvrFsMcSPI_MediaNotInitialized
__STATIC_INLINE void EvrFsMcSPI_MediaNotInitialized(uint32_t instance)
Event on using uninitialized memory card device (Error)
Definition: fs_evr.h:5289

EvrFsFAT_AttribSetSuccess
__STATIC_INLINE void EvrFsFAT_AttribSetSuccess(uint32_t drive, const char *path, uint32_t attrib)
Event on successful FAT attribute setting (Op)
Definition: fs_evr.h:1957

EvrFsFAT_FileHandleInvalid
__STATIC_INLINE void EvrFsFAT_FileHandleInvalid(uint32_t h)
Event on invalid FAT file handle number (Error)
Definition: fs_evr.h:1550

EvtFsEFS_AllocationOrderInvalid
#define EvtFsEFS_AllocationOrderInvalid
Definition: fs_evr.h:217

EvrFsFAT_FormatNoSpace
__STATIC_INLINE void EvrFsFAT_FormatNoSpace(uint32_t drive)
Event on not enough free space for FAT12/16 format (Error)
Definition: fs_evr.h:1318

EvrFsMcMCI_MediaWpActive
__STATIC_INLINE void EvrFsMcMCI_MediaWpActive(uint32_t instance)
Event on active write protection switch (Op)
Definition: fs_evr.h:4593

fsTime::day
uint8_t day
Day [1..31].
Definition: rl_fs.h:136

EvtFsCore_fformat
#define EvtFsCore_fformat
Definition: fs_evr.h:58

EvtFsIOC_DriveNotFAT
#define EvtFsIOC_DriveNotFAT
Definition: fs_evr.h:258

EvtFsNFTL_MountSuccess
#define EvtFsNFTL_MountSuccess
Definition: fs_evr.h:265

EvrFsFAT_DirCreate
__STATIC_INLINE void EvrFsFAT_DirCreate(uint32_t drive, const char *path)
Event on FAT directory create (Op)
Definition: fs_evr.h:1834

EvrFsIOC_Lock
__STATIC_INLINE void EvrFsIOC_Lock(uint32_t drv_id)
Event on call of fs_ioc_lock function (API)
Definition: fs_evr.h:3035

EvtFsNFTL_PageRead
#define EvtFsNFTL_PageRead
Definition: fs_evr.h:327

EvrFsNFTL_RelocateBlockFailed
__STATIC_INLINE void EvrFsNFTL_RelocateBlockFailed(uint32_t instance, uint32_t pbn)
Event on failed attempt to change block physical location (Error)
Definition: fs_evr.h:3896

EvtFsMcMCI_ReadInfoSuccess
#define EvtFsMcMCI_ReadInfoSuccess
Definition: fs_evr.h:393

EvrFsFAT_InitDriverError
__STATIC_INLINE void EvrFsFAT_InitDriverError(uint32_t drive)
Event on FAT driver initialization error (Error)
Definition: fs_evr.h:952

EvtFsMcSPI_UninitDriver
#define EvtFsMcSPI_UninitDriver
Definition: fs_evr.h:437

EvrFsFAT_FormatNoSpaceFAT32
__STATIC_INLINE void EvrFsFAT_FormatNoSpaceFAT32(uint32_t drive)
Event on not enough free space for FAT32 format (Error)
Definition: fs_evr.h:1330

EvtFsFAT_Pwd
#define EvtFsFAT_Pwd
Definition: fs_evr.h:151

EvrFsNFTL_ReadBootBlock
__STATIC_INLINE void EvrFsNFTL_ReadBootBlock(uint32_t instance)
Event on NFTL boot block read (Op)
Definition: fs_evr.h:3398

EvtFsEFS_InitDrive
#define EvtFsEFS_InitDrive
Definition: fs_evr.h:174

EvrFsEFS_DriveAnalyze
__STATIC_INLINE void EvrFsEFS_DriveAnalyze(uint32_t drive)
Event on EFS drive analyze (Op)
Definition: fs_evr.h:2689

EvrFsEFS_DiskFull
__STATIC_INLINE void EvrFsEFS_DiskFull(uint32_t drive)
Event on out of free space on EFS drive (Error)
Definition: fs_evr.h:2847

EvrFsMcMCI_StbyStateError
__STATIC_INLINE void EvrFsMcMCI_StbyStateError(uint32_t instance)
Event on STBY state switch error (Error)
Definition: fs_evr.h:4811

EvrFsNFTL_BadBlockDetected
__STATIC_INLINE void EvrFsNFTL_BadBlockDetected(uint32_t instance, uint32_t block)
Event on NFTL bad block detection (Op)
Definition: fs_evr.h:3622

EvtFsFAT_FormatMediaCapacity
#define EvtFsFAT_FormatMediaCapacity
Definition: fs_evr.h:103

EvrFsCore_ffind
__STATIC_INLINE void EvrFsCore_ffind(const char *pattern, fsFileInfo *info)
Event on file or directory search (API)
Definition: fs_evr.h:636

EvrFsFAT_InvalidFreeClusFSInfo
__STATIC_INLINE void EvrFsFAT_InvalidFreeClusFSInfo(uint32_t drive)
Event on invalid number of free clusters in FAT FSInfo signature (Error)
Definition: fs_evr.h:1159

EvrFsIOC_DeviceControlSuccess
__STATIC_INLINE void EvrFsIOC_DeviceControlSuccess(uint32_t drv_id, uint32_t code, uint32_t p)
Event on call of fs_ioc_read_info function (API)
Definition: fs_evr.h:3254

EvtFsNFTL_ReadInfo
#define EvtFsNFTL_ReadInfo
Definition: fs_evr.h:280

EvrFsEFS_FileIdInvalid
__STATIC_INLINE void EvrFsEFS_FileIdInvalid(uint32_t drive)
Event on EFS invalid file ID detection (Error)
Definition: fs_evr.h:2750

EvtFsMcMCI_MediaDetectionSD
#define EvtFsMcMCI_MediaDetectionSD
Definition: fs_evr.h:367

EvtFsNFTL_BadBlockMark
#define EvtFsNFTL_BadBlockMark
Definition: fs_evr.h:289

EvrFsFAT_OptionsString
__STATIC_INLINE void EvrFsFAT_OptionsString(const char *buf, uint32_t len)
Event on FAT options specification (Detail)
Definition: fs_evr.h:2057

EvtFsFAT_PathInvalidChar
#define EvtFsFAT_PathInvalidChar
Definition: fs_evr.h:115

EvtFsMcMCI_CidReadError
#define EvtFsMcMCI_CidReadError
Definition: fs_evr.h:373

EvrFsEFS_FileWrite
__STATIC_INLINE void EvrFsEFS_FileWrite(uint32_t h, const uint8_t *buf, uint32_t len)
Event on EFS file write (Op)
Definition: fs_evr.h:2537

EvrFsMcMCI_SectorWriteError
__STATIC_INLINE void EvrFsMcMCI_SectorWriteError(uint32_t instance, uint32_t sector, uint32_t count)
Event on sector write operation error (Op)
Definition: fs_evr.h:4905

fsTime
File System Time structure.
Definition: rl_fs.h:132

EvtFsFAT_ChDirSuccess
#define EvtFsFAT_ChDirSuccess
Definition: fs_evr.h:150

EvtFsMcMCI_UninitMedia
#define EvtFsMcMCI_UninitMedia
Definition: fs_evr.h:385

EvtFsNFTL_PageWrite
#define EvtFsNFTL_PageWrite
Definition: fs_evr.h:326

EvrFsFAT_InitDriveSuccess
__STATIC_INLINE void EvrFsFAT_InitDriveSuccess(uint32_t drive)
Event on successful FAT drive initialization (Op)
Definition: fs_evr.h:928

EvtFsMcSPI_CrcDisableError
#define EvtFsMcSPI_CrcDisableError
Definition: fs_evr.h:455

EvtFsCore_funinit
#define EvtFsCore_funinit
Definition: fs_evr.h:44

EvtFsEFS_FlashReadTimeout
#define EvtFsEFS_FlashReadTimeout
Definition: fs_evr.h:226

EvrFsFAT_Pwd
__STATIC_INLINE void EvrFsFAT_Pwd(uint32_t drive, const char *path, uint32_t len)
Event on FAT current directory print (Op)
Definition: fs_evr.h:1915

EvtFsMcSPI_InitMedia
#define EvtFsMcSPI_InitMedia
Definition: fs_evr.h:419

EvrFsNFTL_TableLookup
__STATIC_INLINE void EvrFsNFTL_TableLookup(uint32_t instance, uint32_t lbn)
Event on NFTL translation table lookup (Op)
Definition: fs_evr.h:3759

EvtFsCore_sys_seek
#define EvtFsCore_sys_seek
Definition: fs_evr.h:40

EvrFsNAND_InitDriverError
__STATIC_INLINE void EvrFsNAND_InitDriverError(uint32_t instance, uint32_t driver)
Event on NAND driver initialization error (Error)
Definition: fs_evr.h:4248

EvrFsNAND_DriverTimeoutError
__STATIC_INLINE void EvrFsNAND_DriverTimeoutError(uint32_t instance, uint32_t driver)
Event on NAND driver timeout error (Error)
Definition: fs_evr.h:4371

EvrFsNFTL_BlockEraseStatusErr
__STATIC_INLINE void EvrFsNFTL_BlockEraseStatusErr(uint32_t instance, uint32_t row)
Event on invalid block erase status value (Op)
Definition: fs_evr.h:3974

fsTime::hr
uint8_t hr
Hours [0..23].
Definition: rl_fs.h:133

EvtFsEFS_FileHandleActive
#define EvtFsEFS_FileHandleActive
Definition: fs_evr.h:220

EvrFsNFTL_ResetDeviceTimeout
__STATIC_INLINE void EvrFsNFTL_ResetDeviceTimeout(uint32_t instance)
Event on NAND device reset timeout (Error)
Definition: fs_evr.h:3386

EvtFsMcMCI_DeviceStateUnknown
#define EvtFsMcMCI_DeviceStateUnknown
Definition: fs_evr.h:400

EvrFsCore_fdefrag
__STATIC_INLINE void EvrFsCore_fdefrag(const char *drive)
Event on drive defrag (API)
Definition: fs_evr.h:786

EvrFsEFS_FileDelete
__STATIC_INLINE void EvrFsEFS_FileDelete(uint32_t drive, const char *path)
Event on EFS file delete (Op)
Definition: fs_evr.h:2614

EvrFsNFTL_ReadSector
__STATIC_INLINE void EvrFsNFTL_ReadSector(uint32_t instance, uint32_t sector, uint8_t *buf, uint32_t cnt)
Event on NFTL read sector operation (Op)
Definition: fs_evr.h:3677

EvtFsCore_ftime_set
#define EvtFsCore_ftime_set
Definition: fs_evr.h:67

EvtFsMcSPI_SectorWrite
#define EvtFsMcSPI_SectorWrite
Definition: fs_evr.h:441

EvtFsNFTL_UninitDriverFailed
#define EvtFsNFTL_UninitDriverFailed
Definition: fs_evr.h:279

EvtFsNFTL_InitMediaFailed
#define EvtFsNFTL_InitMediaFailed
Definition: fs_evr.h:263

EvrFsFAT_FileWrite
__STATIC_INLINE void EvrFsFAT_FileWrite(uint32_t h, const uint8_t *buf, uint32_t len)
Event on FAT file write (Op)
Definition: fs_evr.h:1728

EvtFsNFTL_BootSignatureInvalid
#define EvtFsNFTL_BootSignatureInvalid
Definition: fs_evr.h:273

EvrFsNFTL_Init
__STATIC_INLINE void EvrFsNFTL_Init(uint32_t instance)
Event on NFTL initialization (Op)
Definition: fs_evr.h:3302

EvtFsMcSPI_SlaveSelCtrlMissing
#define EvtFsMcSPI_SlaveSelCtrlMissing
Definition: fs_evr.h:452

EvtFsMcSPI_InitDriverPowerError
#define EvtFsMcSPI_InitDriverPowerError
Definition: fs_evr.h:418

EvrFsEFS_DriveCheck
__STATIC_INLINE void EvrFsEFS_DriveCheck(uint32_t drive)
Event on EFS drive check (Op)
Definition: fs_evr.h:2714

EvrFsNFTL_SetupSpareLayout
__STATIC_INLINE void EvrFsNFTL_SetupSpareLayout(uint32_t instance, uint32_t ofs_lsn, uint32_t ofs_dcm, uint32_t ofs_bbm, uint32_t ofs_ecc)
Event on spare area layout setup (Detail)
Definition: fs_evr.h:4127

EvrFsMcSPI_InitDriverSuccess
__STATIC_INLINE void EvrFsMcSPI_InitDriverSuccess(uint32_t instance, uint32_t driver)
Event on successful memory card driver initialization (Op)
Definition: fs_evr.h:5226

EvrFsMcMCI_SectorWrite
__STATIC_INLINE void EvrFsMcMCI_SectorWrite(uint32_t instance, uint32_t sector, uint32_t count)
Event on sector write operation (Op)
Definition: fs_evr.h:4891

EvtFsEFS_FileRename
#define EvtFsEFS_FileRename
Definition: fs_evr.h:206

EvrFsMcMCI_MediaDetectionMMC
__STATIC_INLINE void EvrFsMcMCI_MediaDetectionMMC(uint32_t instance)
Event on start of MMC/eMMC device detection procedure (Op)
Definition: fs_evr.h:4678

EvrFsMcMCI_CidReadError
__STATIC_INLINE void EvrFsMcMCI_CidReadError(uint32_t instance)
Event on CID register read error (Error)
Definition: fs_evr.h:4702

EvtFsIOC_ReadInfo
#define EvtFsIOC_ReadInfo
Definition: fs_evr.h:252

EvtFsCore_fmedia
#define EvtFsCore_fmedia
Definition: fs_evr.h:62

EvtFsNFTL_UninitDriver
#define EvtFsNFTL_UninitDriver
Definition: fs_evr.h:278

EvtFsFAT_TimeSet
#define EvtFsFAT_TimeSet
Definition: fs_evr.h:169

EvtFsFAT_MediaInsertStatError
#define EvtFsFAT_MediaInsertStatError
Definition: fs_evr.h:79

EvtFsNAND_IdRead
#define EvtFsNAND_IdRead
Definition: fs_evr.h:353

EvtFsMcMCI_SectorWrite
#define EvtFsMcMCI_SectorWrite
Definition: fs_evr.h:388

EvtFsEFS_FlashProgUnitTooBig
#define EvtFsEFS_FlashProgUnitTooBig
Definition: fs_evr.h:182

EvtFsMcMCI_DataBusSwitchError
#define EvtFsMcMCI_DataBusSwitchError
Definition: fs_evr.h:381

EvrFsEFS_FileNotOpened
__STATIC_INLINE void EvrFsEFS_FileNotOpened(uint32_t h, uint32_t flags)
Event on EFS file close (Op)
Definition: fs_evr.h:2497

EvrFsMcMCI_TransferRetry
__STATIC_INLINE void EvrFsMcMCI_TransferRetry(uint32_t instance, uint32_t retry)
Event on transfer setup error (Op)
Definition: fs_evr.h:4931

EvrFsFAT_AttribSet
__STATIC_INLINE void EvrFsFAT_AttribSet(uint32_t drive, const char *path, uint32_t attrib)
Event on FAT attribute setting (Op)
Definition: fs_evr.h:1943

EvrFsEFS_FreeSpaceAmount
__STATIC_INLINE void EvrFsEFS_FreeSpaceAmount(uint32_t drive, uint32_t free)
Event on EFS free space retrieval (Op)
Definition: fs_evr.h:2677

fsFileInfo
File information data.
Definition: rl_fs.h:142

EvrFsNFTL_PbnOutOfRange
__STATIC_INLINE void EvrFsNFTL_PbnOutOfRange(uint32_t instance, uint32_t pbn, uint32_t max)
Event when physical block number is out of range (Error)
Definition: fs_evr.h:3746

EvrFsEFS_DriveNotInitialized
__STATIC_INLINE void EvrFsEFS_DriveNotInitialized(uint32_t drive)
Event on EFS when media driver is not initialized (Error)
Definition: fs_evr.h:2942

EvtFsEFS_FileAlreadyExists
#define EvtFsEFS_FileAlreadyExists
Definition: fs_evr.h:208

EvrFsMcSPI_SectorWriteError
__STATIC_INLINE void EvrFsMcSPI_SectorWriteError(uint32_t instance, uint32_t sector, uint32_t count)
Event on sector write operation error (Op)
Definition: fs_evr.h:5553

EvtFsMcMCI_MediaCdInactive
#define EvtFsMcMCI_MediaCdInactive
Definition: fs_evr.h:363

EvrFsFAT_ReadFSInfo
__STATIC_INLINE void EvrFsFAT_ReadFSInfo(uint32_t drive, uint32_t sector)
Event on FAT FSInfo read operation (Op)
Definition: fs_evr.h:1135

EvtFsNFTL_ReadTable
#define EvtFsNFTL_ReadTable
Definition: fs_evr.h:275

EvtFsEFS_DriveCheckSuccess
#define EvtFsEFS_DriveCheckSuccess
Definition: fs_evr.h:214

EvrFsNFTL_LsnToLbn
__STATIC_INLINE void EvrFsNFTL_LsnToLbn(uint32_t instance, uint32_t lsn, uint32_t lbn)
Event on NFTL resolving logical sector to logical block (Op)
Definition: fs_evr.h:3703

EvtFsMcMCI_RcaWriteError
#define EvtFsMcMCI_RcaWriteError
Definition: fs_evr.h:375

EvtFsMcSPI_CsdReadError
#define EvtFsMcSPI_CsdReadError
Definition: fs_evr.h:435

EvrFsFAT_FormatOptionDetected
__STATIC_INLINE void EvrFsFAT_FormatOptionDetected(uint32_t drive, uint32_t option)
Event on FAT drive format option detection (Op)
Definition: fs_evr.h:1281

EvrFsFAT_TimeGet
__STATIC_INLINE void EvrFsFAT_TimeGet(uint32_t drive, const char *path)
Event on FAT timestamp get (Op)
Definition: fs_evr.h:2169

EvtFsFAT_MediaInitStatError
#define EvtFsFAT_MediaInitStatError
Definition: fs_evr.h:80

EvrFsMcMCI_SleepAwakeControl
__STATIC_INLINE void EvrFsMcMCI_SleepAwakeControl(uint32_t instance)
Event on SLEEP/AWAKE control operation (Op)
Definition: fs_evr.h:5095

EvrFsFAT_DirCreateSuccess
__STATIC_INLINE void EvrFsFAT_DirCreateSuccess(uint32_t drive, const char *path)
Event on successful FAT directory create operation (Op)
Definition: fs_evr.h:1847

EvrFsFAT_InitDrive
__STATIC_INLINE void EvrFsFAT_InitDrive(uint32_t drive)
Event on FAT drive initialization (Op)
Definition: fs_evr.h:916

EvrFsCore_sys_close
__STATIC_INLINE void EvrFsCore_sys_close(int fh)
Event on file close (API)
Definition: fs_evr.h:484

EvrFsNFTL_LbnToPbn
__STATIC_INLINE void EvrFsNFTL_LbnToPbn(uint32_t instance, uint32_t lbn, uint32_t pbn_0, uint32_t pbn_1)
Event on NFTL resolving logical block to physical block (Op)
Definition: fs_evr.h:3718

EvtFsFAT_ReadFSInfo
#define EvtFsFAT_ReadFSInfo
Definition: fs_evr.h:90

EvtFsFAT_LabelNotSet
#define EvtFsFAT_LabelNotSet
Definition: fs_evr.h:125

EvrFsCore_finit
__STATIC_INLINE void EvrFsCore_finit(const char *drive)
Event on drive initialization (API)
Definition: fs_evr.h:562

EvrFsNFTL_TableEntryNotFound
__STATIC_INLINE void EvrFsNFTL_TableEntryNotFound(uint32_t instance, uint32_t lbn)
Event on nonexisting translation table entry (Op)
Definition: fs_evr.h:3772

EvtFsCore_sys_close
#define EvtFsCore_sys_close
Definition: fs_evr.h:37

EvtFsMcMCI_ReadInfo
#define EvtFsMcMCI_ReadInfo
Definition: fs_evr.h:392

EvrFsEFS_InitDriver
__STATIC_INLINE void EvrFsEFS_InitDriver(uint32_t drive, uint32_t driver)
Event on EFS driver initialization (Op)
Definition: fs_evr.h:2233

EvrFsFAT_FormatDriveSuccess
__STATIC_INLINE void EvrFsFAT_FormatDriveSuccess(uint32_t drive)
Event on successful formating of a FAT drive (Op)
Definition: fs_evr.h:1256

EvtFsIOC_GetIdSuccess
#define EvtFsIOC_GetIdSuccess
Definition: fs_evr.h:238

EvtFsFAT_ClearHiddenSectors
#define EvtFsFAT_ClearHiddenSectors
Definition: fs_evr.h:109

EvrFsMcMCI_UninitMedia
__STATIC_INLINE void EvrFsMcMCI_UninitMedia(uint32_t instance)
Event on memory card device uninitialization (Op)
Definition: fs_evr.h:4849

EvtFsMcSPI_MediaPasswordEnabled
#define EvtFsMcSPI_MediaPasswordEnabled
Definition: fs_evr.h:462

EvtFsNFTL_ResetDeviceFailed
#define EvtFsNFTL_ResetDeviceFailed
Definition: fs_evr.h:268

EvtFsIOC_Lock
#define EvtFsIOC_Lock
Definition: fs_evr.h:240

EvrFsNAND_DriverEccSelect
__STATIC_INLINE void EvrFsNAND_DriverEccSelect(uint32_t instance, uint32_t driver, uint32_t index)
Event on NAND driver ECC selection (Op)
Definition: fs_evr.h:4345

EvrFsEFS_DataAreaOverlap
__STATIC_INLINE void EvrFsEFS_DataAreaOverlap(uint32_t drive)
Event on EFS user and allocation area overlap detection (Error)
Definition: fs_evr.h:2738

EvtFsEFS_FileAllocWrite
#define EvtFsEFS_FileAllocWrite
Definition: fs_evr.h:233

EvrFsCore_fcheck
__STATIC_INLINE void EvrFsCore_fcheck(const char *drive)
Event on drive check (API)
Definition: fs_evr.h:774

fsTime::min
uint8_t min
Minutes [0..59].
Definition: rl_fs.h:134

EvrFsEFS_FileFlush
__STATIC_INLINE void EvrFsEFS_FileFlush(uint32_t h)
Event on EFS file flush (Op)
Definition: fs_evr.h:2561

EvrFsFAT_UnmountDriveSuccess
__STATIC_INLINE void EvrFsFAT_UnmountDriveSuccess(uint32_t drive)
Event on successful unmount of a FAT drive (Op)
Definition: fs_evr.h:1232

EvtFsMcMCI_BlenWriteError
#define EvtFsMcMCI_BlenWriteError
Definition: fs_evr.h:378

EvrFsEFS_DriveAnalyzeSuccess
__STATIC_INLINE void EvrFsEFS_DriveAnalyzeSuccess(uint32_t drive, uint32_t factor)
Event on successful EFS drive analyze (Op)
Definition: fs_evr.h:2702

EvrFsFAT_LabelInvalid
__STATIC_INLINE void EvrFsFAT_LabelInvalid(uint32_t drive)
Event on invalid character found in FAT label (Error)
Definition: fs_evr.h:1562

EvtFsMcSPI_UninitMedia
#define EvtFsMcSPI_UninitMedia
Definition: fs_evr.h:438

EvrFsMcMCI_ExtCsdReadError
__STATIC_INLINE void EvrFsMcMCI_ExtCsdReadError(uint32_t instance)
Event on EXT_CSD register read error (Error)
Definition: fs_evr.h:4775

EvtFsCore_ffind
#define EvtFsCore_ffind
Definition: fs_evr.h:49

EvtFsMcMCI_LockDeactivated
#define EvtFsMcMCI_LockDeactivated
Definition: fs_evr.h:399

EvtFsEFS_FlashEraseChipTimeout
#define EvtFsEFS_FlashEraseChipTimeout
Definition: fs_evr.h:190

EvtFsEFS_FileHandleUnavailable
#define EvtFsEFS_FileHandleUnavailable
Definition: fs_evr.h:221

EvrFsNFTL_BadBlockMark
__STATIC_INLINE void EvrFsNFTL_BadBlockMark(uint32_t instance, uint32_t block)
Event on NFTL bad block mark operation (Op)
Definition: fs_evr.h:3635

EvrFsMcSPI_CidReadError
__STATIC_INLINE void EvrFsMcSPI_CidReadError(uint32_t instance)
Event on CID register read error (Error)
Definition: fs_evr.h:5446

EvtFsEFS_FileAllocRead
#define EvtFsEFS_FileAllocRead
Definition: fs_evr.h:234

EvrFsCore_sys_handle_assign
__STATIC_INLINE void EvrFsCore_sys_handle_assign(const char *name, int fh)
Event on file handle assignment (Op)
Definition: fs_evr.h:550

EvtFsNFTL_ReadSectorSuccess
#define EvtFsNFTL_ReadSectorSuccess
Definition: fs_evr.h:293

EvrFsCore_sys_flen
__STATIC_INLINE void EvrFsCore_sys_flen(int fh)
Event on current file length request (API)
Definition: fs_evr.h:537

EvrFsNFTL_BlockEraseFailed
__STATIC_INLINE void EvrFsNFTL_BlockEraseFailed(uint32_t instance, uint32_t row)
Event on NAND block erase error (Error)
Definition: fs_evr.h:3987

EvrFsMcMCI_MediaCdActive
__STATIC_INLINE void EvrFsMcMCI_MediaCdActive(uint32_t instance)
Event on media detection using card detect switch (Op)
Definition: fs_evr.h:4569

EvrFsFAT_VolumeNotMounted
__STATIC_INLINE void EvrFsFAT_VolumeNotMounted(uint32_t drive)
Event on FAT when using unmounted volume (Error)
Definition: fs_evr.h:1048

EvtFsEFS_InitDriverFailed
#define EvtFsEFS_InitDriverFailed
Definition: fs_evr.h:176

EvrFsMcSPI_MediaNoResponse
__STATIC_INLINE void EvrFsMcSPI_MediaNoResponse(uint32_t instance)
Event on nonresponsive media device (Error)
Definition: fs_evr.h:5410

EvrFsMcSPI_ParameterInvalid
__STATIC_INLINE void EvrFsMcSPI_ParameterInvalid(uint32_t instance)
Event on invalid function parameter(s) (Error)
Definition: fs_evr.h:5792

EvtFsNFTL_ReadSector
#define EvtFsNFTL_ReadSector
Definition: fs_evr.h:292

EvtFsMcMCI_MediaDetectionMMC
#define EvtFsMcMCI_MediaDetectionMMC
Definition: fs_evr.h:371

EvrFsFAT_UninitDrive
__STATIC_INLINE void EvrFsFAT_UninitDrive(uint32_t drive)
Event on FAT drive uninitialization (Op)
Definition: fs_evr.h:964

EvrFsNFTL_GarbageCollection
__STATIC_INLINE void EvrFsNFTL_GarbageCollection(uint32_t instance, uint32_t src_0, uint32_t src_1, uint32_t dst)
Event on NFTL garbage collection operation (Op)
Definition: fs_evr.h:3843

EvtFsFAT_AttribSet
#define EvtFsFAT_AttribSet
Definition: fs_evr.h:153

EvrFsNAND_DriverBusWidthSelect
__STATIC_INLINE void EvrFsNAND_DriverBusWidthSelect(uint32_t instance, uint32_t driver, uint32_t width)
Event on NAND driver initialization error (Error)
Definition: fs_evr.h:4290

EvtFsFAT_NameCacheHit
#define EvtFsFAT_NameCacheHit
Definition: fs_evr.h:164

EvrFsFAT_FileIsReadOnly
__STATIC_INLINE void EvrFsFAT_FileIsReadOnly(uint32_t drive)
Event on encounter of read only FAT file (Error)
Definition: fs_evr.h:1501

EvtFsNAND_Uninit
#define EvtFsNAND_Uninit
Definition: fs_evr.h:347

EvrFsFAT_InitJournal
__STATIC_INLINE void EvrFsFAT_InitJournal(uint32_t drive)
Event on FAT journal initialization start (Op)
Definition: fs_evr.h:1651

EvtFsNFTL_ResetDevice
#define EvtFsNFTL_ResetDevice
Definition: fs_evr.h:267

EvrFsMcSPI_LockUnlockExec
__STATIC_INLINE void EvrFsMcSPI_LockUnlockExec(uint32_t instance)
Event on Lock/Unlock command execution (Op)
Definition: fs_evr.h:5617

EvrFsNFTL_SkipBadBlock
__STATIC_INLINE void EvrFsNFTL_SkipBadBlock(uint32_t instance, uint32_t pbn)
Event on skipped bad block (Op)
Definition: fs_evr.h:3909

EvtFsFAT_FileFlush
#define EvtFsFAT_FileFlush
Definition: fs_evr.h:138

EvrFsMcSPI_DevCtrlUnsupported
__STATIC_INLINE void EvrFsMcSPI_DevCtrlUnsupported(uint32_t instance, uint32_t code)
Event on memory card device control code unsupported error (Error)
Definition: fs_evr.h:5605

EvtFsFAT_PathBufferToSmall
#define EvtFsFAT_PathBufferToSmall
Definition: fs_evr.h:130

EvrFsMcMCI_MediaDetectionError
__STATIC_INLINE void EvrFsMcMCI_MediaDetectionError(uint32_t instance)
Event on media device detection error (Error)
Definition: fs_evr.h:4690

EvtFsNAND_DriverTimeoutError
#define EvtFsNAND_DriverTimeoutError
Definition: fs_evr.h:345

EvrFsNFTL_DevCtrl
__STATIC_INLINE void EvrFsNFTL_DevCtrl(uint32_t instance, uint32_t code, void *p)
Event on NFTL device control operation (Op)
Definition: fs_evr.h:3547

EvrFsFAT_WriteFSInfo
__STATIC_INLINE void EvrFsFAT_WriteFSInfo(uint32_t drive, uint32_t sector)
Event on FAT FSInfo write operation (Op)
Definition: fs_evr.h:1184

EvrFsEFS_FileHandleUnavailable
__STATIC_INLINE void EvrFsEFS_FileHandleUnavailable(uint32_t drive)
Event on too many open files (Error)
Definition: fs_evr.h:2811

EvrFsMcMCI_InitDriverPowerError
__STATIC_INLINE void EvrFsMcMCI_InitDriverPowerError(uint32_t instance, uint32_t driver, uint32_t state)
Event on memory card driver initialization error (Op)
Definition: fs_evr.h:4533

EvrFsEFS_DriveNotMounted
__STATIC_INLINE void EvrFsEFS_DriveNotMounted(uint32_t drive)
Event on EFS when using unmounted drive (Error)
Definition: fs_evr.h:2930

EvtFsFAT_FileRename
#define EvtFsFAT_FileRename
Definition: fs_evr.h:143

EvtFsNFTL_BitErrorCorrected
#define EvtFsNFTL_BitErrorCorrected
Definition: fs_evr.h:317

EvrFsCore_funinit
__STATIC_INLINE void EvrFsCore_funinit(const char *drive)
Event on drive uninitialization (API)
Definition: fs_evr.h:574

EvrFsIOC_ReadInfoSuccess
__STATIC_INLINE void EvrFsIOC_ReadInfoSuccess(uint32_t drv_id, uint32_t block_count)
Event on successful read info operation (Op)
Definition: fs_evr.h:3214

EvtFsFAT_FileHandleUnavailable
#define EvtFsFAT_FileHandleUnavailable
Definition: fs_evr.h:122

EvtFsMcSPI_LockUnlockExec
#define EvtFsMcSPI_LockUnlockExec
Definition: fs_evr.h:447

EvrFsMcSPI_InitDriver
__STATIC_INLINE void EvrFsMcSPI_InitDriver(uint32_t instance, uint32_t driver)
Event on memory card driver initialization (Op)
Definition: fs_evr.h:5213

EvrFsIOC_GetIdSuccess
__STATIC_INLINE void EvrFsIOC_GetIdSuccess(uint32_t drive, uint32_t drv_id)
Event on retrieval of drive ID (Op)
Definition: fs_evr.h:3011

EvtFsFAT_FormatNoSpaceFAT32
#define EvtFsFAT_FormatNoSpaceFAT32
Definition: fs_evr.h:106

EvtFsFAT_CreateFAT
#define EvtFsFAT_CreateFAT
Definition: fs_evr.h:112

EvrFsMcSPI_CrcDisableError
__STATIC_INLINE void EvrFsMcSPI_CrcDisableError(uint32_t instance)
Event on CRC check disable error (Error)
Definition: fs_evr.h:5714

EvrFsNAND_DriverDevPowerSelect
__STATIC_INLINE void EvrFsNAND_DriverDevPowerSelect(uint32_t instance, uint32_t driver, uint32_t volt)
Event on NAND device voltage change (Op)
Definition: fs_evr.h:4318

EvtFsMcMCI_DevCtrl
#define EvtFsMcMCI_DevCtrl
Definition: fs_evr.h:394

EvrFsEFS_OpenModeUnsupported
__STATIC_INLINE void EvrFsEFS_OpenModeUnsupported(uint32_t h, uint32_t openmode)
Event on unsupported EFS file open mode specification (Error)
Definition: fs_evr.h:2472

EvtFsEFS_FileSeekEOF
#define EvtFsEFS_FileSeekEOF
Definition: fs_evr.h:204

EvtFsNFTL_LsnNotFound
#define EvtFsNFTL_LsnNotFound
Definition: fs_evr.h:303

EvtFsMcMCI_MediaReset
#define EvtFsMcMCI_MediaReset
Definition: fs_evr.h:366

EvrFsNFTL_MountSuccess
__STATIC_INLINE void EvrFsNFTL_MountSuccess(uint32_t instance)
Event on successful NFTL mount (Op)
Definition: fs_evr.h:3338

EvrFsFAT_FileIsInUse
__STATIC_INLINE void EvrFsFAT_FileIsInUse(uint32_t drive)
Event on specified FAT file already in use (Error)
Definition: fs_evr.h:1489

EvtFsNFTL_SetBadBlockMarker
#define EvtFsNFTL_SetBadBlockMarker
Definition: fs_evr.h:305

EvtFsIOC_NotAllowed
#define EvtFsIOC_NotAllowed
Definition: fs_evr.h:259

EvtFsFAT_DirEntryAllocFailed
#define EvtFsFAT_DirEntryAllocFailed
Definition: fs_evr.h:129

EvtFsMcMCI_MediaNotInitialized
#define EvtFsMcMCI_MediaNotInitialized
Definition: fs_evr.h:361

EvrFsFAT_FileFlush
__STATIC_INLINE void EvrFsFAT_FileFlush(uint32_t h)
Event on FAT file flush (Op)
Definition: fs_evr.h:1740

EvtFsMcSPI_MediaCdActive
#define EvtFsMcSPI_MediaCdActive
Definition: fs_evr.h:422

EvtFsFAT_InvalidBootSector
#define EvtFsFAT_InvalidBootSector
Definition: fs_evr.h:88

EvrFsEFS_FlashCapacity
__STATIC_INLINE void EvrFsEFS_FlashCapacity(uint32_t drive, uint32_t capacity)
Event on retrieved capacity of the Flash device (Error)
Definition: fs_evr.h:2334

EvrFsCore_CurrentDriveSelect
__STATIC_INLINE void EvrFsCore_CurrentDriveSelect(uint32_t drive)
Event on current drive selection (Op)
Definition: fs_evr.h:849

EvrFsEFS_FormatDrive
__STATIC_INLINE void EvrFsEFS_FormatDrive(uint32_t drive)
Event on EFS drive format (Op)
Definition: fs_evr.h:2370

EvrFsMcSPI_MediaCdActive
__STATIC_INLINE void EvrFsMcSPI_MediaCdActive(uint32_t instance)
Event on media detection using card detect switch (Op)
Definition: fs_evr.h:5301

EvtFsNFTL_PbnOutOfRange
#define EvtFsNFTL_PbnOutOfRange
Definition: fs_evr.h:297

EvrFsFAT_TimeData
__STATIC_INLINE void EvrFsFAT_TimeData(fsTime *create, fsTime *access, fsTime *write)
Event on FAT timestamp data set/get (Detail)
Definition: fs_evr.h:2183

EvtFsFAT_FileIsInUse
#define EvtFsFAT_FileIsInUse
Definition: fs_evr.h:118

EvrFsFAT_InitMediaError
__STATIC_INLINE void EvrFsFAT_InitMediaError(uint32_t drive)
Event on FAT media initialization error (Error)
Definition: fs_evr.h:988

EvrFsCore_ffree
__STATIC_INLINE void EvrFsCore_ffree(const char *drive)
Event on free space retrieval (API)
Definition: fs_evr.h:737

EvtFsEFS_DriveNotInitialized
#define EvtFsEFS_DriveNotInitialized
Definition: fs_evr.h:231

EvrFsFAT_NameCacheMiss
__STATIC_INLINE void EvrFsFAT_NameCacheMiss(uint32_t drive, const char *name, uint32_t len)
Event on FAT name cache miss (Op)
Definition: fs_evr.h:2098

EvtFsNFTL_BootSignatureValid
#define EvtFsNFTL_BootSignatureValid
Definition: fs_evr.h:272

EvtFsFAT_FileHandleInvalid
#define EvtFsFAT_FileHandleInvalid
Definition: fs_evr.h:123

EvtFsMcMCI_MediaReady
#define EvtFsMcMCI_MediaReady
Definition: fs_evr.h:369

EvrFsNFTL_PageProgramTimeout
__STATIC_INLINE void EvrFsNFTL_PageProgramTimeout(uint32_t instance, uint32_t row)
Event on NAND page program timeout (Error)
Definition: fs_evr.h:3961

EvrFsNAND_DriverEccInquire
__STATIC_INLINE void EvrFsNAND_DriverEccInquire(uint32_t instance, uint32_t driver)
Event on NAND driver ECC inquiry (Op)
Definition: fs_evr.h:4331

EvrFsEFS_FileRead
__STATIC_INLINE void EvrFsEFS_FileRead(uint32_t h, uint8_t *buf, uint32_t len)
Event on EFS file read (Op)
Definition: fs_evr.h:2511

EvrFsMcSPI_LockDeactivated
__STATIC_INLINE void EvrFsMcSPI_LockDeactivated(uint32_t instance)
Event on deactivated password protection status (Op)
Definition: fs_evr.h:5653

EvrFsCore_fanalyse
__STATIC_INLINE void EvrFsCore_fanalyse(const char *drive)
Event on drive analyse (API)
Definition: fs_evr.h:762

EvrFsFAT_InvalidBootSector
__STATIC_INLINE void EvrFsFAT_InvalidBootSector(uint32_t drive)
Event on invalid Boot Sector (Error)
Definition: fs_evr.h:1110

EvrFsCore_fdelete
__STATIC_INLINE void EvrFsCore_fdelete(const char *path, const char *options)
Event on file delete (API)
Definition: fs_evr.h:623

EvtFsIOC_Unlock
#define EvtFsIOC_Unlock
Definition: fs_evr.h:242

EvrFsNAND_StatusRead
__STATIC_INLINE void EvrFsNAND_StatusRead(uint32_t instance, uint32_t status)
Event on NAND device status retrieval (Detail)
Definition: fs_evr.h:4410

EvrFsMcSPI_BusSpeedControl
__STATIC_INLINE void EvrFsMcSPI_BusSpeedControl(uint32_t instance, uint32_t speed)
Event on SPI bus speed control operation (Op)
Definition: fs_evr.h:5666

EvrFsEFS_AllocationOrderInvalid
__STATIC_INLINE void EvrFsEFS_AllocationOrderInvalid(uint32_t drive)
Event on EFS allocation order error (Error)
Definition: fs_evr.h:2762

EvrFsCore_fversion
__STATIC_INLINE void EvrFsCore_fversion(uint32_t version)
Event on FileSystem component version retrieve (API)
Definition: fs_evr.h:891

EvrFsMcMCI_SendCommandError
__STATIC_INLINE void EvrFsMcMCI_SendCommandError(uint32_t instance, uint32_t cmd, uint32_t arg)
Event on AWAKE mode active status (Op)
Definition: fs_evr.h:5146

EvtFsNAND_DriverEccSelect
#define EvtFsNAND_DriverEccSelect
Definition: fs_evr.h:343

EvrFsCore_fmedia
__STATIC_INLINE void EvrFsCore_fmedia(const char *drive)
Event on media presence check (API)
Definition: fs_evr.h:798

EvrFsNFTL_BitErrorCorrected
__STATIC_INLINE void EvrFsNFTL_BitErrorCorrected(uint32_t instance, uint32_t row)
Event on ECC bit error correction (Op)
Definition: fs_evr.h:4013

EvtFsNFTL_Uninit
#define EvtFsNFTL_Uninit
Definition: fs_evr.h:277

EvrFsEFS_MountDrive
__STATIC_INLINE void EvrFsEFS_MountDrive(uint32_t drive)
Event on EFS drive mount (Op)
Definition: fs_evr.h:2283

EvtFsFAT_FreeAmount
#define EvtFsFAT_FreeAmount
Definition: fs_evr.h:156

EvrFsFAT_FileRead
__STATIC_INLINE void EvrFsFAT_FileRead(uint32_t h, uint8_t *buf, uint32_t len)
Event on FAT file read (Op)
Definition: fs_evr.h:1714

EvtFsNFTL_LbnToPbn
#define EvtFsNFTL_LbnToPbn
Definition: fs_evr.h:295

EvrFsFAT_FileClose
__STATIC_INLINE void EvrFsFAT_FileClose(uint32_t h)
Event on FAT file close (Op)
Definition: fs_evr.h:1687

EvrFsEFS_FreeSpaceRetrieve
__STATIC_INLINE void EvrFsEFS_FreeSpaceRetrieve(uint32_t drive)
Event on EFS free space retrieve request (Op)
Definition: fs_evr.h:2664

EvtFsEFS_FormatDrive
#define EvtFsEFS_FormatDrive
Definition: fs_evr.h:186

EvtFsFAT_DirCreateSuccess
#define EvtFsFAT_DirCreateSuccess
Definition: fs_evr.h:146

EvrFsEFS_FlashGetInfo
__STATIC_INLINE void EvrFsEFS_FlashGetInfo(uint32_t drive)
Event on Flash device info retrieve operation (Op)
Definition: fs_evr.h:2307

EvrFsFAT_CreateFAT
__STATIC_INLINE void EvrFsFAT_CreateFAT(uint32_t drive, uint32_t sector, uint32_t count)
Event on FAT File Allocation Table create operation (Op)
Definition: fs_evr.h:1412

EvrFsNAND_ParamPageRead
__STATIC_INLINE void EvrFsNAND_ParamPageRead(uint32_t instance, uint32_t col, uint32_t len)
Event on NAND parameter page read operation (Op)
Definition: fs_evr.h:4467

EvtFsIOC_DeviceControlSuccess
#define EvtFsIOC_DeviceControlSuccess
Definition: fs_evr.h:256

EvrFsMcSPI_MediaSD_V2
__STATIC_INLINE void EvrFsMcSPI_MediaSD_V2(uint32_t instance)
Event on received response from SD memory card V2 (Op)
Definition: fs_evr.h:5385

EvrFsMcSPI_InitMedia
__STATIC_INLINE void EvrFsMcSPI_InitMedia(uint32_t instance)
Event on memory card device initialization (Op)
Definition: fs_evr.h:5265

EvtFsFAT_PathProcessing
#define EvtFsFAT_PathProcessing
Definition: fs_evr.h:121

EvrFsEFS_UninitDrive
__STATIC_INLINE void EvrFsEFS_UninitDrive(uint32_t drive)
Event on EFS drive uninitialization (Op)
Definition: fs_evr.h:2258

EvrFsMcMCI_InitSuccess
__STATIC_INLINE void EvrFsMcMCI_InitSuccess(uint32_t instance)
Event on successful memory card device initialization (Op)
Definition: fs_evr.h:4823

EvtFsIOC_GetIdError
#define EvtFsIOC_GetIdError
Definition: fs_evr.h:239

EvtFsNFTL_GarbageCollection
#define EvtFsNFTL_GarbageCollection
Definition: fs_evr.h:304

EvtFsNFTL_FormatSuccess
#define EvtFsNFTL_FormatSuccess
Definition: fs_evr.h:285

EvrFsMcMCI_TransferError
__STATIC_INLINE void EvrFsMcMCI_TransferError(uint32_t instance, uint32_t events)
Event on transfer error (Error)
Definition: fs_evr.h:4918

EvtFsMcSPI_MediaNoResponse
#define EvtFsMcSPI_MediaNoResponse
Definition: fs_evr.h:431

EvrFsMcMCI_ReadInfoSuccess
__STATIC_INLINE void EvrFsMcMCI_ReadInfoSuccess(uint32_t instance, uint32_t sect_count)
Event on media capacity retrieval operation (Op)
Definition: fs_evr.h:4956

EvrFsNFTL_RelocateBlock
__STATIC_INLINE void EvrFsNFTL_RelocateBlock(uint32_t instance, uint32_t pbn)
Event on attempt to change block physical location (Op)
Definition: fs_evr.h:3883

EvtFsFAT_DirCreate
#define EvtFsFAT_DirCreate
Definition: fs_evr.h:145

EvrFsEFS_DriveDefrag
__STATIC_INLINE void EvrFsEFS_DriveDefrag(uint32_t drive)
Event on EFS drive defrag (Op)
Definition: fs_evr.h:2786

EvrFsMcSPI_UninitDriver
__STATIC_INLINE void EvrFsMcSPI_UninitDriver(uint32_t instance, uint32_t driver)
Event on SPI driver uninitialization (Op)
Definition: fs_evr.h:5484

EvtFsMcSPI_DriverReceiveError
#define EvtFsMcSPI_DriverReceiveError
Definition: fs_evr.h:457

EvtFsFAT_FormatLowLevel
#define EvtFsFAT_FormatLowLevel
Definition: fs_evr.h:104

EvrFsNFTL_ResetDeviceFailed
__STATIC_INLINE void EvrFsNFTL_ResetDeviceFailed(uint32_t instance)
Event on NAND device reset error (Error)
Definition: fs_evr.h:3374

EvtFsMcMCI_InitSuccess
#define EvtFsMcMCI_InitSuccess
Definition: fs_evr.h:383

EvtFsMcSPI_InitMediaSuccess
#define EvtFsMcSPI_InitMediaSuccess
Definition: fs_evr.h:420

EvrFsMcSPI_ReadWpMissing
__STATIC_INLINE void EvrFsMcSPI_ReadWpMissing(uint32_t instance)
Event on missing fs_mc_read_wp function (Op)
Definition: fs_evr.h:5690

EvrFsEFS_AllocationAreaOverlap
__STATIC_INLINE void EvrFsEFS_AllocationAreaOverlap(uint32_t drive)
Event on EFS allocation area overlap error (Error)
Definition: fs_evr.h:2774

EvrFsMcMCI_SectorRead
__STATIC_INLINE void EvrFsMcMCI_SectorRead(uint32_t instance, uint32_t sector, uint32_t count)
Event on sector read operation (Op)
Definition: fs_evr.h:4863

EvrFsIOC_DeviceControl
__STATIC_INLINE void EvrFsIOC_DeviceControl(uint32_t drv_id, uint32_t code, uint32_t p)
Event on call of fs_ioc_read_info function (API)
Definition: fs_evr.h:3240

EvrFsIOC_WriteSectorSuccess
__STATIC_INLINE void EvrFsIOC_WriteSectorSuccess(uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt)
Event on successful read sector operation (Op)
Definition: fs_evr.h:3173

EvrFsEFS_FileNameInvalid
__STATIC_INLINE void EvrFsEFS_FileNameInvalid(const char *name, uint32_t len)
Event on invalid EFS filename specification (Error)
Definition: fs_evr.h:2459

EvrFsFAT_LabelString
__STATIC_INLINE void EvrFsFAT_LabelString(const char *buf, uint32_t len)
Event on FAT volume label string output (Detail)
Definition: fs_evr.h:2070

EvrFsFAT_NonexistentMBR
__STATIC_INLINE void EvrFsFAT_NonexistentMBR(uint32_t drive)
Event on nonexistent Master Boot Record (Op)
Definition: fs_evr.h:1085

EvtFsMcSPI_BusSpeedControl
#define EvtFsMcSPI_BusSpeedControl
Definition: fs_evr.h:451

EvrFsEFS_FlashEraseChipFailed
__STATIC_INLINE void EvrFsEFS_FlashEraseChipFailed(uint32_t drive)
Event on Flash chip erase operation error (Error)
Definition: fs_evr.h:2406

EvtFsMcSPI_InitDriver
#define EvtFsMcSPI_InitDriver
Definition: fs_evr.h:415

EvtFsFAT_FormatOptionDetected
#define EvtFsFAT_FormatOptionDetected
Definition: fs_evr.h:102

EvtFsCore_fversion
#define EvtFsCore_fversion
Definition: fs_evr.h:69

EvrFsMcMCI_MediaPasswordEnabled
__STATIC_INLINE void EvrFsMcMCI_MediaPasswordEnabled(uint32_t instance)
Event on detection of enabled media password protection (Error)
Definition: fs_evr.h:5200

EvrFsFAT_LabelNotSet
__STATIC_INLINE void EvrFsFAT_LabelNotSet(uint32_t drive)
Event on nonexisting FAT volume label (Op)
Definition: fs_evr.h:1574

EvtFsIOC_WriteSector
#define EvtFsIOC_WriteSector
Definition: fs_evr.h:249

EvtFsFAT_FileIsNonExistent
#define EvtFsFAT_FileIsNonExistent
Definition: fs_evr.h:120

EvtFsNAND_Init
#define EvtFsNAND_Init
Definition: fs_evr.h:334

EvrFsEFS_FileName
__STATIC_INLINE void EvrFsEFS_FileName(const char *buf, uint32_t len)
Event on EFS file name specification (Detail)
Definition: fs_evr.h:2955

EvtFsCore_sys_handle_assign
#define EvtFsCore_sys_handle_assign
Definition: fs_evr.h:42

EvrFsMcSPI_DriverSendError
__STATIC_INLINE void EvrFsMcSPI_DriverSendError(uint32_t instance, uint32_t event)
Event on SPI driver Send function error (Error)
Definition: fs_evr.h:5727

EvtFsNAND_DriverBusModeSelect
#define EvtFsNAND_DriverBusModeSelect
Definition: fs_evr.h:338

EvtFsMcSPI_BlenWriteError
#define EvtFsMcSPI_BlenWriteError
Definition: fs_evr.h:436

EvtFsFAT_InvalidMBR
#define EvtFsFAT_InvalidMBR
Definition: fs_evr.h:85

EvtFsMcSPI_MediaDetectionSD
#define EvtFsMcSPI_MediaDetectionSD
Definition: fs_evr.h:428

EvtFsNFTL_BlockEraseStatusErr
#define EvtFsNFTL_BlockEraseStatusErr
Definition: fs_evr.h:314

EvrFsEFS_UnmountDrive
__STATIC_INLINE void EvrFsEFS_UnmountDrive(uint32_t drive)
Event on EFS drive unmount (Op)
Definition: fs_evr.h:2346

EvrFsCore_ftime_set
__STATIC_INLINE void EvrFsCore_ftime_set(const char *path, fsTime *create, fsTime *access, fsTime *write)
Event on file or directory timestamp set (API)
Definition: fs_evr.h:864

EvtFsEFS_FlashEraseChipFailed
#define EvtFsEFS_FlashEraseChipFailed
Definition: fs_evr.h:189

EvtFsMcMCI_SleepAwakeControl
#define EvtFsMcMCI_SleepAwakeControl
Definition: fs_evr.h:404

EvtFsNFTL_DataBlockCapacity
#define EvtFsNFTL_DataBlockCapacity
Definition: fs_evr.h:274

EvtFsIOC_DriveIdInvalid
#define EvtFsIOC_DriveIdInvalid
Definition: fs_evr.h:257

EvtFsNFTL_LoadDataLayout
#define EvtFsNFTL_LoadDataLayout
Definition: fs_evr.h:323

EvtFsMcMCI_SectorRead
#define EvtFsMcMCI_SectorRead
Definition: fs_evr.h:386

EvtFsFAT_FormatDriveSuccess
#define EvtFsFAT_FormatDriveSuccess
Definition: fs_evr.h:100

EvtFsNFTL_DevCtrl
#define EvtFsNFTL_DevCtrl
Definition: fs_evr.h:282

EvrFsNFTL_PageRead
__STATIC_INLINE void EvrFsNFTL_PageRead(uint32_t instance, uint32_t pbn, uint32_t pg)
Event on page read (Op)
Definition: fs_evr.h:4155

EvtFsMcMCI_DeviceStateTimeout
#define EvtFsMcMCI_DeviceStateTimeout
Definition: fs_evr.h:402

EvtFsMcMCI_StbyStateError
#define EvtFsMcMCI_StbyStateError
Definition: fs_evr.h:382

EvrFsFAT_FileModeRead
__STATIC_INLINE void EvrFsFAT_FileModeRead(int32_t h)
Event on write to FAT file opened for read (Error)
Definition: fs_evr.h:1995

EvrFsMcSPI_DevCtrl
__STATIC_INLINE void EvrFsMcSPI_DevCtrl(uint32_t instance, uint32_t code, uint32_t p)
Event on memory card device control operation (Op)
Definition: fs_evr.h:5592

EvtFsNFTL_CacheRead
#define EvtFsNFTL_CacheRead
Definition: fs_evr.h:331

EvtFsFAT_FileRead
#define EvtFsFAT_FileRead
Definition: fs_evr.h:136

EvrFsCore_fmount
__STATIC_INLINE void EvrFsCore_fmount(const char *drive)
Event on drive mount (API)
Definition: fs_evr.h:586

EvtFsEFS_DriveAnalyze
#define EvtFsEFS_DriveAnalyze
Definition: fs_evr.h:211

EvrFsFAT_ClearHiddenSectors
__STATIC_INLINE void EvrFsFAT_ClearHiddenSectors(uint32_t drive, uint32_t sector, uint32_t count)
Event on FAT hidden sectors clear operation (Op)
Definition: fs_evr.h:1370

EvrFsNFTL_ReadSectorSuccess
__STATIC_INLINE void EvrFsNFTL_ReadSectorSuccess(uint32_t instance)
Event on successful NFTL read sector operation (Op)
Definition: fs_evr.h:3689

EvtFsEFS_OpenModeInvalid
#define EvtFsEFS_OpenModeInvalid
Definition: fs_evr.h:202

EvrFsNFTL_DeviceNotInitialized
__STATIC_INLINE void EvrFsNFTL_DeviceNotInitialized(uint32_t instance)
Event (Error)
Definition: fs_evr.h:3350

EvtFsEFS_FileNameInvalid
#define EvtFsEFS_FileNameInvalid
Definition: fs_evr.h:193

EvrFsNFTL_BootSignatureInvalid
__STATIC_INLINE void EvrFsNFTL_BootSignatureInvalid(uint32_t instance)
Event on NFTL invalid boot signatures (Op)
Definition: fs_evr.h:3434

EvtFsEFS_InitDriver
#define EvtFsEFS_InitDriver
Definition: fs_evr.h:175

EvrFsMcMCI_LockActive
__STATIC_INLINE void EvrFsMcMCI_LockActive(uint32_t instance)
Event on active password protection status (Op)
Definition: fs_evr.h:5019

EvtFsMcMCI_AwakeActive
#define EvtFsMcMCI_AwakeActive
Definition: fs_evr.h:406

EvtFsNAND_DriverBusWidthError
#define EvtFsNAND_DriverBusWidthError
Definition: fs_evr.h:340

EvtFsFAT_PathName
#define EvtFsFAT_PathName
Definition: fs_evr.h:161

EvtFsCore_fchdir
#define EvtFsCore_fchdir
Definition: fs_evr.h:53

EvtFsEFS_FlashEraseSectors
#define EvtFsEFS_FlashEraseSectors
Definition: fs_evr.h:191

EvtFsFAT_SectorReadFailed
#define EvtFsFAT_SectorReadFailed
Definition: fs_evr.h:126

EvrFsNAND_InitDriver
__STATIC_INLINE void EvrFsNAND_InitDriver(uint32_t instance, uint32_t driver)
Event on NAND driver initialization (Op)
Definition: fs_evr.h:4235

EvtFsNFTL_ReadTableFailed
#define EvtFsNFTL_ReadTableFailed
Definition: fs_evr.h:276

fsTime::sec
uint8_t sec
Seconds [0..59].
Definition: rl_fs.h:135

EvrFsMcSPI_InitDriverError
__STATIC_INLINE void EvrFsMcSPI_InitDriverError(uint32_t instance, uint32_t driver)
Event on memory card driver initialization error (Op)
Definition: fs_evr.h:5239

EvrFsNAND_DriverEccInquireError
__STATIC_INLINE void EvrFsNAND_DriverEccInquireError(uint32_t instance, uint32_t driver)
Event on NAND driver ECC inquiry error (Op)
Definition: fs_evr.h:4358

EvtFsNFTL_BlockErase
#define EvtFsNFTL_BlockErase
Definition: fs_evr.h:328

EvtFsCore_sys_flen
#define EvtFsCore_sys_flen
Definition: fs_evr.h:41

EvtFsMcSPI_MediaResetError
#define EvtFsMcSPI_MediaResetError
Definition: fs_evr.h:427

EvtFsNFTL_PageProgramTimeout
#define EvtFsNFTL_PageProgramTimeout
Definition: fs_evr.h:313

EvtFsNAND_DriverPowerCtrlError
#define EvtFsNAND_DriverPowerCtrlError
Definition: fs_evr.h:337

EvrFsMcSPI_SlaveSelCtrlMissing
__STATIC_INLINE void EvrFsMcSPI_SlaveSelCtrlMissing(uint32_t instance)
Event on missing fs_mc_spi_control_ss function (Op)
Definition: fs_evr.h:5678

EvtFsFAT_DiskFull
#define EvtFsFAT_DiskFull
Definition: fs_evr.h:128

EvrFsMcSPI_InitDriverPowerError
__STATIC_INLINE void EvrFsMcSPI_InitDriverPowerError(uint32_t instance, uint32_t driver, uint32_t state)
Event on memory card driver power control error (Op)
Definition: fs_evr.h:5253

EvtFsEFS_FileOpenReadMode
#define EvtFsEFS_FileOpenReadMode
Definition: fs_evr.h:200

EvtFsNAND_PageRead
#define EvtFsNAND_PageRead
Definition: fs_evr.h:351

EvtFsEFS_FileDelete
#define EvtFsEFS_FileDelete
Definition: fs_evr.h:205

EvrFsNFTL_Format
__STATIC_INLINE void EvrFsNFTL_Format(uint32_t instance)
Event on NFTL format operation (Op)
Definition: fs_evr.h:3572

EvtFsEFS_FlashEraseFailed
#define EvtFsEFS_FlashEraseFailed
Definition: fs_evr.h:227

EvrFsNFTL_BootSignatureValid
__STATIC_INLINE void EvrFsNFTL_BootSignatureValid(uint32_t instance)
Event on NFTL valid boot signatures (Op)
Definition: fs_evr.h:3422

EvtFsMcMCI_WriteXferSetupError
#define EvtFsMcMCI_WriteXferSetupError
Definition: fs_evr.h:410

EvtFsFAT_InitDriverError
#define EvtFsFAT_InitDriverError
Definition: fs_evr.h:75

EvrFsNAND_DeviceTimeoutError
__STATIC_INLINE void EvrFsNAND_DeviceTimeoutError(uint32_t instance, uint32_t driver, uint32_t device)
Event on NAND device timeout error (Error)
Definition: fs_evr.h:4385

EvtFsFAT_InitDriveSuccess
#define EvtFsFAT_InitDriveSuccess
Definition: fs_evr.h:73

EvrFsNFTL_SetupPageLayout
__STATIC_INLINE void EvrFsNFTL_SetupPageLayout(uint32_t instance, uint32_t sector_inc, uint32_t spare_ofs, uint32_t spare_inc)
Event on page layout setup (Detail)
Definition: fs_evr.h:4111

EvrFsNAND_PageWrite
__STATIC_INLINE void EvrFsNAND_PageWrite(uint32_t instance, uint32_t row, uint32_t col, uint32_t len)
Event on NAND page write operation (Op)
Definition: fs_evr.h:4438

EvtFsMcSPI_MediaDetectionMMC
#define EvtFsMcSPI_MediaDetectionMMC
Definition: fs_evr.h:432

EvrFsFAT_ClearReservedSectors
__STATIC_INLINE void EvrFsFAT_ClearReservedSectors(uint32_t drive, uint32_t sector, uint32_t count)
Event on FAT reserved sectors clear operation (Op)
Definition: fs_evr.h:1384

EvrFsFAT_FreeAmount
__STATIC_INLINE void EvrFsFAT_FreeAmount(uint32_t drive, uint32_t clus, uint32_t size)
Event on FAT free space retrieval (Op)
Definition: fs_evr.h:1983

EvrFsNFTL_WriteSector
__STATIC_INLINE void EvrFsNFTL_WriteSector(uint32_t instance, uint32_t sector, const uint8_t *buf, uint32_t cnt)
Event on NFTL write sector operation (Op)
Definition: fs_evr.h:3650

EvtFsFAT_VolumeWriteStatError
#define EvtFsFAT_VolumeWriteStatError
Definition: fs_evr.h:82

EvrFsCore_fformat
__STATIC_INLINE void EvrFsCore_fformat(const char *drive, const char *options)
Event on drive format (API)
Definition: fs_evr.h:750

EvtFsFAT_InitJournalFATError
#define EvtFsFAT_InitJournalFATError
Definition: fs_evr.h:133

EvtFsEFS_FreeSpaceRetrieve
#define EvtFsEFS_FreeSpaceRetrieve
Definition: fs_evr.h:209

EvtFsMcSPI_LockDeactivated
#define EvtFsMcSPI_LockDeactivated
Definition: fs_evr.h:450

EvrFsMcMCI_CardPowerControl
__STATIC_INLINE void EvrFsMcMCI_CardPowerControl(uint32_t instance, uint32_t voltage)
Event on memory card power control operation (Op)
Definition: fs_evr.h:5132

EvtFsFAT_CountFreeClus
#define EvtFsFAT_CountFreeClus
Definition: fs_evr.h:95

EvtFsNAND_InitDriverError
#define EvtFsNAND_InitDriverError
Definition: fs_evr.h:336

EvrFsFAT_FileDeleteSuccess
__STATIC_INLINE void EvrFsFAT_FileDeleteSuccess(uint32_t drive, const char *path)
Event on successful FAT file delete operation (Op)
Definition: fs_evr.h:1793

EvtFsMcMCI_ParameterInvalid
#define EvtFsMcMCI_ParameterInvalid
Definition: fs_evr.h:411

EvrFsNFTL_UninitDriver
__STATIC_INLINE void EvrFsNFTL_UninitDriver(uint32_t instance)
Event on NFTL driver uninitialization (Op)
Definition: fs_evr.h:3495

EvtFsFAT_InvalidParameter
#define EvtFsFAT_InvalidParameter
Definition: fs_evr.h:159

EvrFsEFS_FileAlreadyExists
__STATIC_INLINE void EvrFsEFS_FileAlreadyExists(uint32_t drive)
Event on EFS file already exists (Op)
Definition: fs_evr.h:2652

EvtFsNAND_DeviceReset
#define EvtFsNAND_DeviceReset
Definition: fs_evr.h:354

EvtFsFAT_NameCacheMiss
#define EvtFsFAT_NameCacheMiss
Definition: fs_evr.h:165

EvtFsEFS_AllocationAreaOverlap
#define EvtFsEFS_AllocationAreaOverlap
Definition: fs_evr.h:218

EvtFsMcSPI_LockUnlockExecError
#define EvtFsMcSPI_LockUnlockExecError
Definition: fs_evr.h:448

EvtFsCore_InvalidDrive
#define EvtFsCore_InvalidDrive
Definition: fs_evr.h:65

EvtFsCore_funmount
#define EvtFsCore_funmount
Definition: fs_evr.h:46

EvtFsNFTL_ParameterInvalid
#define EvtFsNFTL_ParameterInvalid
Definition: fs_evr.h:318

EvrFsEFS_FileNotFound
__STATIC_INLINE void EvrFsEFS_FileNotFound(uint32_t drive)
Event on EFS file not found (Op)
Definition: fs_evr.h:2640

EvtFsIOC_WriteSectorError
#define EvtFsIOC_WriteSectorError
Definition: fs_evr.h:251

EvtFsMcMCI_MediaSD_V2
#define EvtFsMcMCI_MediaSD_V2
Definition: fs_evr.h:368

EvrFsIOC_WriteSector
__STATIC_INLINE void EvrFsIOC_WriteSector(uint32_t drv_id, uint32_t sect, uint32_t buf, uint32_t cnt)
Event on call of fs_ioc_write_sector function (API)
Definition: fs_evr.h:3158

EvtFsNFTL_TableEntryNotFound
#define EvtFsNFTL_TableEntryNotFound
Definition: fs_evr.h:299

EvrFsMcMCI_DevCtrl
__STATIC_INLINE void EvrFsMcMCI_DevCtrl(uint32_t instance, uint32_t code, uint32_t p)
Event on memory card device control operation (Op)
Definition: fs_evr.h:4970

EvrFsNFTL_ReadInfo
__STATIC_INLINE void EvrFsNFTL_ReadInfo(uint32_t instance, uint32_t info)
Event on NFTL driver uninitialization (Op)
Definition: fs_evr.h:3520

EvtFsNFTL_LsnToLbn
#define EvtFsNFTL_LsnToLbn
Definition: fs_evr.h:294

EvrFsNFTL_PageProgramFailed
__STATIC_INLINE void EvrFsNFTL_PageProgramFailed(uint32_t instance, uint32_t row)
Event on NAND page program error (Error)
Definition: fs_evr.h:3948

EvrFsMcMCI_DeviceStateTimeout
__STATIC_INLINE void EvrFsMcMCI_DeviceStateTimeout(uint32_t instance, uint32_t cstate, uint32_t nstate)
Event on discovery of invalid device state (Error)
Definition: fs_evr.h:5071

EvtFsNFTL_SkipBadBlock
#define EvtFsNFTL_SkipBadBlock
Definition: fs_evr.h:309

EvtFsMcMCI_InitDriverPowerError
#define EvtFsMcMCI_InitDriverPowerError
Definition: fs_evr.h:359

EvtFsEFS_FileNotOpened
#define EvtFsEFS_FileNotOpened
Definition: fs_evr.h:196

EvrFsFAT_FileDelete
__STATIC_INLINE void EvrFsFAT_FileDelete(uint32_t drive, const char *path)
Event on FAT file delete (Op)
Definition: fs_evr.h:1780

EvrFsNFTL_DataBlockCapacity
__STATIC_INLINE void EvrFsNFTL_DataBlockCapacity(uint32_t instance, uint32_t capacity)
Event on NFTL invalid boot signatures (Op)
Definition: fs_evr.h:3447

EvtFsFAT_InitJournal
#define EvtFsFAT_InitJournal
Definition: fs_evr.h:131

EvtFsNFTL_BlockEraseTimeout
#define EvtFsNFTL_BlockEraseTimeout
Definition: fs_evr.h:316

EvtFsMcMCI_MediaWpActive
#define EvtFsMcMCI_MediaWpActive
Definition: fs_evr.h:364

EvrFsFAT_InvalidParameter
__STATIC_INLINE void EvrFsFAT_InvalidParameter(uint32_t drive)
Event on FAT invalid function parameter error (Error)
Definition: fs_evr.h:2019

EvtFsMcMCI_MediaCdActive
#define EvtFsMcMCI_MediaCdActive
Definition: fs_evr.h:362

EvrFsMcMCI_ReadXferSetupError
__STATIC_INLINE void EvrFsMcMCI_ReadXferSetupError(uint32_t instance, uint8_t *buf, uint32_t cnt, uint32_t size)
Event on TransferSetup error for block read operation (Op)
Definition: fs_evr.h:5161

EvrFsEFS_InitDriverFailed
__STATIC_INLINE void EvrFsEFS_InitDriverFailed(uint32_t drive, uint32_t driver)
Event on EFS driver initialization error (Error)
Definition: fs_evr.h:2246

EvrFsEFS_FlashEraseChip
__STATIC_INLINE void EvrFsEFS_FlashEraseChip(uint32_t drive)
Event on Flash chip erase operation (Op)
Definition: fs_evr.h:2394

EvrFsNFTL_FormatSuccess
__STATIC_INLINE void EvrFsNFTL_FormatSuccess(uint32_t instance)
Event on successful NFTL format operation (Op)
Definition: fs_evr.h:3584

EvtFsEFS_DriveAnalyzeSuccess
#define EvtFsEFS_DriveAnalyzeSuccess
Definition: fs_evr.h:212

EvrFsCore_ftime_get
__STATIC_INLINE void EvrFsCore_ftime_get(const char *path, fsTime *create, fsTime *access, fsTime *write)
Event on file or directory timestamp get (API)
Definition: fs_evr.h:879

EvrFsNAND_DriverPowerCtrlError
__STATIC_INLINE void EvrFsNAND_DriverPowerCtrlError(uint32_t instance, uint32_t driver, uint32_t state)
Event on NAND driver initialization error (Error)
Definition: fs_evr.h:4262

EvtFsMcMCI_TranStateError
#define EvtFsMcMCI_TranStateError
Definition: fs_evr.h:377

EvrFsFAT_WriteMBR
__STATIC_INLINE void EvrFsFAT_WriteMBR(uint32_t drive, uint32_t sector)
Event on Master Boot Record write operation (Op)
Definition: fs_evr.h:1343

EvtFsNFTL_RelocateBlockFailed
#define EvtFsNFTL_RelocateBlockFailed
Definition: fs_evr.h:308

EvtFsNFTL_BadBlockDetected
#define EvtFsNFTL_BadBlockDetected
Definition: fs_evr.h:288

EvrFsMcMCI_MediaSD_V2
__STATIC_INLINE void EvrFsMcMCI_MediaSD_V2(uint32_t instance)
Event on received response from SD memory card V2 (Op)
Definition: fs_evr.h:4641

EvrFsMcMCI_ReadInfo
__STATIC_INLINE void EvrFsMcMCI_ReadInfo(uint32_t instance)
Event on media capacity retrieval operation (Op)
Definition: fs_evr.h:4943

EvtFsMcMCI_SleepActive
#define EvtFsMcMCI_SleepActive
Definition: fs_evr.h:405

EvrFsFAT_DirRemove
__STATIC_INLINE void EvrFsFAT_DirRemove(uint32_t drive, const char *path, const char *options)
Event on FAT directory remove (Op)
Definition: fs_evr.h:1861

EvrFsFAT_PathIsTooLong
__STATIC_INLINE void EvrFsFAT_PathIsTooLong(uint32_t max_len)
Event on too long FAT path (Error)
Definition: fs_evr.h:1465

EvtFsEFS_FlashCapacity
#define EvtFsEFS_FlashCapacity
Definition: fs_evr.h:183

EvtFsMcMCI_TransferRetry
#define EvtFsMcMCI_TransferRetry
Definition: fs_evr.h:391

EvrFsEFS_FileOpenWriteMode
__STATIC_INLINE void EvrFsEFS_FileOpenWriteMode(uint32_t h)
Event on EFS when reading from write only file (Error)
Definition: fs_evr.h:2523

EvtFsFAT_InitMediaError
#define EvtFsFAT_InitMediaError
Definition: fs_evr.h:78

EvtFsNFTL_BBMPositionSet
#define EvtFsNFTL_BBMPositionSet
Definition: fs_evr.h:287

EvtFsCore_fdelete_l
#define EvtFsCore_fdelete_l
Definition: fs_evr.h:47

EvtFsMcSPI_DevCtrlUnsupported
#define EvtFsMcSPI_DevCtrlUnsupported
Definition: fs_evr.h:446

EvtFsFAT_FileSeekIncrease
#define EvtFsFAT_FileSeekIncrease
Definition: fs_evr.h:140

EvtFsMcSPI_ReadWpMissing
#define EvtFsMcSPI_ReadWpMissing
Definition: fs_evr.h:454

EvtFsMcSPI_InitDriverError
#define EvtFsMcSPI_InitDriverError
Definition: fs_evr.h:417

EvrFsMcSPI_CmdResponseError
__STATIC_INLINE void EvrFsMcSPI_CmdResponseError(uint32_t instance, uint32_t cmd)
Event on missing or invalid command response (Error)
Definition: fs_evr.h:5767

EvrFsFAT_FileRename
__STATIC_INLINE void EvrFsFAT_FileRename(uint32_t drive, const char *path, const char *newname)
Event on FAT file rename (Op)
Definition: fs_evr.h:1807

EvtFsNFTL_MoveData
#define EvtFsNFTL_MoveData
Definition: fs_evr.h:306

EvtFsNFTL_LoadTableLayout
#define EvtFsNFTL_LoadTableLayout
Definition: fs_evr.h:322

EvrFsFAT_ReadMBR
__STATIC_INLINE void EvrFsFAT_ReadMBR(uint32_t drive, uint32_t sector)
Event on Master Boot Record read operation (Op)
Definition: fs_evr.h:1061

EvtFsMcSPI_DriverSendError
#define EvtFsMcSPI_DriverSendError
Definition: fs_evr.h:456

EvtFsCore_fmkdir
#define EvtFsCore_fmkdir
Definition: fs_evr.h:54

EvtFsNFTL_CacheWrite
#define EvtFsNFTL_CacheWrite
Definition: fs_evr.h:330

EvtFsNAND_DriverEccInquireError
#define EvtFsNAND_DriverEccInquireError
Definition: fs_evr.h:344

EvtFsNAND_ParamPageRead
#define EvtFsNAND_ParamPageRead
Definition: fs_evr.h:352