#ifndef EFI_PROTOCOLS_MEDIA_ACCESS_H
#define EFI_PROTOCOLS_MEDIA_ACCESS_H

////
// Load File Protocol
///

#define EFI_LOAD_FILE_PROTOCOL_GUID {0x56ec3091,0x954c,0x11d2, {0x8e,0x3f,0x00,0xa0,0xc9,0x69,0x72,0x3b}}

typedef struct _EFI_LOAD_FILE_PROTOCOL EFI_LOAD_FILE_PROTOCOL;

typedef
EFI_STATUS
(EFIAPI *EFI_LOAD_FILE)(
	IN EFI_LOAD_FILE_PROTOCOL *This,
	IN EFI_DEVICE_PATH_PROTOCOL *FilePath,
	IN BOOLEAN BootPolicy,
	IN OUT UINTN *BufferSize,
	IN VOID *Buffer OPTIONAL
);

typedef struct _EFI_LOAD_FILE_PROTOCOL {
	EFI_LOAD_FILE LoadFile;
} EFI_LOAD_FILE_PROTOCOL;

////
// Load File 2 Protocol
///

#define EFI_LOAD_FILE2_PROTOCOL_GUID {0x4006c0c1,0xfcb3,0x403e, {0x99,0x6d,0x4a,0x6c,0x87,0x24,0xe0,0x6d}}

typedef EFI_LOAD_FILE_PROTOCOL EFI_LOAD_FILE2_PROTOCOL;

////
// File Protocol
///

#define EFI_FILE_PROTOCOL_REVISION								0x00010000
#define EFI_FILE_PROTOCOL_REVISION2								0x00020000
#define EFI_FILE_PROTOCOL_LATEST_REVISION						EFI_FILE_PROTOCOL_REVISION2

#define EFI_FILE_MODE_READ										0x0000000000000001
#define EFI_FILE_MODE_WRITE										0x0000000000000002
#define EFI_FILE_MODE_CREATE									0x8000000000000000

#define EFI_FILE_READ_ONLY										0x0000000000000001
#define EFI_FILE_HIDDEN											0x0000000000000002
#define EFI_FILE_SYSTEM											0x0000000000000004
#define EFI_FILE_RESERVED										0x0000000000000008
#define EFI_FILE_DIRECTORY										0x0000000000000010
#define EFI_FILE_ARCHIVE										0x0000000000000020
#define EFI_FILE_VALID_ATTR										0x0000000000000037

typedef struct _EFI_FILE_PROTOCOL EFI_FILE_PROTOCOL;

typedef struct {
	EFI_EVENT Event;
	EFI_STATUS Status;
	UINTN BufferSize;
	VOID *Buffer;
} EFI_FILE_IO_TOKEN;

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_OPEN)(
	IN EFI_FILE_PROTOCOL *This,
	OUT EFI_FILE_PROTOCOL **NewHandle,
	IN CHAR16 *FileName,
	IN UINT64 OpenMode,
	IN UINT64 Attributes
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_CLOSE)(
	IN EFI_FILE_PROTOCOL *This
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_DELETE)(
	IN EFI_FILE_PROTOCOL *This
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_READ)(
	IN EFI_FILE_PROTOCOL *This,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_WRITE)(
	IN EFI_FILE_PROTOCOL *This,
	IN OUT UINTN *BufferSize,
	IN VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_GET_POSITION)(
	IN EFI_FILE_PROTOCOL *This,
	OUT UINT64 Position
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_SET_POSITION)(
	IN EFI_FILE_PROTOCOL *This,
	IN UINT64 Position
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_GET_INFO)(
	IN EFI_FILE_PROTOCOL *This,
	IN EFI_GUID *InformationType,
	IN OUT UINTN *BufferSize,
	OUT VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_SET_INFO)(
	IN EFI_FILE_PROTOCOL *This,
	IN EFI_GUID *InformationType,
	IN UINTN BufferSize,
	IN VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_FLUSH)(
	IN EFI_FILE_PROTOCOL *This
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_OPEN_EX)(
	IN EFI_FILE_PROTOCOL *This,
	OUT EFI_FILE_PROTOCOL **NewHandle,
	IN CHAR16 *FileName,
	IN UINT64 OpenMode,
	IN UINT64 Attributes,
	IN OUT EFI_FILE_IO_TOKEN *Token
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_READ_EX)(
	IN EFI_FILE_PROTOCOL *This,
	IN OUT EFI_FILE_IO_TOKEN *Token
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_WRITE_EX)(
	IN EFI_FILE_PROTOCOL *This,
	IN OUT EFI_FILE_IO_TOKEN *Token
);

