📄 rtfiles.h
字号:
const char * Path,
const RTFDOSDirEntry * FileInfo,
DWORD N1,
DWORD N2);
#ifndef _WINDOWS_
typedef struct {
DWORD Reserved[12];
} CRITICAL_SECTION;
#endif
typedef struct RTFMutex_t {
kal_semid rtf_sem;
kal_taskid rtf_sem_owner;
kal_uint32 rtf_lock_count;
/* Solve MMI hang for waiting lock, Karen Hsu, 2004/04/23, ADD START */
int DeviceNum_1;
int DeviceNum_2;
/* Solve MMI hang for waiting lock, Karen Hsu, 2004/04/23, ADD END */
} RTFMutex; /* ! Must SYNC ! */
typedef RTFMutex RTFSemaphore;
typedef struct rtfdriver {
//UINT Version;
int (RTFAPI * MountDevice) (void * DriveData, int DeviceNumber, int DeviceType, DWORD Flags);
int (RTFAPI * ShutDown) (void * DriveData);
int (RTFAPI * ReadSectors) (void * DriveData, RTFSector Sector, UINT Sectors, void * Buffer);
int (RTFAPI * WriteSectors) (void * DriveData, RTFSector Sector, UINT Sectors, void * Buffer);
int (RTFAPI * MediaChanged) (void * DriveData);
int (RTFAPI * DiscardSectors) (void * DriveData, RTFSector Sector, UINT Sectors);
int (RTFAPI * GetDiskGeometry)(void * DriveData, RTFPartitionRecord * DiskGeometry, BYTE * MediaDescriptor);
int (RTFAPI * LowLevelFormat) (void * DriveData, const char * DeviceName, RTFFormatCallback Progress, DWORD Flags);
int (RTFAPI * NonBlockWriteSectors) (void * DriveData, RTFSector Sector, UINT Sectors, void * Buffer);
int (RTFAPI * RecoverableWriteSectors)(void * DriveData, RTFSector Sector, UINT Sectors, void * Buffer); // Recoverable support
int (RTFAPI * ResumeSectorStates) (void * DriveData); // Recoverable support
int (RTFAPI * HighLevelFormat)(void * DriveData); /* Add for general format, Karen Hsu, 2004/02/09 */
int (RTFAPI * FlushData) (void * DriveData); /* Add for 2KB page NAND, Karen Hsu, 2004/08/30 */
int (RTFAPI * MessageAck) (void * DriveData, int type); /* Add for USB OTG Device, 2005/12/13 */
int (RTFAPI * CopySectors) (void * DriveData, RTFSector SrcSector, RTFSector DstSector, UINT Sectors); /* Add for XCOPY Speed up, 2006/06/15 */
int (RTFAPI * OTPAccess) (void * DriveData, int type, UINT Offset, void * BufferPtr, UINT Length); /* Add for OTP device IO, 2006/06/29 */
int (RTFAPI * OTPQueryLength) (void * DriveData, UINT *Length); /* Add for OTP device IO, 2006/06/29 */
} RTFDriver; /* ! Must SYNC ! */
struct _rtfDrive;
struct _rtfBuffer;
typedef struct {
RTFMutex * Lock;
struct _rtfDrive * FirstDrive;
BYTE MediaPresent;
BYTE MediaRemovedReported; // set to zero when MediaPresent is set to zero
BYTE Reserved;
BYTE MountState;
int SectorSize;
RTFPartitionRecord Geometry; // size = 4 DWORDs
UINT SectorShift;
UINT AccessCount;
struct _rtfBuffer *B; // temporary buffer
struct _rtfBuffer *AltBuffer; // temporary buffer for critical errors
int ErrorCondition; // keep returning this until it is remounted
int PhysicalDiskIndex;
char FriendlyName[7]; // "Disk X"
BYTE MediaDescriptor;
} RTFDeviceData; /* ! Must SYNC ! */
typedef struct _rtfDevice {
int DeviceType;
int DeviceNumber;
DWORD DeviceFlags;
RTFDriver * Driver;
void * DriverData; // total size = 5 DWORD
RTFDeviceData DevData; // size = 16 DWORDS
} RTFDevice; /* ! Must SYNC ! */
// driver specific data for well known drivers
// Windows NT driver, do not use for embedded systems
typedef struct {
int DeviceType;
DWORD Flags;
HANDLE FileHandle;
CRITICAL_SECTION CS;
// just for diagnostics
DWORD LastStatus;
DWORD SectorSize;
DWORD SectorsPerTrack;
DWORD Heads;
} RTFDrvNTData;
// ATA-IDE driver
typedef struct {
void * ReadAheadBuffer;
UINT ReadAheadBufferSize;
UINT PortBase;
UINT InitTimeout;
UINT DiskTimeout;
UINT ControllerTimeout;
UINT IRQ;
UINT Cylinders;
UINT Heads;
UINT SectorsPerTrack;
UINT MaxSectors;
UINT DeviceNumber; // 0 or 1
UINT Controller; // 0 to 3
RTFSector TotalSector;
RTFSector InBufferSector;
RTFSector InBufferSectors;
DWORD ExtraReads;
DWORD SavedReads;
DWORD SavedAccesses;
DWORD Flags;
} RTFDrvIDEData;
// Floppy driver
// these are also used as media identifiers. 0 means unknown.
// drive types never change, but medias can
#define RTF_FPLY_DRIVE_UNKNOWN 0
#define RTF_FPLY_DRIVE_360 1
#define RTF_FPLY_DRIVE_1200 2
#define RTF_FPLY_DRIVE_720 3
#define RTF_FPLY_DRIVE_1440 4
#define RTF_FPLY_DRIVE_2880 5
typedef struct {
BYTE CommandByte2; // use 0xDF
BYTE CommandByte3; // HeadLoadTime, use 0x02
BYTE MotorTimeout; // 55ms timer ticks, use 0x25
BYTE SectorSize; // use 2 for 512 bytes
BYTE LastSector; // media dependent, don't use
BYTE GapLength; // media dependent, don't use
BYTE CommandByte8; // DataLength, use 0xFF
BYTE FormatGapLength; // media dependent, don't use
BYTE FormatFillByte; // use 0xF6
BYTE HeadSettleTime; // use 0x0F (milliseconds)
BYTE MotorStartupTime; // 8th of a second, use 8 (only used from write)
} RTF_FPLY_BIOS_Disk_Parameter;
typedef struct {
UINT DeviceType; // 0 to have the driver ask the BIOS CMOS RAM
RTF_FPLY_BIOS_Disk_Parameter * DPT; // NULL to use default
UINT DiskTimeout; // 0 for default of 2000 milliseconds
UINT ControllerTimeout; // 0 for default 500 milliseconds
UINT Retries; // 3 by default
UINT DeviceNumber;
UINT Media;
UINT CurrentTrack;
UINT RetryCount;
UINT ReadAheadSectors;
DWORD ExtraReads;
DWORD SavedReads;
DWORD SavedAccesses;
DWORD Flags;
BYTE CtrStatus[7];
} RTFDrvFLPYData;
// RAM Disk
typedef struct {
RTFSector Sectors;
DWORD Reserved1, Reserved2;
UINT SectorsPerSegment;
void * * * MasterSegment;
} RTFDrvRAMData;
// BIOS Driver
typedef struct {
void * ReadAheadBuffer;
UINT ReadAheadBufferSize;
UINT LockIndex;
UINT Retries;
UINT DeviceNumber;
UINT DeviceType;
UINT SectorsPerTrack;
UINT Heads;
UINT RetryCount;
UINT InBufferSectors;
RTFSector InBufferSector;
DWORD ExtraReads;
DWORD SavedReads;
DWORD SavedAccesses;
DWORD Flags;
} RTFDrvBIOSData;
// DiskOnChip 2000
typedef struct {
unsigned DeviceNumber;
} RTFDrvDOCData;
// PCMCIA SRAM card driver
typedef struct {
RTFSector Sectors;
BYTE * WinAddrP; // physical address of window
BYTE * WinAddrV; // virtual address of window
RTFSector WinSize; // in sectors
RTFSector CurrSec;
int Socket;
DWORD Flags;
} RTFDrvSRAMData;
// port i/o routines for the drivers
RTTDLL BYTE RTFAPI RTIn (UINT Port);
RTTDLL WORD RTFAPI RTInW (UINT Port);
RTTDLL DWORD RTFAPI RTInD (UINT Port);
RTTDLL void RTFAPI RTOut (UINT Port, BYTE val);
RTTDLL void RTFAPI RTOutW (UINT Port, WORD val);
RTTDLL void RTFAPI RTOutD (UINT Port, DWORD val);
RTTDLL void * RTFAPI RTInSW (UINT Port, void * Buffer, UINT Bytes);
RTTDLL void * RTFAPI RTInSD (UINT Port, void * Buffer, UINT Bytes);
RTTDLL void * RTFAPI RTOutSW(UINT Port, void * Buffer, UINT Bytes);
RTTDLL void * RTFAPI RTOutSD(UINT Port, void * Buffer, UINT Bytes);
// 32-bit disk drivers
RTTDDL RTFDriver RTFDrvNT; // Windows NT driver (not for embedded systems)
RTTDDL RTFDriver RTFDrvIDE; // ATA-IDE driver
RTTDDL RTFDriver RTFDrvFloppy; // floppy disk driver
RTTDDL RTFDriver RTFDrvRAM; // RAM disk driver
RTTDDL RTFDriver RTFDrvDOC; // M-Systems DiskOnChip 2000 driver
RTTDDL RTFDriver RTFDrvSRAM; // PCMCIA SRAM card driver
RTTDDL RTFDriver RTFDrvNULL; // Dummy driver to reserve driver letters
RTTDDL RTFDriver RTFDrvFlash; // linear flash driver
// 16-bit disk drivers
RTTDDL RTFDriver RTFDrvBIOS; // BIOS int 13h driver
RTTDDL RTFDriver RTFDrvRAM; // RAM disk driver
RTTDDL RTFDriver RTFDrvNULL; // dummy driver to reserve driver letters
// The device list
RTTDDL RTFDevice gFS_DeviceList[]; /* Move to custom, Karen Hsu, 2004/08/30 */
//RTTDDL RTFDevice RTFDeviceList[];
struct _rtfDevice;
struct _rtfDrive;
typedef struct _rtfBuffer {
struct _rtfBuffer * Next;
struct _rtfBuffer * Prev;
RTFDevice * Dev;
BYTE * Data;
RTFSector Sector;
struct _rtfDrive * FATSectorInfo;
UINT Flags;
UINT FirstDirtyTime,
LastDirtyTime;
int Num; // for debugging only
BYTE recoverable_flag; // 1 means the buffer needs recoverablewritesector, 0 means not
#define RTF_RECOVERABLE_WRITE 1
#define RTF_NORMAL_WRITE 0
} RTFBuffer; /* ! Must SYNC ! */
typedef struct {
RTFCluster Cluster; // zero if none
UINT Index; // undefined if none
} RTFDirLocation; /* ! Must SYNC ! */
typedef struct {
RTFCluster DirCluster; // start of dir containing this entry
RTFDirLocation LongPos;
RTFDirLocation ShortPos;
RTFDOSDirEntry Dir;
} RTFDirEntry; /* ! Must SYNC ! */
typedef struct _rtfDrive {
struct _rtfDevice * Dev;
struct _rtfDrive * NextDrive;
int MountState; // see type MountStates
RTFPartitionRecord Geometry;
RTFCluster Clusters; // 1 + last valid cluster value, actual value +2
UINT SectorsPerCluster;
DWORD ClusterSize; // in bytes
UINT ClusterShift;
UINT SPerCShift; // sector per cluster shift
UINT FATType;
UINT FATCount;
DWORD SectorsPerFAT;
RTFCluster ClusterWatermark;
RTFCluster FreeClusterCount; // 0xFFFFFFFF if unknown
RTFSector InfoSector; // 0 if none
DWORD SerialNumber;
RTFSector FirstSector;
RTFSector FirstFATSector;
RTFSector FirstDirSector; // this is the first root dir cluster on FAT-32
RTFSector FirstDataSector;
UINT RootDirEntries; // not used on FAT-32
RTFDirEntry CurrDirEntry;
char CurrDir[RTF_MAX_PATH]; // "X:\[Dir]"
/* Add for quota management, Karen Hsu, 2004/07/12, ADD START */
#ifdef __FS_QM_SUPPORT__
BYTE QuotaMgt;
BYTE Reserved[3];
#endif
/* Add for quota management, Karen Hsu, 2004/07/12, ADD END */
} RTFDrive; /* ! Must SYNC ! */
typedef struct {
RTFDrive * Drive; // NULL for physical disk files
RTFDevice * Dev; // redundant for data and volume files
int SpecialKind;
UINT Unique;
DWORD Flags;
RTFDirEntry DirEntry;
DWORD FilePointer;
RTFCluster LastCluster; // cluster preceeding Cluster (A1 and A2 for search handles)
RTFCluster Cluster; // cluster containing FilePointer (RTFDirLocation for search handles)
DWORD Offset; // within Cluster (ditto)
char FullName[RTF_MAX_PATH];
void * Task; /* ADD for garbage collection, Karen Hsu, 2004/04/16 */
/* Speedup seek, Karen Hsu, 2004/08/24, ADD START */
UINT HintNum;
RTFDirLocation * Seek_Hint;
/* Speedup seek, Karen Hsu, 2004/08/24, ADD END */
BYTE Lock;
/* Modified for hot plug I/O, Karen Hsu, 2004/02/04, ADD START */
BYTE Valid;
BYTE Reserved[sizeof(int) - 2*sizeof(BYTE)]; // integer alignment
//BYTE Reserved[sizeof(int) - sizeof(BYTE)]; // integer alignment
/* Modified for hot plug I/O, Karen Hsu, 2004/02/04, ADD END */
} RTFile; /* ! Must SYNC ! */
typedef struct {
RTFDrive * DriveTable;
RTFile * FileTable;
RTFBuffer * BufferTable;
BYTE * BufferData;
} RTFTables; /* ! Must SYNC ! */
#if defined(WIN32)
#pragma pack(1)
#endif
typedef ONE_BYTE_ALIGN_ADS struct {
DWORD Signature1; // 0x41615252l
BYTE Reserved[480];
DWORD Signature2; // 0x61417272l
RTFCluster FreeClusterCount; // 0xFFFFFFFF for unkown, not guaranteed to be correct
RTFCluster NextFreeCluster; // 0xFFFFFFFF for unkown, start free cluster search here, not guaranteed to be correct
BYTE Reserved2[12];
DWORD Signature; // 0xAA550000l
} RTFFAT32InfoSector;
typedef ONE_BYTE_ALIGN_ADS struct {
BYTE PhysicalDiskNumber; // 0x80, 0x81, etc.
BYTE CurrentHead; // not used
BYTE Signature; // needed by NT
DWORD SerialNumber;
BYTE Label[11]; // not used
char SystemID[8];
} RTFExtendedBIOSParameter; /* ! Must SYNC ! */
typedef ONE_BYTE_ALIGN_ADS struct {
char OEMName[8];
WORD BytesPerSector;
BYTE SectorsPerCluster;
WORD ReservedSectors; // relative to partition start
BYTE NumberOfFATs;
WORD DirEntries; // zero on FAT-32
WORD SectorsOnDisk;
BYTE MediaDescriptor;
WORD SectorsPerFAT; // zero on FAT-32
WORD SectorsPerTrack;
WORD NumberOfHeads;
RTFSector NumberOfHiddenSectors; // OS specific, unreliable
RTFSector TotalSectors;
ONE_BYTE_ALIGN_ADS union {
ONE_BYTE_ALIGN_ADS struct {
RTFExtendedBIOSParameter BPB;
} _16;
ONE_BYTE_ALIGN_ADS struct {
RTFCluster SectorsPerFAT;
WORD Flags; // if (Flags & 0x0080) { SingleFAT; ActiveFat = (Flags & 0x000F); }
WORD Version;
RTFCluster RootDirCluster;
WORD FSInfoSector; // relative to start of partition, usually 1, 0xFFFF for none.
WORD BackupBootSector; // usually 6
BYTE Reserved[12]; // should be all zero
RTFExtendedBIOSParameter BPB;
} _32;
} E;
} RTFBIOSParameter; /* ! Must SYNC ! */
typedef ONE_BYTE_ALIGN_ADS struct {
BYTE BootCode[512-4*sizeof(RTFPartitionRecord)-sizeof(WORD)];
RTFPartitionRecord PTable[4];
WORD Signature;
} RTFMasterBootRecord; /* ! Must SYNC ! */
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -