/** @file
  PartitionDxe.h -- Header for PartitionDxe

Copyright (c) HR650X BIOS Decompilation Project
**/

#ifndef __PARTITIONDXE_H__
#define __PARTITIONDXE_H__

#include "../uefi_headers/Uefi.h"

//
// Function Prototypes
//

EFI_STATUS
EFIAPI
PartitionDriverEntryPoint(
  VOID
);

EFI_STATUS
EFIAPI
PartitionDriverBindingSupported(
  VOID
);

EFI_STATUS
EFIAPI
PartitionDriverBindingStart(
  VOID
);

EFI_STATUS
EFIAPI
PartitionDriverBindingStop(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIoReset(
  VOID
);

EFI_STATUS
EFIAPI
PartitionReturnChildError(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIoReadBlocks(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIoWriteBlocks(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIoFlushBlocks(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIo2Reset(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIo2ReadWriteCommon(
  VOID
);

EFI_STATUS
EFIAPI
PartitionCreateMediaDevicePathNode(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIo2ReadBlocks(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIo2WriteBlocks(
  VOID
);

EFI_STATUS
EFIAPI
PartitionBlockIo2FlushBlocks(
  VOID
);

EFI_STATUS
EFIAPI
PartitionCreateChildHandles(
  VOID
);

EFI_STATUS
EFIAPI
PartitionComponentNameUnsupported(
  VOID
);

EFI_STATUS
EFIAPI
PartitionCheckOverlap(
  VOID
);

EFI_STATUS
EFIAPI
PartitionRegisterOverlap(
  VOID
);

EFI_STATUS
EFIAPI
PartitionUnregisterOverlap(
  VOID
);

EFI_STATUS
EFIAPI
PartitionValidMbr(
  VOID
);

EFI_STATUS
EFIAPI
PartitionInstallMbrChildHandles(
  VOID
);

EFI_STATUS
EFIAPI
PartitionInstallGptChildHandles(
  VOID
);

EFI_STATUS
EFIAPI
PartitionCheckGptTable(
  VOID
);

EFI_STATUS
EFIAPI
PartitionCheckGptEntryArrayCrc(
  VOID
);

EFI_STATUS
EFIAPI
PartitionWriteGptTable(
  VOID
);

EFI_STATUS
EFIAPI
PartitionCheckGptEntries(
  VOID
);

EFI_STATUS
EFIAPI
PartitionInstallEltChildHandles(
  VOID
);

EFI_STATUS
EFIAPI
GetSupportedLanguages(
  VOID
);

EFI_STATUS
EFIAPI
variable definitions(
  VOID
);

EFI_STATUS
EFIAPI
ImageHandle_0    = 0;  // 0x4E40(
  VOID
);

EFI_STATUS
EFIAPI
EFI_HANDLE                ImageHandle      = 0;  // 0x4EC8(
  VOID
);

EFI_STATUS
EFIAPI
EFI_BOOT_SERVICES        *BootServices     = NULL; // 0x4EC0(
  VOID
);

EFI_STATUS
EFIAPI
UINT16                    i                = 0;   // 0x4EB0 - Index for overlap entries(
  VOID
);

EFI_STATUS
EFIAPI
detection table (0x32 entries x 32 bytes = 0xA00 bytes at 0x4F00)(
  VOID
);

EFI_STATUS
EFIAPI
byte_4F00[0xA00] = {0};(
  VOID
);

EFI_STATUS
EFIAPI
GUIDs(
  VOID
);

EFI_STATUS
EFIAPI
CLSID_PARTITION_SYSTEM_GUID = { 0xc12a7328, 0xf81f, 0x11d2, { 0xba, 0x4b, 0x00, 0xa0, 0xc9, 0x3e, 0xc9, 0x3b } };  // 0x4DA0(
  VOID
);

EFI_STATUS
EFIAPI
EFI_GUID                  Guid2                       = { 0x00000000, 0x0000, 0x0000, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } };  // 0x4EA0 (zero GUID)(
  VOID
);

EFI_STATUS
EFIAPI
detection function table(
  VOID
);

EFI_STATUS
EFIAPI
in order: GPT first, then El Torito, then MBR(
  VOID
);

EFI_STATUS
EFIAPI
gPartitionDetectionTable[] = {(
  VOID
);

EFI_STATUS
EFIAPI
partitions(
  VOID
);

EFI_STATUS
EFIAPI
Torito (CD-ROM)(
  VOID
);

EFI_STATUS
EFIAPI
};(
  VOID
);

EFI_STATUS
EFIAPI
Binding protocol instance(
  VOID
);

EFI_STATUS
EFIAPI
gPartitionDriverBinding = {(
  VOID
);

EFI_STATUS
EFIAPI
NULL,           // ImageHandle(
  VOID
);

EFI_STATUS
EFIAPI
Name 2 protocol instance(
  VOID
);

EFI_STATUS
EFIAPI
gPartitionComponentName2 = {(
  VOID
);

EFI_STATUS
EFIAPI
(driver-specific)(
  VOID
);

EFI_STATUS
EFIAPI
languages table(
  VOID
);

EFI_STATUS
EFIAPI
gSupportedLanguages[] = {(
  VOID
);

EFI_STATUS
EFIAPI
{ NULL, NULL }         // Terminator(
  VOID
);

EFI_STATUS
EFIAPI
used for Component Name protocols(
  VOID
);

EFI_STATUS
EFIAPI
*gComponentNameDriverName[] = { "eng", "en" };  // 0x3F50, 0x3F54(
  VOID
);

EFI_STATUS
EFIAPI
Entry Point(
  VOID
);

EFI_STATUS
EFIAPI
(not supported)(
  VOID
);

EFI_STATUS
EFIAPI
status(
  VOID
);

EFI_STATUS
EFIAPI
Binding Protocol(
  VOID
);

EFI_STATUS
EFIAPI
a remaining device path is provided, validate it(
  VOID
);

EFI_STATUS
EFIAPI
be NULL, end instance, or a valid hard drive media device path(
  VOID
);

EFI_STATUS
EFIAPI
(RemainingDevicePath != NULL &&(
  VOID
);

EFI_STATUS
EFIAPI
if controller has DevicePath protocol(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->OpenProtocol((
  VOID
);

EFI_STATUS
EFIAPI
if controller has Block IO protocol (the primary requirement)(
  VOID
);

EFI_STATUS
EFIAPI
check for Component Name 2 to verify it's a full disk controller(
  VOID
);

EFI_STATUS
EFIAPI
previous TPL and raise to TPL_CALLBACK(
  VOID
);

EFI_STATUS
EFIAPI
= RemainingDevicePath;(
  VOID
);

EFI_STATUS
EFIAPI
remaining device path is an end instance, nothing to do(
  VOID
);

EFI_STATUS
EFIAPI
(RemainingDevicePath != NULL && IsDevicePathEndInstance(RemainingDevicePath)) {(
  VOID
);

EFI_STATUS
EFIAPI
Block IO protocol(
  VOID
);

EFI_STATUS
EFIAPI
Disk IO protocol (optional - needed for GPT backup restore)(
  VOID
);

EFI_STATUS
EFIAPI
Device Path protocol(
  VOID
);

EFI_STATUS
EFIAPI
Block IO2 protocol (optional)(
  VOID
);

EFI_STATUS
EFIAPI
= NULL;(
  VOID
);

EFI_STATUS
EFIAPI
media info(
  VOID
);

EFI_STATUS
EFIAPI
= BlockIo;(
  VOID
);

EFI_STATUS
EFIAPI
each partition detection method(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; gPartitionDetectionTable[Index] != NULL; Index++) {(
  VOID
);

EFI_STATUS
EFIAPI
no partitions found, clean up protocols(
  VOID
);

EFI_STATUS
EFIAPI
(DevicePath != NULL || BlockIo2 != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
all protocols opened by Start()(
  VOID
);

EFI_STATUS
EFIAPI
if any children still exist(
  VOID
);

EFI_STATUS
EFIAPI
(NumberOfChildren != 0) {(
  VOID
);

EFI_STATUS
EFIAPI
individual children(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->RaiseTPL(TPL_CALLBACK);(
  VOID
);

EFI_STATUS
EFIAPI
the Block IO protocol from child handle(
  VOID
);

EFI_STATUS
EFIAPI
private data signature(
  VOID
);

EFI_STATUS
EFIAPI
= CR(BlockIo, PARTITION_PRIVATE_DATA, BlockIo, PARTITION_PRIVATE_DATA_SIGNATURE);(
  VOID
);

EFI_STATUS
EFIAPI
and close Block IO(
  VOID
);

EFI_STATUS
EFIAPI
= BlockIo->FlushBlocks(BlockIo);(
  VOID
);

EFI_STATUS
EFIAPI
Block IO2 if available(
  VOID
);

EFI_STATUS
EFIAPI
(BlockIo2 != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
protocols from child handle(
  VOID
);

EFI_STATUS
EFIAPI
Block IO, Block IO2, Device Path, and Partition Info(
  VOID
);

EFI_STATUS
EFIAPI
= gBS->UninstallMultipleProtocolInterfaces((
  VOID
);

EFI_STATUS
EFIAPI
overlap and free private data(
  VOID
);

EFI_STATUS
EFIAPI
IO Protocol Implementation(
  VOID
);

EFI_STATUS
EFIAPI
buffer size is a multiple of block size(
  VOID
);

EFI_STATUS
EFIAPI
(BufferSize % Private->BlockSize != 0) {(
  VOID
);

EFI_STATUS
EFIAPI
offset on parent device(
  VOID
);

EFI_STATUS
EFIAPI
= Private->CachedDiskOffset + Lba * Private->BlockSize;(
  VOID
);

EFI_STATUS
EFIAPI
the read is within partition bounds(
  VOID
);

EFI_STATUS
EFIAPI
(OffsetLba + BufferSize > Private->CachedDiskSize) {(
  VOID
);

EFI_STATUS
EFIAPI
the write is within partition bounds(
  VOID
);

EFI_STATUS
EFIAPI
IO2 Protocol Implementation(
  VOID
);

EFI_STATUS
EFIAPI
no token (synchronous) or no buffer to map, call parent directly(
  VOID
);

EFI_STATUS
EFIAPI
(Token == NULL || *Token == NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
a wrapped device path for tracking(
  VOID
);

EFI_STATUS
EFIAPI
*MediaDevicePath = PartitionCreateMediaDevicePathNode(Token);(
  VOID
);

EFI_STATUS
EFIAPI
no token, call parent directly(
  VOID
);

EFI_STATUS
EFIAPI
Handle Creation(
  VOID
);

EFI_STATUS
EFIAPI
private data structure (0x1A0 bytes)(
  VOID
);

EFI_STATUS
EFIAPI
= AllocateCopyPool(sizeof(PARTITION_PRIVATE_DATA));(
  VOID
);

EFI_STATUS
EFIAPI
revision(
  VOID
);

EFI_STATUS
EFIAPI
Block IO2 protocol if parent supports it(
  VOID
);

EFI_STATUS
EFIAPI
(ParentBlockIo2 != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
media parameters(
  VOID
);

EFI_STATUS
EFIAPI
Block IO2 media parameters(
  VOID
);

EFI_STATUS
EFIAPI
LastBlock for floppy detection(
  VOID
);

EFI_STATUS
EFIAPI
(Private->BlockIo.Media->LastBlock >= 0x20000) {(
  VOID
);

EFI_STATUS
EFIAPI
a floppy(
  VOID
);

EFI_STATUS
EFIAPI
full device path(
  VOID
);

EFI_STATUS
EFIAPI
= AppendDevicePathInstance(DevicePath, DevicePathInstance);(
  VOID
);

EFI_STATUS
EFIAPI
partition info(
  VOID
);

EFI_STATUS
EFIAPI
partition type GUID pointer(
  VOID
);

EFI_STATUS
EFIAPI
(PartitionInfo->Type == PARTITION_TYPE_MBR) {(
  VOID
);

EFI_STATUS
EFIAPI
protocols on new child handle(
  VOID
);

EFI_STATUS
EFIAPI
Device Path protocol on the child handle(
  VOID
);

EFI_STATUS
EFIAPI
Name Protocol(
  VOID
);

EFI_STATUS
EFIAPI
Detection(
  VOID
);

EFI_STATUS
EFIAPI
first free entry(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; Index < i; Index++) {(
  VOID
);

EFI_STATUS
EFIAPI
full(
  VOID
);

EFI_STATUS
EFIAPI
against all registered entries(
  VOID
);

EFI_STATUS
EFIAPI
detected(
  VOID
);

EFI_STATUS
EFIAPI
overlap(
  VOID
);

EFI_STATUS
EFIAPI
first free slot(
  VOID
);

EFI_STATUS
EFIAPI
the entry(
  VOID
);

EFI_STATUS
EFIAPI
flag(
  VOID
);

EFI_STATUS
EFIAPI
for matching entry(
  VOID
);

EFI_STATUS
EFIAPI
entry(
  VOID
);

EFI_STATUS
EFIAPI
Partition Support(
  VOID
);

EFI_STATUS
EFIAPI
MBR signature(
  VOID
);

EFI_STATUS
EFIAPI
(*(UINT16*)((UINT8*)MbrBuffer + MBR_OFFSET_SIGNATURE) != MBR_SIGNATURE) {(
  VOID
);

EFI_STATUS
EFIAPI
of first partition entry(
  VOID
);

EFI_STATUS
EFIAPI
start LBA and size (24-bit CHS/LBA hybrid encoding)(
  VOID
);

EFI_STATUS
EFIAPI
= PartitionEntry->StartLBA;(
  VOID
);

EFI_STATUS
EFIAPI
for overlap with other partitions(
  VOID
);

EFI_STATUS
EFIAPI
(SubIndex = Index + 1; SubIndex < 4; SubIndex++) {(
  VOID
);

EFI_STATUS
EFIAPI
MBR (512 bytes), validates it, then iterates 4 primary partition entries.(
  VOID
);

EFI_STATUS
EFIAPI
each valid entry, creates a HARDDRIVE_DEVICE_PATH media node and calls(
  VOID
);

EFI_STATUS
EFIAPI
partitions (EBR) are recursively followed.(
  VOID
);

EFI_STATUS
EFIAPI
details from disassembly (0x1CC0):(
  VOID
);

EFI_STATUS
EFIAPI
EFI_UNSUPPORTED;  // Placeholder - full implementation in decompiled output(
  VOID
);

EFI_STATUS
EFIAPI
primary and backup GPT headers, validates CRC, and creates(
  VOID
);

EFI_STATUS
EFIAPI
handles for each valid GPT partition entry.(
  VOID
);

EFI_STATUS
EFIAPI
details from disassembly (0x227C):(
  VOID
);

EFI_STATUS
EFIAPI
GPT signature ("EFI PART")(
  VOID
);

EFI_STATUS
EFIAPI
(Header->Signature == GPT_HEADER_SIGNATURE) {(
  VOID
);

EFI_STATUS
EFIAPI
CRC (clear CRC field, recalculate, compare)(
  VOID
);

EFI_STATUS
EFIAPI
(Header->HeaderSize != 0 &&(
  VOID
);

EFI_STATUS
EFIAPI
write location (primary or backup)(
  VOID
);

EFI_STATUS
EFIAPI
(GptHeader->MyLBA == 1) {(
  VOID
);

EFI_STATUS
EFIAPI
header fields(
  VOID
);

EFI_STATUS
EFIAPI
new CRC(
  VOID
);

EFI_STATUS
EFIAPI
header(
  VOID
);

EFI_STATUS
EFIAPI
= HeaderCopy->PartitionEntryLBA * ParentBlockIoMedia->Media->BlockSize;(
  VOID
);

EFI_STATUS
EFIAPI
partition entries(
  VOID
);

EFI_STATUS
EFIAPI
= AllocatePool(GptHeader->SizeOfPartitionEntry * GptHeader->NumberOfPartitionEntries);(
  VOID
);

EFI_STATUS
EFIAPI
existing entries, then write to new location(
  VOID
);

EFI_STATUS
EFIAPI
= ParentBlockIo->ReadBlocks((
  VOID
);

EFI_STATUS
EFIAPI
unused entries(
  VOID
);

EFI_STATUS
EFIAPI
(!CompareGuid(&Entry->PartitionTypeGUID, &Guid2)) {(
  VOID
);

EFI_STATUS
EFIAPI
of range(
  VOID
);

EFI_STATUS
EFIAPI
for required partition attribute(
  VOID
);

EFI_STATUS
EFIAPI
((Entry->Attributes & 2) != 0) {(
  VOID
);

EFI_STATUS
EFIAPI
partition(
  VOID
);

EFI_STATUS
EFIAPI
for overlap with subsequent entries(
  VOID
);

EFI_STATUS
EFIAPI
(SubIndex = Index + 1; SubIndex < GptHeader->NumberOfPartitionEntries; SubIndex++) {(
  VOID
);

EFI_STATUS
EFIAPI
by prev(
  VOID
);

EFI_STATUS
EFIAPI
Torito (CD-ROM) Partition Support(
  VOID
);

EFI_STATUS
EFIAPI
details from disassembly (0x2D84):(
  VOID
);

EFI_STATUS
EFIAPI
through supported languages(
  VOID
);

EFI_STATUS
EFIAPI
(This->SupportedLanguages != NULL) {(
  VOID
);

EFI_STATUS
EFIAPI
with requested language(
  VOID
);

EFI_STATUS
EFIAPI
(CompareLangCodes(Language, (CHAR8*)This->SupportedLanguages + Index)) {(
  VOID
);

EFI_STATUS
EFIAPI
to next language in the list(
  VOID
);

EFI_STATUS
EFIAPI
(((CHAR8*)This->SupportedLanguages)[Index] != '\0' &&(
  VOID
);

EFI_STATUS
EFIAPI
matching language entry in the table(
  VOID
);

EFI_STATUS
EFIAPI
(Index = 0; gSupportedLanguages[Index].LanguageString != NULL; Index += 2) {(
  VOID
);

#endif /* __PARTITIONDXE_H__ */