typedef
EFI_STATUS
(EFIAPI *EFI_FILE_FLUSH_EX)(
	IN EFI_FILE_PROTOCOL *This,
	IN OUT EFI_FILE_IO_TOKEN *Token
);

typedef struct _EFI_FILE_PROTOCOL {
	UINT64 Revision;

	EFI_FILE_OPEN Open;
	EFI_FILE_CLOSE Close;
	EFI_FILE_DELETE Delete;
	EFI_FILE_READ Read;
	EFI_FILE_WRITE Write;
	EFI_FILE_GET_POSITION GetPosition;
	EFI_FILE_SET_POSITION SetPosition;
	EFI_FILE_GET_INFO GetInfo;
	EFI_FILE_SET_INFO SetInfo;
	EFI_FILE_FLUSH Flush;

	// Added for revision 2
	EFI_FILE_OPEN_EX OpenEx;
	EFI_FILE_READ_EX ReadEx;
	EFI_FILE_WRITE_EX WriteEx;
	EFI_FILE_FLUSH_EX FlushEx;
} EFI_FILE_PROTOCOL;

////
// Simple File System Protocol
///

#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID {0x0964e5b22,0x6459,0x11d2, {0x8e,0x39,0x00,0xa0,0xc9,0x69,0x72,0x3b}}

#define EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_REVISION 0x00010000

typedef struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL EFI_SIMPLE_FILE_SYSTEM_PROTOCOL;

typedef
EFI_STATUS
(EFIAPI *EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME)(
	IN EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *This,
	OUT EFI_FILE_PROTOCOL **Root
);

typedef struct _EFI_SIMPLE_FILE_SYSTEM_PROTOCOL {
	UINT64 Revision;
	EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_OPEN_VOLUME OpenVolume;
} EFI_SIMPLE_FILE_SYSTEM_PROTOCOL;

////
// Disk I/O Protocol
///

#define EFI_DISK_IO_PROTOCOL_GUID {0xce345171,0xba0b,0x11d2, {0x8e,0x4f,0x00,0xa0,0xc9,0x69,0x72,0x3b}}

#define EFI_DISK_IO_PROTOCOL_REVISION 0x00010000

typedef struct _EFI_DISK_IO_PROTOCOL EFI_DISK_IO_PROTOCOL;

typedef
EFI_STATUS
(EFIAPI *EFI_DISK_READ)(
	IN EFI_DISK_IO_PROTOCOL *This,
	IN UINT32 MediaId,
	IN UINT64 Offset,
	IN UINTN BufferSize,
	OUT VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_DISK_WRITE)(
	IN EFI_DISK_IO_PROTOCOL *This,
	IN UINT32 MediaId,
	IN UINT64 Offset,
	IN UINTN BufferSize,
	IN VOID *Buffer
);

typedef struct _EFI_DISK_IO_PROTOCOL {
	UINT64 Revision;
	EFI_DISK_READ ReadDisk;
	EFI_DISK_WRITE WriteDisk;
} EFI_DISK_IO_PROTOCOL;

////
// Disk I/O 2 Protocol
///

#define EFI_DISK_IO2_PROTOCOL_GUID {0x151c8eae,0x7f2c,0x472c, {0x9e,0x54,0x98,0x28,0x19,0x4f,0x6a,0x88}}

#define EFI_DISK_IO2_PROTOCOL_REVISION 0x00020000

typedef struct _EFI_DISK_IO2_PROTOCOL EFI_DISK_IO2_PROTOCOL;

typedef struct {
	EFI_EVENT Event;
	EFI_STATUS TransactionStatus;
} EFI_DISK_IO2_TOKEN;

typedef
EFI_STATUS
(EFIAPI *EFI_DISK_CANCEL_EX)(
	IN EFI_DISK_IO2_PROTOCOL *This
);

typedef
EFI_STATUS
(EFIAPI *EFI_DISK_READ_EX)(
	IN EFI_DISK_IO2_PROTOCOL *This,
	IN UINT32 MediaId,
	IN UINT64 Offset,
	IN OUT EFI_DISK_IO2_TOKEN *Token,
	IN UINTN BufferSize,
	OUT VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_DISK_WRITE_EX)(
	IN EFI_DISK_IO2_PROTOCOL *This,
	IN UINT32 MediaId,
	IN UINT64 Offset,
	IN OUT EFI_DISK_IO2_TOKEN *Token,
	IN UINTN BufferSize,
	IN VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_DISK_FLUSH_EX)(
	IN EFI_DISK_IO2_PROTOCOL *This,
	IN OUT EFI_DISK_IO2_TOKEN *Token
);

typedef struct _EFI_DISK_IO2_PROTOCOL {
	UINT64 Revision;
	EFI_DISK_CANCEL_EX Cancel;
	EFI_DISK_READ_EX ReadDiskEx;
	EFI_DISK_WRITE_EX WriteDiskEx;
	EFI_DISK_FLUSH_EX FlushDiskEx;
} EFI_DISK_IO2_PROTOCOL;

////
// Block I/O Protocol
///

#define EFI_BLOCK_IO_PROTOCOL_GUID {0x964e5b21,0x6459,0x11d2, {0x8e,0x39,0x00,0xa0,0xc9,0x69,0x72,0x3b}}

#define EFI_BLOCK_IO_PROTOCOL_REVISION2 0x00020001
#define EFI_BLOCK_IO_PROTOCOL_REVISION3 ((2<<16) | (31))

typedef struct _EFI_BLOCK_IO_PROTOCOL EFI_BLOCK_IO_PROTOCOL;

typedef struct {
	UINT32 MediaId;
	BOOLEAN RemovableMedia;
	BOOLEAN MediaPresent;
	BOOLEAN LogicalPartition;
	BOOLEAN ReadOnly;
	BOOLEAN WriteCaching;
	UINT32 BlockSize;
	UINT32 IoAlign;
	EFI_LBA LastBlock;
	EFI_LBA LowestAlignedLba;
	UINT32 LogicalBlocksPerPhysicalBlock;
	UINT32 OptimalTransferLengthGranularity;
} EFI_BLOCK_IO_MEDIA;

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_RESET)(
	IN EFI_BLOCK_IO_PROTOCOL *This,
	IN BOOLEAN ExtendedVerification
);

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_READ)(
	IN EFI_BLOCK_IO_PROTOCOL *This,
	IN UINT32 MediaId,
	IN EFI_LBA LBA,
	IN UINTN BufferSize,
	OUT VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_WRITE)(
	IN EFI_BLOCK_IO_PROTOCOL *This,
	IN UINT32 MediaId,
	IN EFI_LBA LBA,
	IN UINTN BufferSize,
	IN VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_FLUSH)(
	IN EFI_BLOCK_IO_PROTOCOL *This
);

typedef struct _EFI_BLOCK_IO_PROTOCOL {
	UINT64 Revision;
	EFI_BLOCK_IO_MEDIA *Media;
	EFI_BLOCK_RESET Reset;
	EFI_BLOCK_READ ReadBlocks;
	EFI_BLOCK_WRITE WriteBlocks;
	EFI_BLOCK_FLUSH FlushBlocks;
} EFI_BLOCK_IO_PROTOCOL;

////
// Block I/O 2 Protocol
///

#define EFI_BLOCK_IO2_PROTOCOL_GUID {0xa77b2472,0xe282,0x4e9f, {0xa2,0x45,0xc2,0xc0,0xe2,0x7b,0xbc,0xc1}}

typedef struct _EFI_BLOCK_IO2_PROTOCOL EFI_BLOCK_IO2_PROTOCOL;

typedef struct {
	EFI_EVENT Event;
	EFI_STATUS TransactionStatus;
} EFI_BLOCK_IO2_TOKEN;

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_RESET_EX)(
	IN EFI_BLOCK_IO2_PROTOCOL *This,
	IN BOOLEAN ExtendedVerification
);

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_READ_EX)(
	IN EFI_BLOCK_IO2_PROTOCOL *This,
	IN UINT32 MediaId,
	IN EFI_LBA LBA,
	IN OUT EFI_BLOCK_IO2_TOKEN *Token,
	IN UINTN BufferSize,
	OUT VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_WRITE_EX)(
	IN EFI_BLOCK_IO2_PROTOCOL *This,
	IN UINT32 MediaId,
	IN EFI_LBA LBA,
	IN OUT EFI_BLOCK_IO2_TOKEN *Token,
	IN UINTN BufferSize,
	IN VOID *Buffer
);

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_FLUSH_EX)(
	IN EFI_BLOCK_IO2_PROTOCOL *This,
	IN OUT EFI_BLOCK_IO2_TOKEN *Token
);

typedef struct _EFI_BLOCK_IO2_PROTOCOL {
	EFI_BLOCK_IO_MEDIA *Media;
	EFI_BLOCK_RESET_EX Reset;
	EFI_BLOCK_READ_EX ReadBlocksEx;
	EFI_BLOCK_WRITE_EX WriteBlocksEx;
	EFI_BLOCK_FLUSH_EX FlushBlocksEx;
} EFI_BLOCK_IO2_PROTOCOL;

////
// Inline Cryptographics Interface Protocol
///

#define EFI_BLOCK_IO_CRYPTO_PROTOCOL_GUID {0xa00490ba,0x3f1a,0x4b4c, {0xab,0x90,0x4f,0xa9,0x97,0x26,0xa1,0xe8}}

#define EFI_BLOCK_IO_CRYPTO_ALGO_GUID_AES_XTS {0x2f87ba6a,0x5c04,0x4385,0xa7,0x80,0xf3,0xbf,0x78,0xa9,0x7b,0xec}
#define EFI_BLOCK_IO_CRYPTO_ALGO_GUID_AES_CBC_MICROSOFT_BITLOCKER {0x689e4c62,0x70bf,0x4cf3,0x88,0xbb,0x33,0xb3,0x18,0x26,0x86,0x70}

#define EFI_BLOCK_IO_CRYPTO_INDEX_ANY 0xFFFFFFFFFFFFFFFF

typedef struct _EFI_BLOCK_IO_CRYPTO_PROTOCOL EFI_BLOCK_IO_CRYPTO_PROTOCOL;

typedef struct {
	EFI_GUID Algorithm;
	UINT64 KeySize;
	UINT64 CryptoBlockSizeBitMask;
} EFI_BLOCK_IO_CRYPTO_CAPABILITY;

typedef struct {
	BOOLEAN Supported;
	UINT64 KeyCount;
	UINT64 CapabilityCount;
	EFI_BLOCK_IO_CRYPTO_CAPABILITY Capabilities [1];
} EFI_BLOCK_IO_CRYPTO_CAPABILITIES;

typedef struct {
	UINT64 Index;
	EFI_GUID KeyOwnerGuid;
	EFI_BLOCK_IO_CRYPTO_CAPABILITY Capability;
	VOID *CryptoKey;
} EFI_BLOCK_IO_CRYPTO_CONFIGURATION_TABLE_ENTRY;

typedef struct {
	UINT64 Index;
	EFI_GUID KeyOwnerGuid;
	EFI_BLOCK_IO_CRYPTO_CAPABILITY Capability;
} EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY;

typedef struct {
	UINT64 InputSize;
} EFI_BLOCK_IO_CRYPTO_IV_INPUT;

typedef struct {
	EFI_BLOCK_IO_CRYPTO_IV_INPUT Header;
	UINT64 CryptoBlockNumber;
	UINT64 CryptoBlockByteSize;
} EFI_BLOCK_IO_CRYPTO_IV_INPUT_AES_XTS;

typedef struct {
	EFI_BLOCK_IO_CRYPTO_IV_INPUT Header;
	UINT64 CryptoBlockByteOffset;
	UINT64 CryptoBlockByteSize;
} EFI_BLOCK_IO_CRYPTO_IV_INPUT_AES_CBC_MICROSOFT_BITLOCKER;

typedef struct {
	EFI_EVENT Event;
	EFI_STATUS TransactionStatus;
} EFI_BLOCK_IO_CRYPTO_TOKEN;

typedef
EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_RESET)(
	IN EFI_BLOCK_IO_CRYPTO_PROTOCOL *This,
	IN BOOLEAN ExtendedVerification
);

typedef EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_GET_CAPABILITIES)(
	IN EFI_BLOCK_IO_CRYPTO_PROTOCOL *This,
	OUT EFI_BLOCK_IO_CRYPTO_CAPABILITIES *Capabilities
);

typedef EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_SET_CONFIGURATION)(
	IN EFI_BLOCK_IO_CRYPTO_PROTOCOL *This,
	IN UINT64 ConfigurationCount,
	IN EFI_BLOCK_IO_CRYPTO_CONFIGURATION_TABLE_ENTRY *ConfigurationTable,
	OUT EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY
	*ResultingTable OPTIONAL
);

typedef EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_GET_CONFIGURATION)(
	IN EFI_BLOCK_IO_CRYPTO_PROTOCOL *This,
	IN UINT64 StartIndex,
	IN UINT64 ConfigurationCount,
	IN EFI_GUID *KeyOwnerGuid OPTIONAL,
	OUT EFI_BLOCK_IO_CRYPTO_RESPONSE_CONFIGURATION_ENTRY *ConfigurationTable
);

typedef EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_READ_EXTENDED)(
	IN EFI_BLOCK_IO_CRYPTO_PROTOCOL *This,
	IN UINT32 MediaId,
	IN EFI_LBA LBA,
	IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN *Token,
	IN UINT64 BufferSize,
	OUT VOID *Buffer,
	IN UINT64 *Index OPTIONAL,
	IN VOID *CryptoIvInput OPTIONAL
);

typedef EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_WRITE_EXTENDED)(
	IN EFI_BLOCK_IO_CRYPTO_PROTOCOL *This,
	IN UINT32 MediaId,
	IN EFI_LBA LBA,
	IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN *Token,
	IN UINT64 BufferSize,
	IN VOID *Buffer,
	IN UINT64 *Index, OPTIONAL
	IN VOID *CryptoIvInput OPTIONAL
);

typedef EFI_STATUS
(EFIAPI *EFI_BLOCK_IO_CRYPTO_FLUSH)(
	IN EFI_BLOCK_IO_CRYPTO_PROTOCOL *This,
	IN OUT EFI_BLOCK_IO_CRYPTO_TOKEN *Token
);

typedef struct _EFI_BLOCK_IO_CRYPTO_PROTOCOL {
	EFI_BLOCK_IO_MEDIA *Media;
	EFI_BLOCK_IO_CRYPTO_RESET Reset;
	EFI_BLOCK_IO_CRYPTO_GET_CAPABILITIES GetCapabilities;
	EFI_BLOCK_IO_CRYPTO_SET_CONFIGURATION SetConfiguration;
	EFI_BLOCK_IO_CRYPTO_GET_CONFIGURATION GetConfiguration;
	EFI_BLOCK_IO_CRYPTO_READ_EXTENDED ReadExtended;
	EFI_BLOCK_IO_CRYPTO_WRITE_EXTENDED WriteExtended;
	EFI_BLOCK_IO_CRYPTO_FLUSH FlushBlocks;
} EFI_BLOCK_IO_CRYPTO_PROTOCOL;

////
// Erase Block Protocol
///

#define EFI_ERASE_BLOCK_PROTOCOL_GUID {0x95a9a93e,0xa86e,0x4926, {0xaa,0xef,0x99,0x18,0xe7,0x72,0xd9,0x87}}

#define EFI_ERASE_BLOCK_PROTOCOL_REVISION ((2<<16) (60))

typedef struct _EFI_ERASE_BLOCK_PROTOCOL EFI_ERASE_BLOCK_PROTOCOL;

typedef struct {
	EFI_EVENT Event;
	EFI_STATUS TransactionStatus;
} EFI_ERASE_BLOCK_TOKEN;

typedef
EFI_STATUS*
(EFIAPI *EFI_BLOCK_ERASE)(
	IN EFI_BLOCK_IO_PROTOCOL *This,
	IN UINT32 MediaId,
	IN EFI_LBA LBA,
	IN OUT EFI_ERASE_BLOCK_TOKEN *Token,
	IN UINTN Size
);

typedef struct _EFI_ERASE_BLOCK_PROTOCOL {
	UINT64 Revision;
	UINT32 EraseLengthGranularity;
	EFI_BLOCK_ERASE EraseBlocks;
} EFI_ERASE_BLOCK_PROTOCOL;

////
// ATA Pass Through Protocol
///



////
// Storage Security Command Protocol
///



////
// NVM Express Pass Through Protocol
///



////
// SD MMC Pass Through Protocol
///



////
// RAM Disk Protocol
///



////
// Partition Information Protocol
///



////
// NVDIMM Label Protocol
///



////
// EFI UFS Device Config Protocol
///




#endif /* EFI_PROTOCOLS_MEDIA_ACCESS_H */