windows-server-2003/base/published/arc.w

/*++ BUILD Version: 0010    // Increment this if a change has global effects

Copyright (c) Microsoft Corporation.  All rights reserved.

Module Name:

    arc.h

Abstract:

    This header file defines the ARC system firmware interface and the
    NT structures that are dependent on ARC types.

Author:

    David N. Cutler (davec) 18-May-1991


Revision History:

--*/

#ifndef _ARC_
#define _ARC_

#include "profiles.h"


//
// Define console input and console output file ids.
//

#define ARC_CONSOLE_INPUT 0
#define ARC_CONSOLE_OUTPUT 1

//
// Define ARC_STATUS type.
//

typedef ULONG ARC_STATUS;

//
// Define the firmware entry point numbers.
//

typedef enum _FIRMWARE_ENTRY {
    LoadRoutine,
    InvokeRoutine,
    ExecuteRoutine,
    HaltRoutine,
    PowerDownRoutine,
    RestartRoutine,
    RebootRoutine,
    InteractiveModeRoutine,
    Reserved1,
    GetPeerRoutine,
    GetChildRoutine,
    GetParentRoutine,
    GetDataRoutine,
    AddChildRoutine,
    DeleteComponentRoutine,
    GetComponentRoutine,
    SaveConfigurationRoutine,
    GetSystemIdRoutine,
    MemoryRoutine,
    Reserved2,
    GetTimeRoutine,
    GetRelativeTimeRoutine,
    GetDirectoryEntryRoutine,
    OpenRoutine,
    CloseRoutine,
    ReadRoutine,
    ReadStatusRoutine,
    WriteRoutine,
    SeekRoutine,
    MountRoutine,
    GetEnvironmentRoutine,
    SetEnvironmentRoutine,
    GetFileInformationRoutine,
    SetFileInformationRoutine,
    FlushAllCachesRoutine,
    TestUnicodeCharacterRoutine,
    GetDisplayStatusRoutine,
    MaximumRoutine
} FIRMWARE_ENTRY;

//
// Define software loading and execution routine types.
//

typedef
ARC_STATUS
(*PARC_EXECUTE_ROUTINE) (
    IN CHAR * FIRMWARE_PTR ImagePath,
    IN ULONG Argc,
    IN CHAR * FIRMWARE_PTR * FIRMWARE_PTR Argv,
    IN CHAR * FIRMWARE_PTR * FIRMWARE_PTR Envp
    );

typedef
ARC_STATUS
(*PARC_INVOKE_ROUTINE) (
    IN ULONG EntryAddress,
    IN ULONG StackAddress,
    IN ULONG Argc,
    IN CHAR * FIRMWARE_PTR * FIRMWARE_PTR Argv,
    IN CHAR * FIRMWARE_PTR * FIRMWARE_PTR Envp
    );

typedef
ARC_STATUS
(*PARC_LOAD_ROUTINE) (
    IN CHAR * FIRMWARE_PTR ImagePath,
    IN ULONG TopAddress,
    OUT ULONG * FIRMWARE_PTR EntryAddress,
    OUT ULONG * FIRMWARE_PTR LowAddress
    );

//
// Define firmware software loading and execution prototypes.
//

ARC_STATUS
FwExecute (
    IN CHAR * FIRMWARE_PTR ImagePath,
    IN ULONG Argc,
    IN CHAR * FIRMWARE_PTR * FIRMWARE_PTR Argv,
    IN CHAR * FIRMWARE_PTR * FIRMWARE_PTR Envp
    );

ARC_STATUS
FwInvoke (
    IN ULONG EntryAddress,
    IN ULONG StackAddress,
    IN ULONG Argc,
    IN CHAR * FIRMWARE_PTR * FIRMWARE_PTR Argv,
    IN CHAR * FIRMWARE_PTR * FIRMWARE_PTR Envp
    );

ARC_STATUS
FwLoad (
    IN CHAR * FIRMWARE_PTR ImagePath,
    IN ULONG TopAddress,
    OUT ULONG * FIRMWARE_PTR EntryAddress,
    OUT ULONG * FIRMWARE_PTR LowAddress
    );

//
// Define program termination routine types.
//

typedef
VOID
(*PARC_HALT_ROUTINE) (
    VOID
    );

typedef
VOID
(*PARC_POWERDOWN_ROUTINE) (
    VOID
    );

typedef
VOID
(*PARC_RESTART_ROUTINE) (
    VOID
    );

typedef
VOID
(*PARC_REBOOT_ROUTINE) (
    VOID
    );

typedef
VOID
(*PARC_INTERACTIVE_MODE_ROUTINE) (
    VOID
    );

//
// Define firmware program termination prototypes.
//

VOID
FwHalt (
    VOID
    );

VOID
FwPowerDown (
    VOID
    );

VOID
FwRestart (
    VOID
    );

VOID
FwReboot (
    VOID
    );

VOID
FwEnterInteractiveMode (
    VOID
    );

// begin_ntddk
//
// Define configuration routine types.
//
// Configuration information.
//
// end_ntddk

typedef enum _CONFIGURATION_CLASS {
    SystemClass,
    ProcessorClass,
    CacheClass,
    AdapterClass,
    ControllerClass,
    PeripheralClass,
    MemoryClass,
    MaximumClass
} CONFIGURATION_CLASS, *PCONFIGURATION_CLASS;

// begin_ntddk

typedef enum _CONFIGURATION_TYPE {
    ArcSystem,
    CentralProcessor,
    FloatingPointProcessor,
    PrimaryIcache,
    PrimaryDcache,
    SecondaryIcache,
    SecondaryDcache,
    SecondaryCache,
    EisaAdapter,
    TcAdapter,
    ScsiAdapter,
    DtiAdapter,
    MultiFunctionAdapter,
    DiskController,
    TapeController,
    CdromController,
    WormController,
    SerialController,
    NetworkController,
    DisplayController,
    ParallelController,
    PointerController,
    KeyboardController,
    AudioController,
    OtherController,
    DiskPeripheral,
    FloppyDiskPeripheral,
    TapePeripheral,
    ModemPeripheral,
    MonitorPeripheral,
    PrinterPeripheral,
    PointerPeripheral,
    KeyboardPeripheral,
    TerminalPeripheral,
    OtherPeripheral,
    LinePeripheral,
    NetworkPeripheral,
    SystemMemory,
    DockingInformation,
    RealModeIrqRoutingTable,
    RealModePCIEnumeration,
    MaximumType
} CONFIGURATION_TYPE, *PCONFIGURATION_TYPE;

// end_ntddk

typedef struct _CONFIGURATION_COMPONENT {
    CONFIGURATION_CLASS Class;
    CONFIGURATION_TYPE Type;
    DEVICE_FLAGS Flags;
    USHORT Version;
    USHORT Revision;
    ULONG Key;
    ULONG AffinityMask;
    ULONG ConfigurationDataLength;
    ULONG IdentifierLength;
    CHAR * FIRMWARE_PTR Identifier;
} CONFIGURATION_COMPONENT, * FIRMWARE_PTR PCONFIGURATION_COMPONENT;

typedef
PCONFIGURATION_COMPONENT
(*PARC_GET_CHILD_ROUTINE) (
    IN PCONFIGURATION_COMPONENT Component OPTIONAL
    );

typedef
PCONFIGURATION_COMPONENT
(*PARC_GET_PARENT_ROUTINE) (
    IN PCONFIGURATION_COMPONENT Component
    );

typedef
PCONFIGURATION_COMPONENT
(*PARC_GET_PEER_ROUTINE) (
    IN PCONFIGURATION_COMPONENT Component
    );

typedef
PCONFIGURATION_COMPONENT
(*PARC_ADD_CHILD_ROUTINE) (
    IN PCONFIGURATION_COMPONENT Component,
    IN PCONFIGURATION_COMPONENT NewComponent,
    IN VOID * FIRMWARE_PTR ConfigurationData
    );

typedef
ARC_STATUS
(*PARC_DELETE_COMPONENT_ROUTINE) (
    IN PCONFIGURATION_COMPONENT Component
    );

typedef
PCONFIGURATION_COMPONENT
(*PARC_GET_COMPONENT_ROUTINE) (
    IN CHAR * FIRMWARE_PTR Path
    );

typedef
ARC_STATUS
(*PARC_GET_DATA_ROUTINE) (
    OUT VOID * FIRMWARE_PTR ConfigurationData,
    IN PCONFIGURATION_COMPONENT Component
    );

typedef
ARC_STATUS
(*PARC_SAVE_CONFIGURATION_ROUTINE) (
    VOID
    );

//
// Define firmware configuration prototypes.
//

PCONFIGURATION_COMPONENT
FwGetChild (
    IN PCONFIGURATION_COMPONENT Component OPTIONAL
    );

PCONFIGURATION_COMPONENT
FwGetParent (
    IN PCONFIGURATION_COMPONENT Component
    );

PCONFIGURATION_COMPONENT
FwGetPeer (
    IN PCONFIGURATION_COMPONENT Component
    );

PCONFIGURATION_COMPONENT
FwAddChild (
    IN PCONFIGURATION_COMPONENT Component,
    IN PCONFIGURATION_COMPONENT NewComponent,
    IN VOID * FIRMWARE_PTR ConfigurationData OPTIONAL
    );

ARC_STATUS
FwDeleteComponent (
    IN PCONFIGURATION_COMPONENT Component
    );

PCONFIGURATION_COMPONENT
FwGetComponent(
    IN CHAR * FIRMWARE_PTR Path
    );

ARC_STATUS
FwGetConfigurationData (
    OUT VOID * FIRMWARE_PTR ConfigurationData,
    IN PCONFIGURATION_COMPONENT Component
    );

ARC_STATUS
FwSaveConfiguration (
    VOID
    );

//
// System information.
//

typedef struct _SYSTEM_ID {
    CHAR VendorId[8];
    CHAR ProductId[8];
} SYSTEM_ID, * FIRMWARE_PTR PSYSTEM_ID;

typedef
PSYSTEM_ID
(*PARC_GET_SYSTEM_ID_ROUTINE) (
    VOID
    );

//
// Define system identifier query routine type.
//

PSYSTEM_ID
FwGetSystemId (
    VOID
    );

//
// Memory information.
//

typedef enum _MEMORY_TYPE {
    MemoryExceptionBlock,
    MemorySystemBlock,
    MemoryFree,
    MemoryBad,
    MemoryLoadedProgram,
    MemoryFirmwareTemporary,
    MemoryFirmwarePermanent,
    MemoryFreeContiguous,
    MemorySpecialMemory,
    MemoryMaximum
} MEMORY_TYPE;

typedef struct _MEMORY_DESCRIPTOR {
    MEMORY_TYPE MemoryType;
    ULONG BasePage;
    ULONG PageCount;
} MEMORY_DESCRIPTOR, * FIRMWARE_PTR PMEMORY_DESCRIPTOR;

#if defined(_IA64_)

//
// Cache Attribute.
//

#define WTU    0x1
#define WTO    0x2
#define WBO    0x4
#define WBU    0x8
#define WCU    0x10
#define UCU    0x20
#define UCUE   0x40
#define UCO    0x80

typedef enum _MEMORY_USAGE_TYPE {
    RegularMemory,
    MemoryMappedIo,
    ProcessorIoBlock,
    BootServicesCode,
    BootServicesData,
    RuntimeServicesCode,
    RuntimeServicesData,
    FirmwareSpace,
    DisplayMemory,
    CacheAttributeMaximum
} MEMORY_USAGE_TYPE;

typedef struct _CACHE_ATTRIBUTE_DESCRIPTOR {
    LIST_ENTRY ListEntry;
    MEMORY_USAGE_TYPE MemoryUsage;
    ULONG CacheAttribute;
    ULONG BasePage;
    ULONG PageCount;
} CACHE_ATTRIBUTE_DESCRIPTOR, *PCACHE_ATTRIBUTE_DESCRIPTOR;

#endif // defined(_IA64_)

typedef
PMEMORY_DESCRIPTOR
(*PARC_MEMORY_ROUTINE) (
    IN PMEMORY_DESCRIPTOR MemoryDescriptor OPTIONAL
    );

//
// Define memory query routine type.
//

PMEMORY_DESCRIPTOR
FwGetMemoryDescriptor (
    IN PMEMORY_DESCRIPTOR MemoryDescriptor OPTIONAL
    );

//
// Query time functions.
//

typedef
PTIME_FIELDS
(*PARC_GET_TIME_ROUTINE) (
    VOID
    );

typedef
ULONG
(*PARC_GET_RELATIVE_TIME_ROUTINE) (
    VOID
    );

//
// Define query time routine types.
//

PTIME_FIELDS
FwGetTime (
    VOID
    );

ULONG
FwGetRelativeTime (
    VOID
    );

//
// Define I/O routine types.
//

#define ArcReadOnlyFile   1
#define ArcHiddenFile     2
#define ArcSystemFile     4
#define ArcArchiveFile    8
#define ArcDirectoryFile 16
#define ArcDeleteFile    32

typedef enum _OPEN_MODE {
    ArcOpenReadOnly,
    ArcOpenWriteOnly,
    ArcOpenReadWrite,
    ArcCreateWriteOnly,
    ArcCreateReadWrite,
    ArcSupersedeWriteOnly,
    ArcSupersedeReadWrite,
    ArcOpenDirectory,
    ArcCreateDirectory,
    ArcOpenMaximumMode
} OPEN_MODE;

typedef struct _FILE_INFORMATION {
    LARGE_INTEGER StartingAddress;
    LARGE_INTEGER EndingAddress;
    LARGE_INTEGER CurrentPosition;
    CONFIGURATION_TYPE Type;
    ULONG FileNameLength;
    UCHAR Attributes;
    CHAR FileName[32];
} FILE_INFORMATION, * FIRMWARE_PTR PFILE_INFORMATION;

typedef enum _SEEK_MODE {
    SeekAbsolute,
    SeekRelative,
    SeekMaximum
} SEEK_MODE;

typedef enum _MOUNT_OPERATION {
    MountLoadMedia,
    MountUnloadMedia,
    MountMaximum
} MOUNT_OPERATION;

typedef struct _DIRECTORY_ENTRY {
        ULONG FileNameLength;
        UCHAR FileAttribute;
        CHAR FileName[32];
} DIRECTORY_ENTRY, * FIRMWARE_PTR PDIRECTORY_ENTRY;

typedef
ARC_STATUS
(*PARC_CLOSE_ROUTINE) (
    IN ULONG FileId
    );

typedef
ARC_STATUS
(*PARC_MOUNT_ROUTINE) (
    IN CHAR * FIRMWARE_PTR MountPath,
    IN MOUNT_OPERATION Operation
    );

typedef
ARC_STATUS
(*PARC_OPEN_ROUTINE) (
    IN CHAR * FIRMWARE_PTR OpenPath,
    IN OPEN_MODE OpenMode,
    OUT ULONG * FIRMWARE_PTR FileId
    );

typedef
ARC_STATUS
(*PARC_READ_ROUTINE) (
    IN ULONG FileId,
    OUT VOID * FIRMWARE_PTR Buffer,
    IN ULONG Length,
    OUT ULONG * FIRMWARE_PTR Count
    );

typedef
ARC_STATUS
(*PARC_READ_STATUS_ROUTINE) (
    IN ULONG FileId
    );

typedef
ARC_STATUS
(*PARC_SEEK_ROUTINE) (
    IN ULONG FileId,
    IN LARGE_INTEGER * FIRMWARE_PTR Offset,
    IN SEEK_MODE SeekMode
    );

typedef
ARC_STATUS
(*PARC_WRITE_ROUTINE) (
    IN ULONG FileId,
    IN VOID * FIRMWARE_PTR Buffer,
    IN ULONG Length,
    OUT ULONG * FIRMWARE_PTR Count
    );

typedef
ARC_STATUS
(*PARC_GET_FILE_INFO_ROUTINE) (
    IN ULONG FileId,
    OUT PFILE_INFORMATION FileInformation
    );

typedef
ARC_STATUS
(*PARC_SET_FILE_INFO_ROUTINE) (
    IN ULONG FileId,
    IN ULONG AttributeFlags,
    IN ULONG AttributeMask
    );

typedef
ARC_STATUS
(*PARC_GET_DIRECTORY_ENTRY_ROUTINE) (
    IN ULONG FileId,
    OUT PDIRECTORY_ENTRY Buffer,
    IN ULONG Length,
    OUT ULONG * FIRMWARE_PTR Count
    );

//
// Define firmware I/O prototypes.
//

ARC_STATUS
FwClose (
    IN ULONG FileId
    );

ARC_STATUS
FwMount (
    IN CHAR * FIRMWARE_PTR MountPath,
    IN MOUNT_OPERATION Operation
    );

ARC_STATUS
FwOpen (
    IN CHAR * FIRMWARE_PTR OpenPath,
    IN OPEN_MODE OpenMode,
    OUT ULONG * FIRMWARE_PTR FileId
    );

ARC_STATUS
FwRead (
    IN ULONG FileId,
    OUT VOID * FIRMWARE_PTR Buffer,
    IN ULONG Length,
    OUT ULONG * FIRMWARE_PTR Count
    );

ARC_STATUS
FwGetReadStatus (
    IN ULONG FileId
    );

ARC_STATUS
FwSeek (
    IN ULONG FileId,
    IN LARGE_INTEGER * FIRMWARE_PTR Offset,
    IN SEEK_MODE SeekMode
    );

ARC_STATUS
FwWrite (
    IN ULONG FileId,
    IN VOID * FIRMWARE_PTR Buffer,
    IN ULONG Length,
    OUT ULONG * FIRMWARE_PTR Count
    );

ARC_STATUS
FwGetFileInformation (
    IN ULONG FileId,
    OUT PFILE_INFORMATION FileInformation
    );

ARC_STATUS
FwSetFileInformation (
    IN ULONG FileId,
    IN ULONG AttributeFlags,
    IN ULONG AttributeMask
    );

ARC_STATUS
FwGetDirectoryEntry (
    IN ULONG FileId,
    OUT PDIRECTORY_ENTRY Buffer,
    IN ULONG Length,
    OUT ULONG * FIRMWARE_PTR Count
    );


//
// Define environment routine types.
//

typedef
CHAR * FIRMWARE_PTR
(*PARC_GET_ENVIRONMENT_ROUTINE) (
    IN CHAR * FIRMWARE_PTR Variable
    );

typedef
ARC_STATUS
(*PARC_SET_ENVIRONMENT_ROUTINE) (
    IN CHAR * FIRMWARE_PTR Variable,
    IN CHAR * FIRMWARE_PTR Value
    );

//
// Define firmware environment prototypes.
//

CHAR * FIRMWARE_PTR
FwGetEnvironmentVariable (
    IN CHAR * FIRMWARE_PTR Variable
    );

ARC_STATUS
FwSetEnvironmentVariable (
    IN CHAR * FIRMWARE_PTR Variable,
    IN CHAR * FIRMWARE_PTR Value
    );

//
// Define functions to acquire and release the firmware lock and the stub
// function prototypes necessary to interface with the 32-bit firmware on
// 64-bit systems.
//
// These routines are required for the 64-bit system until (if) 64-bit
// firmware is ever supplied.
//

#if defined(_AXP64_) && defined(_NTHAL_)

extern ULONGLONG HalpMarshallBuffer[];
extern KSPIN_LOCK HalpFirmwareLock;

CHAR * FIRMWARE_PTR
HalpArcGetEnvironmentVariable(
    IN CHAR * FIRMWARE_PTR Variable
    );

ARC_STATUS
HalpArcSetEnvironmentVariable(
    IN CHAR * FIRMWARE_PTR Variable,
    IN CHAR * FIRMWARE_PTR Value
    );

KIRQL
FwAcquireFirmwareLock(
    VOID
    );

VOID
FwReleaseFirmwareLock(
    IN KIRQL OldIrql
    );

#endif // _AXP64_  && defined(_NTHAL_)


//
// Define cache flush routine types
//

typedef
VOID
(*PARC_FLUSH_ALL_CACHES_ROUTINE) (
    VOID
    );

//
// Define firmware cache flush prototypes.
//

VOID
FwFlushAllCaches (
    VOID
    );

//
// Define TestUnicodeCharacter and GetDisplayStatus routines.
//

typedef struct _ARC_DISPLAY_STATUS {
    USHORT CursorXPosition;
    USHORT CursorYPosition;
    USHORT CursorMaxXPosition;
    USHORT CursorMaxYPosition;
    UCHAR ForegroundColor;
    UCHAR BackgroundColor;
    BOOLEAN HighIntensity;
    BOOLEAN Underscored;
    BOOLEAN ReverseVideo;
} ARC_DISPLAY_STATUS, * FIRMWARE_PTR PARC_DISPLAY_STATUS;

typedef
ARC_STATUS
(*PARC_TEST_UNICODE_CHARACTER_ROUTINE) (
    IN ULONG FileId,
    IN WCHAR UnicodeCharacter
    );

typedef
PARC_DISPLAY_STATUS
(*PARC_GET_DISPLAY_STATUS_ROUTINE) (
    IN ULONG FileId
    );

ARC_STATUS
FwTestUnicodeCharacter(
    IN ULONG FileId,
    IN WCHAR UnicodeCharacter
    );

PARC_DISPLAY_STATUS
FwGetDisplayStatus(
    IN ULONG FileId
    );


//
// Define low memory data structures.
//
// Define debug block structure.
//

typedef struct _DEBUG_BLOCK {
    ULONG Signature;
    ULONG Length;
} DEBUG_BLOCK, * FIRMWARE_PTR PDEBUG_BLOCK;

//
// Define restart block structure.
//

#define ARC_RESTART_BLOCK_SIGNATURE 0x42545352

typedef struct _BOOT_STATUS {
    ULONG BootStarted : 1;
    ULONG BootFinished : 1;
    ULONG RestartStarted : 1;
    ULONG RestartFinished : 1;
    ULONG PowerFailStarted : 1;
    ULONG PowerFailFinished : 1;
    ULONG ProcessorReady : 1;
    ULONG ProcessorRunning : 1;
    ULONG ProcessorStart : 1;
} BOOT_STATUS, * FIRMWARE_PTR PBOOT_STATUS;

typedef struct _ALPHA_RESTART_STATE {

#if defined(_ALPHA_) || defined(_AXP64_)

    //
    // Control information
    //

    ULONG HaltReason;
    VOID * FIRMWARE_PTR LogoutFrame;
    ULONGLONG PalBase;

    //
    // Integer Save State
    //

    ULONGLONG IntV0;
    ULONGLONG IntT0;
    ULONGLONG IntT1;
    ULONGLONG IntT2;
    ULONGLONG IntT3;
    ULONGLONG IntT4;
    ULONGLONG IntT5;
    ULONGLONG IntT6;
    ULONGLONG IntT7;
    ULONGLONG IntS0;
    ULONGLONG IntS1;
    ULONGLONG IntS2;
    ULONGLONG IntS3;
    ULONGLONG IntS4;
    ULONGLONG IntS5;
    ULONGLONG IntFp;
    ULONGLONG IntA0;
    ULONGLONG IntA1;
    ULONGLONG IntA2;
    ULONGLONG IntA3;
    ULONGLONG IntA4;
    ULONGLONG IntA5;
    ULONGLONG IntT8;
    ULONGLONG IntT9;
    ULONGLONG IntT10;
    ULONGLONG IntT11;
    ULONGLONG IntRa;
    ULONGLONG IntT12;
    ULONGLONG IntAT;
    ULONGLONG IntGp;
    ULONGLONG IntSp;
    ULONGLONG IntZero;

    //
    // Floating Point Save State
    //

    ULONGLONG Fpcr;
    ULONGLONG FltF0;
    ULONGLONG FltF1;
    ULONGLONG FltF2;
    ULONGLONG FltF3;
    ULONGLONG FltF4;
    ULONGLONG FltF5;
    ULONGLONG FltF6;
    ULONGLONG FltF7;
    ULONGLONG FltF8;
    ULONGLONG FltF9;
    ULONGLONG FltF10;
    ULONGLONG FltF11;
    ULONGLONG FltF12;
    ULONGLONG FltF13;
    ULONGLONG FltF14;
    ULONGLONG FltF15;
    ULONGLONG FltF16;
    ULONGLONG FltF17;
    ULONGLONG FltF18;
    ULONGLONG FltF19;
    ULONGLONG FltF20;
    ULONGLONG FltF21;
    ULONGLONG FltF22;
    ULONGLONG FltF23;
    ULONGLONG FltF24;
    ULONGLONG FltF25;
    ULONGLONG FltF26;
    ULONGLONG FltF27;
    ULONGLONG FltF28;
    ULONGLONG FltF29;
    ULONGLONG FltF30;
    ULONGLONG FltF31;

    //
    // Architected Internal Processor State.
    //

    ULONG Asn;
    VOID * FIRMWARE_PTR GeneralEntry;
    VOID * FIRMWARE_PTR Iksp;
    VOID * FIRMWARE_PTR InterruptEntry;
    VOID * FIRMWARE_PTR Kgp;
    ULONG Mces;
    VOID * FIRMWARE_PTR MemMgmtEntry;
    VOID * FIRMWARE_PTR PanicEntry;
    VOID * FIRMWARE_PTR Pcr;
    VOID * FIRMWARE_PTR Pdr;
    ULONG Psr;
    VOID * FIRMWARE_PTR ReiRestartAddress;
    ULONG Sirr;
    VOID * FIRMWARE_PTR SyscallEntry;
    VOID * FIRMWARE_PTR Teb;
    VOID * FIRMWARE_PTR Thread;

    //
    // Processor Implementation-dependent State.
    //

    ULONGLONG PerProcessorState[175];   // allocate 2K maximum restart block

#else

    ULONG PlaceHolder;

#endif

} ALPHA_RESTART_STATE, * FIRMWARE_PTR PALPHA_RESTART_STATE;

typedef struct _I386_RESTART_STATE {

#if defined(_X86_)

    //
    // Put state structure here.
    //

    ULONG PlaceHolder;

#else

    ULONG PlaceHolder;

#endif

} I386_RESTART_STATE, *PI386_RESTART_STATE;

#if defined(_IA64_)
#include "pshpck16.h"
#endif


typedef struct _IA64_RESTART_STATE {

#if defined(_IA64_)


    //
    // This structure is copied from CONTEXT structure in sdk/ntia64.h.
    //

    //
    // The flags values within this flag control the contents of
    // a CONTEXT record.
    //
    // If the context record is used as an input parameter, then
    // for each portion of the context record controlled by a flag
    // whose value is set, it is assumed that that portion of the
    // context record contains valid context. If the context record
    // is being used to modify a thread's context, then only that
    // portion of the threads context will be modified.
    //
    // If the context record is used as an IN OUT parameter to capture
    // the context of a thread, then only those portions of the thread's
    // context corresponding to set flags will be returned.
    //
    // The context record is never used as an OUT only parameter.
    //

    ULONG ContextFlags;
    ULONG Fill1[3];         // for alignment of following on 16-byte boundary

    //
    // This section is specified/returned if the ContextFlags word contains
    // the flag CONTEXT_DEBUG.
    //
    // N.B. CONTEXT_DEBUG is *not* part of CONTEXT_FULL.
    //

    ULONGLONG DbI0;         // Instruction debug registers
    ULONGLONG DbI1;
    ULONGLONG DbI2;
    ULONGLONG DbI3;
    ULONGLONG DbI4;
    ULONGLONG DbI5;
    ULONGLONG DbI6;
    ULONGLONG DbI7;

    ULONGLONG DbD0;         // Data debug registers
    ULONGLONG DbD1;
    ULONGLONG DbD2;
    ULONGLONG DbD3;
    ULONGLONG DbD4;
    ULONGLONG DbD5;
    ULONGLONG DbD6;
    ULONGLONG DbD7;

    //
    // This section is specified/returned if the ContextFlags word contains
    // the flag CONTEXT_LOWER_FLOATING_POINT.
    //

    FLOAT128 FltS0;                         // Lower saved (preserved)
    FLOAT128 FltS1;
    FLOAT128 FltS2;
    FLOAT128 FltS3;
    FLOAT128 FltS4;
    FLOAT128 FltS5;
    FLOAT128 FltT0;                         // Lower temporary (scratch)
    FLOAT128 FltT1;
    FLOAT128 FltT2;
    FLOAT128 FltT3;
    FLOAT128 FltT4;
    FLOAT128 FltT5;
    FLOAT128 FltT6;
    FLOAT128 FltT7;

    //
    // This section is specified/returned if the ContextFlags word contains
    // the flag CONTEXT_HIGHER_FLOATING_POINT.
    //

    FLOAT128 FltS6;                         // Higher saved (preserved) floats
    FLOAT128 FltS7;
    FLOAT128 FltS8;
    FLOAT128 FltS9;
    FLOAT128 FltS10;
    FLOAT128 FltS11;
    FLOAT128 FltS12;
    FLOAT128 FltS13;
    FLOAT128 FltS14;
    FLOAT128 FltS15;
    FLOAT128 FltS16;
    FLOAT128 FltS17;
    FLOAT128 FltS18;
    FLOAT128 FltS19;
    FLOAT128 FltS20;
    FLOAT128 FltS21;

    FLOAT128 FltF32;
    FLOAT128 FltF33;
    FLOAT128 FltF34;
    FLOAT128 FltF35;
    FLOAT128 FltF36;
    FLOAT128 FltF37;
    FLOAT128 FltF38;
    FLOAT128 FltF39;

    FLOAT128 FltF40;
    FLOAT128 FltF41;
    FLOAT128 FltF42;
    FLOAT128 FltF43;
    FLOAT128 FltF44;
    FLOAT128 FltF45;
    FLOAT128 FltF46;
    FLOAT128 FltF47;
    FLOAT128 FltF48;
    FLOAT128 FltF49;

    FLOAT128 FltF50;
    FLOAT128 FltF51;
    FLOAT128 FltF52;
    FLOAT128 FltF53;
    FLOAT128 FltF54;
    FLOAT128 FltF55;
    FLOAT128 FltF56;
    FLOAT128 FltF57;
    FLOAT128 FltF58;
    FLOAT128 FltF59;

    FLOAT128 FltF60;
    FLOAT128 FltF61;
    FLOAT128 FltF62;
    FLOAT128 FltF63;
    FLOAT128 FltF64;
    FLOAT128 FltF65;
    FLOAT128 FltF66;
    FLOAT128 FltF67;
    FLOAT128 FltF68;
    FLOAT128 FltF69;

    FLOAT128 FltF70;
    FLOAT128 FltF71;
    FLOAT128 FltF72;
    FLOAT128 FltF73;
    FLOAT128 FltF74;
    FLOAT128 FltF75;
    FLOAT128 FltF76;
    FLOAT128 FltF77;
    FLOAT128 FltF78;
    FLOAT128 FltF79;

    FLOAT128 FltF80;
    FLOAT128 FltF81;
    FLOAT128 FltF82;
    FLOAT128 FltF83;
    FLOAT128 FltF84;
    FLOAT128 FltF85;
    FLOAT128 FltF86;
    FLOAT128 FltF87;
    FLOAT128 FltF88;
    FLOAT128 FltF89;

    FLOAT128 FltF90;
    FLOAT128 FltF91;
    FLOAT128 FltF92;
    FLOAT128 FltF93;
    FLOAT128 FltF94;
    FLOAT128 FltF95;
    FLOAT128 FltF96;
    FLOAT128 FltF97;
    FLOAT128 FltF98;
    FLOAT128 FltF99;

    FLOAT128 FltF100;
    FLOAT128 FltF101;
    FLOAT128 FltF102;
    FLOAT128 FltF103;
    FLOAT128 FltF104;
    FLOAT128 FltF105;
    FLOAT128 FltF106;
    FLOAT128 FltF107;
    FLOAT128 FltF108;
    FLOAT128 FltF109;

    FLOAT128 FltF110;
    FLOAT128 FltF111;
    FLOAT128 FltF112;
    FLOAT128 FltF113;
    FLOAT128 FltF114;
    FLOAT128 FltF115;
    FLOAT128 FltF116;
    FLOAT128 FltF117;
    FLOAT128 FltF118;
    FLOAT128 FltF119;

    FLOAT128 FltF120;
    FLOAT128 FltF121;
    FLOAT128 FltF122;
    FLOAT128 FltF123;
    FLOAT128 FltF124;
    FLOAT128 FltF125;
    FLOAT128 FltF126;
    FLOAT128 FltF127;

    //
    // This section is specified/returned if the ContextFlags word contains
    // the flag CONTEXT_LOWER_FLOATING_POINT | CONTEXT_HIGHER_FLOATING_POINT.
    // **** TBD **** in some cases it may more efficient to return with
    // CONTEXT_CONTROL
    //

    ULONGLONG StFPSR;   // FP status

    //
    // This section is specified/returned if the ContextFlags word contains
    // the flag CONTEXT_INTEGER.
    //
    // N.B. The registers gp, sp, rp are part of the control context
    //

    ULONGLONG IntGp;                        // global pointer (r1)
    ULONGLONG IntT0;
    ULONGLONG IntT1;
    ULONGLONG IntS0;
    ULONGLONG IntS1;
    ULONGLONG IntS2;
    ULONGLONG IntS3;
    ULONGLONG IntV0;                        // return value (r8)
    ULONGLONG IntAp;                        // argument pointer (r9)
    ULONGLONG IntT2;
    ULONGLONG IntT3;
    ULONGLONG IntSp;                        // stack pointer (r12)
    ULONGLONG IntT4;
    ULONGLONG IntT5;
    ULONGLONG IntT6;
    ULONGLONG IntT7;
    ULONGLONG IntT8;
    ULONGLONG IntT9;
    ULONGLONG IntT10;
    ULONGLONG IntT11;
    ULONGLONG IntT12;
    ULONGLONG IntT13;
    ULONGLONG IntT14;
    ULONGLONG IntT15;
    ULONGLONG IntT16;
    ULONGLONG IntT17;
    ULONGLONG IntT18;
    ULONGLONG IntT19;
    ULONGLONG IntT20;
    ULONGLONG IntT21;
    ULONGLONG IntT22;

    ULONGLONG IntNats;                      // Nat bits for general registers
                                            // r1-r31 in bit positions 1 to 31.
    ULONGLONG Preds;                        // Predicates

    ULONGLONG BrS0l;                        // Branch registers
    ULONGLONG BrS0h;
    ULONGLONG BrS1l;
    ULONGLONG BrS1h;
    ULONGLONG BrS2l;
    ULONGLONG BrS2h;
    ULONGLONG BrS3l;
    ULONGLONG BrS3h;
    ULONGLONG BrS4l;
    ULONGLONG BrS4h;
    ULONGLONG BrT0l;
    ULONGLONG BrT0h;
    ULONGLONG BrT1l;
    ULONGLONG BrT1h;
    ULONGLONG BrRpl;                        // return pointer
    ULONGLONG BrRph;
    ULONGLONG BrT2l;
    ULONGLONG BrT2h;
    ULONGLONG BrT3l;
    ULONGLONG BrT3h;
    ULONGLONG BrT4l;
    ULONGLONG BrT4h;
    ULONGLONG BrT5l;
    ULONGLONG BrT5h;
    ULONGLONG BrT6l;
    ULONGLONG BrT6h;
    ULONGLONG BrT7l;
    ULONGLONG BrT7h;
    ULONGLONG BrT8l;
    ULONGLONG BrT8h;
    ULONGLONG BrT9l;
    ULONGLONG BrT9h;

    // This section is specified/returned if the ContextFlags word contains
    // the flag CONTEXT_CONTROL.
    //

    // Other application registers
    ULONGLONG ApSunatcr;          // User Nat collection register (preserved)
    ULONGLONG ApSlc;              // Loop counter register (preserved)
    ULONGLONG ApTccv;             // CMPXCHG value register (volatile)

    ULONGLONG ApDCR;

    // Register stack info
    ULONGLONG RsPFS;
    ULONGLONG RsBSP;
    ULONGLONG RsBSPStore;
    ULONGLONG RsRSC;
    ULONGLONG RsRNAT;

    // Trap Status Information
    ULONGLONG StIPSR;   // Interrupt Processor Status
    ULONGLONG StIIP;    // Interrupt IP
    ULONGLONG StIFS;    // Interrupt Frame Marker

    ULONGLONG Fill;     // padding for 16-byte alignment on stack, if needed


#else

    ULONG PlaceHolder;

#endif // defined(_IA64_)

} IA64_RESTART_STATE, *PIA64_RESTART_STATE;



typedef struct _RESTART_BLOCK {
    ULONG Signature;
    ULONG Length;
    USHORT Version;
    USHORT Revision;
    struct _RESTART_BLOCK * FIRMWARE_PTR NextRestartBlock;
    VOID * FIRMWARE_PTR RestartAddress;
    ULONG BootMasterId;
    ULONG ProcessorId;
    volatile BOOT_STATUS BootStatus;
    ULONG CheckSum;
    ULONG SaveAreaLength;
    union {
        ULONG SaveArea[1];
        ALPHA_RESTART_STATE Alpha;
        I386_RESTART_STATE I386;
        IA64_RESTART_STATE Ia64;
    } u;

} RESTART_BLOCK, * FIRMWARE_PTR PRESTART_BLOCK;

#if defined(_IA64_)
#include "poppack.h"
#endif

//
// Define system parameter block structure.
//

typedef struct _SYSTEM_PARAMETER_BLOCK {
    ULONG Signature;
    ULONG Length;
    USHORT Version;
    USHORT Revision;
    PRESTART_BLOCK RestartBlock;
    PDEBUG_BLOCK DebugBlock;
    VOID * FIRMWARE_PTR GenerateExceptionVector;
    VOID * FIRMWARE_PTR TlbMissExceptionVector;
    ULONG FirmwareVectorLength;
    VOID * FIRMWARE_PTR * FIRMWARE_PTR FirmwareVector;
    ULONG VendorVectorLength;
    VOID * FIRMWARE_PTR * FIRMWARE_PTR VendorVector;
    ULONG AdapterCount;
    ULONG Adapter0Type;
    ULONG Adapter0Length;
    VOID * FIRMWARE_PTR * FIRMWARE_PTR Adapter0Vector;
} SYSTEM_PARAMETER_BLOCK, * FIRMWARE_PTR PSYSTEM_PARAMETER_BLOCK;

//
// structure defining the function types passed in the FirmwareVector
// of the system block.  
// define this because the compiler does not like the casting of
// void * pointers to function pointers
//
typedef struct _GLOBAL_FIRMWARE_VECTOR {
    ARC_STATUS (* LoadRoutine)(CHAR * FIRMWARE_PTR, ULONG, ULONG * FIRMWARE_PTR, ULONG * FIRMWARE_PTR);
    ARC_STATUS (* InvokeRoutine)(ULONG, ULONG, ULONG, CHAR * FIRMWARE_PTR * FIRMWARE_PTR, CHAR * FIRMWARE_PTR * FIRMWARE_PTR);
    ARC_STATUS (* ExecuteRoutine)(CHAR * FIRWARE_PTR, ULONG, CHAR * FIRMWARE_PTR * FIRMWARE_PTR, CHAR * FIRMWARE_PTR * FIRMWARE_PTR);
    VOID (* HaltRoutine)(VOID);
    VOID (* PowerDownRoutine)(VOID);
    VOID (* RestartRoutine)(VOID);
    VOID (* RebootRoutine)(VOID);
    VOID (* InteractiveModeRoutine)(VOID);
    VOID (* Reserved1)(VOID);
    PCONFIGURATION_COMPONENT (* GetPeerRoutine)(PCONFIGURATION_COMPONENT);
    PCONFIGURATION_COMPONENT (* GetChildRoutine)(PCONFIGURATION_COMPONENT);
    PCONFIGURATION_COMPONENT (* GetParentRoutine)(PCONFIGURATION_COMPONENT);
    ARC_STATUS (* GetDataRoutine)(VOID * FIRMWARE_PTR, PCONFIGURATION_COMPONENT);
    PCONFIGURATION_COMPONENT (* AddChildRoutine)(PCONFIGURATION_COMPONENT, PCONFIGURATION_COMPONENT, VOID * FIRMWARE_PTR);
    ARC_STATUS (* DeleteComponentRoutine)(PCONFIGURATION_COMPONENT);
    PCONFIGURATION_COMPONENT (* GetComponentRoutine)(CHAR * FIRMWARE_PTR);
    ARC_STATUS (* SaveConfigurationRoutine)(VOID);
    PSYSTEM_ID (* GetSystemIdRoutine)(VOID);
    PMEMORY_DESCRIPTOR (* MemoryRoutine)(PMEMORY_DESCRIPTOR);
    VOID (* Reserved2)(VOID);
    PTIME_FIELDS (* GetTimeRoutine)(VOID);
    ULONG (* GetRelativeTimeRoutine)(VOID);
    ARC_STATUS (* GetDirectoryEntryRoutine)(ULONG, PDIRECTORY_ENTRY, ULONG, ULONG * FIRMWARE_PTR);
    ARC_STATUS (* OpenRoutine)(CHAR * FIRMWARE_PTR, OPEN_MODE, ULONG * FIRMWARE_PTR);
    ARC_STATUS (* CloseRoutine)(ULONG);
    ARC_STATUS (* ReadRoutine)(ULONG, VOID * FIRMWARE_PTR, ULONG, ULONG * FIRMWARE_PTR);
    ARC_STATUS (* ReadStatusRoutine)(ULONG);
    ARC_STATUS (* WriteRoutine)(ULONG, VOID * FIRMWARE_PTR, ULONG, ULONG * FIRMWARE_PTR);
    ARC_STATUS (* SeekRoutine)(ULONG, LARGE_INTEGER * FIRMWARE_PTR, SEEK_MODE);
    ARC_STATUS (* MountRoutine)(CHAR * FIRMWARE_PTR, MOUNT_OPERATION);
    CHAR * FIRMWARE_PTR (* GetEnvironmentRoutine)(CHAR * FIRMWARE_PTR);
    ARC_STATUS (* SetEnvironmentRoutine)(CHAR * FIRMWARE_PTR, CHAR * FIRMWARE_PTR);
    ARC_STATUS (* GetFileInformationRoutine)(ULONG, PFILE_INFORMATION);
    ARC_STATUS (* SetFileInformationRoutine)(ULONG, ULONG, ULONG);
    VOID (* FlushAllCachesRoutine)(VOID);
    ARC_STATUS (* TestUnicodeCharacterRoutine)(ULONG, WCHAR);
    PARC_DISPLAY_STATUS (* GetDisplayStatusRoutine)(ULONG); 
} GLOBAL_FIRMWARE_VECTOR, * FIRMWARE_PTR PGLOBAL_FIRMWARE_VECTOR;


//
// Define macros that call firmware routines indirectly through the firmware
// vector and provide type checking of argument values.
//

#if defined(_ALPHA_) || defined(_AXP64_)

#define SYSTEM_BLOCK ((SYSTEM_PARAMETER_BLOCK *)(KSEG0_BASE | 0x6FE000))

#elif defined(_IA64_)

extern SYSTEM_PARAMETER_BLOCK GlobalSystemBlock;

#define SYSTEM_BLOCK (&GlobalSystemBlock)

#elif defined(_X86_)

#if defined(ARCI386)
#define SYSTEM_BLOCK ((PSYSTEM_PARAMETER_BLOCK)(0x1000))

#else
extern SYSTEM_PARAMETER_BLOCK GlobalSystemBlock;

#define SYSTEM_BLOCK (&GlobalSystemBlock)

#endif

#endif

#define FIRMWARE_VECTOR_BLOCK ((PGLOBAL_FIRMWARE_VECTOR) (SYSTEM_BLOCK->FirmwareVector))


//
// Define software loading and execution functions.
//

#define ArcExecute FIRMWARE_VECTOR_BLOCK->ExecuteRoutine
#define ArcInvoke  FIRMWARE_VECTOR_BLOCK->InvokeRoutine
#define ArcLoad    FIRMWARE_VECTOR_BLOCK->LoadRoutine


//
// Define program termination functions.
//

#define ArcHalt                 FIRMWARE_VECTOR_BLOCK->HaltRoutine
#define ArcPowerDown            FIRMWARE_VECTOR_BLOCK->PowerDownRoutine
#define ArcRestart              FIRMWARE_VECTOR_BLOCK->RestartRoutine
#define ArcReboot               FIRMWARE_VECTOR_BLOCK->RebootRoutine
#define ArcEnterInteractiveMode FIRMWARE_VECTOR_BLOCK->InteractiveModeRoutine


//
// Define configuration functions.
//
#define ArcGetChild             FIRMWARE_VECTOR_BLOCK->GetChildRoutine
#define ArcGetParent            FIRMWARE_VECTOR_BLOCK->GetParentRoutine
#define ArcGetPeer              FIRMWARE_VECTOR_BLOCK->GetPeerRoutine
#define ArcAddChild             FIRMWARE_VECTOR_BLOCK->AddChildRoutine
#define ArcDeleteComponent      FIRMWARE_VECTOR_BLOCK->DeleteComponentRoutine
#define ArcGetComponent         FIRMWARE_VECTOR_BLOCK->GetComponentRoutine
#define ArcGetConfigurationData FIRMWARE_VECTOR_BLOCK->GetDataRoutine
#define ArcSaveConfiguration    FIRMWARE_VECTOR_BLOCK->SaveConfigurationRoutine
#define ArcGetSystemId          FIRMWARE_VECTOR_BLOCK->GetSystemIdRoutine
#define ArcGetMemoryDescriptor  FIRMWARE_VECTOR_BLOCK->MemoryRoutine
#define ArcGetTime              FIRMWARE_VECTOR_BLOCK->GetTimeRoutine
#define ArcGetRelativeTime      FIRMWARE_VECTOR_BLOCK->GetRelativeTimeRoutine


//
// Define I/O functions.
//

#define ArcClose              FIRMWARE_VECTOR_BLOCK->CloseRoutine
#define ArcGetReadStatus      FIRMWARE_VECTOR_BLOCK->ReadStatusRoutine
#define ArcMount              FIRMWARE_VECTOR_BLOCK->MountRoutine
#define ArcOpen               FIRMWARE_VECTOR_BLOCK->OpenRoutine
#define ArcRead               FIRMWARE_VECTOR_BLOCK->ReadRoutine
#define ArcSeek               FIRMWARE_VECTOR_BLOCK->SeekRoutine
#define ArcWrite              FIRMWARE_VECTOR_BLOCK->WriteRoutine
#define ArcGetFileInformation FIRMWARE_VECTOR_BLOCK->GetFileInformationRoutine
#define ArcSetFileInformation FIRMWARE_VECTOR_BLOCK->SetFileInformationRoutine
#define ArcGetDirectoryEntry  FIRMWARE_VECTOR_BLOCK->GetDirectoryEntryRoutine


//
// Define environment functions.
//
#if defined(_AXP64_) && defined(_NTHAL_)

__inline
CHAR * FIRMWARE_PTR
ArcGetEnvironmentVariable(
    IN PCHAR Variable
    )

{

    CHAR * FIRMWARE_PTR FwValue;
    CHAR * FIRMWARE_PTR FwVariable;


    //
    // Raise IRQL to high level and acquire firmware lock.
    //

    KIRQL OldIrql = FwAcquireFirmwareLock();

    //
    // Copy variable name to a buffer that is addressable by firmware
    // and query the firmware for the variable value.
    //

    FwVariable = (CHAR * FIRMWARE_PTR)&HalpMarshallBuffer[0];
    strcpy(FwVariable, Variable);
    FwValue = HalpArcGetEnvironmentVariable(FwVariable);

    //
    // Release the firmware lock and lower IRQL to its previous level.
    //

    FwReleaseFirmwareLock(OldIrql);
    return FwValue;
}

#else

#define ArcGetEnvironmentVariable FIRMWARE_VECTOR_BLOCK->GetEnvironmentRoutine

#endif // _AXP64_  && defined(_NTHAL_)

#if defined(_AXP64_) && defined(_NTHAL_)

__inline
ARC_STATUS
ArcSetEnvironmentVariable(
    IN PCHAR Variable,
    IN PCHAR Value
    )

{

    ARC_STATUS ArcStatus;
    CHAR * FIRMWARE_PTR FwValue;
    CHAR * FIRMWARE_PTR FwVariable;
    ULONG Length;

    //
    // Raise IRQL to high level and acquire firmware lock.
    //

    KIRQL OldIrql = FwAcquireFirmwareLock();

    //
    // Copy variable name and value to a buffer that is addressable by
    // firmware and call firmware to set the variable value.
    //

    Length = strlen(Variable);
    FwVariable = (CHAR * FIRMWARE_PTR)&HalpMarshallBuffer[0];
    FwValue = FwVariable + Length + 1;
    strcpy(FwVariable, Variable);
    strcpy(FwValue, Value);
    ArcStatus = HalpArcSetEnvironmentVariable(FwVariable, FwValue);

    //
    // Release the firmware lock and lower IRQL to its previous level.
    //

    FwReleaseFirmwareLock(OldIrql);
    return ArcStatus;
}

#else

#define ArcSetEnvironmentVariable FIRMWARE_VECTOR_BLOCK->SetEnvironmentRoutine

#endif // _AXP64_ && defined(_NTHAL_)


//
// Define cache flush functions.
//

#define ArcFlushAllCaches         FIRMWARE_VECTOR_BLOCK->FlushAllCachesRoutine

//
// Define TestUnicodeCharacter and GetDisplayStatus functions.
//

#define ArcTestUnicodeCharacter   FIRMWARE_VECTOR_BLOCK->TestUnicodeCharacterRoutine
#define ArcGetDisplayStatus       FIRMWARE_VECTOR_BLOCK->GetDisplayStatusRoutine


//
// Define configuration data structure used in all systems.
//

typedef struct _CONFIGURATION_COMPONENT_DATA {
    struct _CONFIGURATION_COMPONENT_DATA *Parent;
    struct _CONFIGURATION_COMPONENT_DATA *Child;
    struct _CONFIGURATION_COMPONENT_DATA *Sibling;
    CONFIGURATION_COMPONENT ComponentEntry;
    PVOID ConfigurationData;
} CONFIGURATION_COMPONENT_DATA, *PCONFIGURATION_COMPONENT_DATA;

//
// Define generic display configuration data structure.
//

typedef struct _MONITOR_CONFIGURATION_DATA {
    USHORT Version;
    USHORT Revision;
    USHORT HorizontalResolution;
    USHORT HorizontalDisplayTime;
    USHORT HorizontalBackPorch;
    USHORT HorizontalFrontPorch;
    USHORT HorizontalSync;
    USHORT VerticalResolution;
    USHORT VerticalBackPorch;
    USHORT VerticalFrontPorch;
    USHORT VerticalSync;
    USHORT HorizontalScreenSize;
    USHORT VerticalScreenSize;
} MONITOR_CONFIGURATION_DATA, *PMONITOR_CONFIGURATION_DATA;

//
// Define generic floppy configuration data structure.
//

typedef struct _FLOPPY_CONFIGURATION_DATA {
    USHORT Version;
    USHORT Revision;
    CHAR Size[8];
    ULONG MaxDensity;
    ULONG MountDensity;
} FLOPPY_CONFIGURATION_DATA, *PFLOPPY_CONFIGURATION_DATA;

//
// Define memory allocation structures used in all systems.
//

typedef enum _TYPE_OF_MEMORY {
    LoaderExceptionBlock = MemoryExceptionBlock,            //  0
    LoaderSystemBlock = MemorySystemBlock,                  //  1
    LoaderFree = MemoryFree,                                //  2
    LoaderBad = MemoryBad,                                  //  3
    LoaderLoadedProgram = MemoryLoadedProgram,              //  4
    LoaderFirmwareTemporary = MemoryFirmwareTemporary,      //  5
    LoaderFirmwarePermanent = MemoryFirmwarePermanent,      //  6
    LoaderOsloaderHeap,                                     //  7
    LoaderOsloaderStack,                                    //  8
    LoaderSystemCode,                                       //  9
    LoaderHalCode,                                          //  a
    LoaderBootDriver,                                       //  b
    LoaderConsoleInDriver,                                  //  c
    LoaderConsoleOutDriver,                                 //  d
    LoaderStartupDpcStack,                                  //  e
    LoaderStartupKernelStack,                               //  f
    LoaderStartupPanicStack,                                // 10
    LoaderStartupPcrPage,                                   // 11
    LoaderStartupPdrPage,                                   // 12
    LoaderRegistryData,                                     // 13
    LoaderMemoryData,                                       // 14
    LoaderNlsData,                                          // 15
    LoaderSpecialMemory,                                    // 16
    LoaderBBTMemory,                                        // 17
    LoaderReserve,                                          // 18
    LoaderXIPRom,                                           // 19
    LoaderHALCachedMemory,                                  // 1a
    LoaderMaximum                                           // 1b
} TYPE_OF_MEMORY;

typedef struct _MEMORY_ALLOCATION_DESCRIPTOR {
    LIST_ENTRY ListEntry;
    TYPE_OF_MEMORY MemoryType;
    ULONG BasePage;
    ULONG PageCount;
} MEMORY_ALLOCATION_DESCRIPTOR, *PMEMORY_ALLOCATION_DESCRIPTOR;


//
// Define loader parameter block structure.
//

typedef struct _NLS_DATA_BLOCK {
    PVOID AnsiCodePageData;
    PVOID OemCodePageData;
    PVOID UnicodeCaseTableData;
} NLS_DATA_BLOCK, *PNLS_DATA_BLOCK;

typedef struct _ARC_DISK_SIGNATURE {
    LIST_ENTRY ListEntry;
    ULONG   Signature;
    PCHAR   ArcName;
    ULONG   CheckSum;
    BOOLEAN ValidPartitionTable;
    BOOLEAN xInt13;
    BOOLEAN IsGpt;
    UCHAR Reserved;
    UCHAR GptSignature[16];
} ARC_DISK_SIGNATURE, *PARC_DISK_SIGNATURE;

typedef struct _ARC_DISK_INFORMATION {
    LIST_ENTRY DiskSignatures;
} ARC_DISK_INFORMATION, *PARC_DISK_INFORMATION;

typedef struct _I386_LOADER_BLOCK {

#if defined(_X86_) || defined(_AMD64_)

    PVOID CommonDataArea;
    ULONG MachineType;      // Temporary only
    ULONG VirtualBias;

#else

    ULONG PlaceHolder;

#endif

} I386_LOADER_BLOCK, *PI386_LOADER_BLOCK;

typedef struct _ALPHA_LOADER_BLOCK {

#if defined(_ALPHA_) || defined(_AXP64_)

    ULONG_PTR DpcStack;
    ULONG FirstLevelDcacheSize;
    ULONG FirstLevelDcacheFillSize;
    ULONG FirstLevelIcacheSize;
    ULONG FirstLevelIcacheFillSize;
    ULONG_PTR GpBase;
    ULONG_PTR PanicStack;
    ULONG PcrPage;
    ULONG PdrPage;
    ULONG SecondLevelDcacheSize;
    ULONG SecondLevelDcacheFillSize;
    ULONG SecondLevelIcacheSize;
    ULONG SecondLevelIcacheFillSize;
    ULONG PhysicalAddressBits;
    ULONG MaximumAddressSpaceNumber;
    UCHAR SystemSerialNumber[16];
    UCHAR SystemType[8];
    ULONG SystemVariant;
    ULONG SystemRevision;
    ULONG ProcessorType;
    ULONG ProcessorRevision;
    ULONG CycleClockPeriod;
    ULONG PageSize;
    PVOID RestartBlock;
    ULONGLONG FirmwareRestartAddress;
    ULONG FirmwareRevisionId;
    PVOID PalBaseAddress;
    UCHAR FirmwareVersion[16];
    UCHAR FirmwareBuildTimeStamp[20];

#else

    ULONG PlaceHolder;

#endif

} ALPHA_LOADER_BLOCK, *PALPHA_LOADER_BLOCK;

#if defined(_IA64_)
typedef struct _TR_INFO {
    BOOLEAN   Valid;
    UCHAR     Index;
    USHORT    Spare0;
    ULONG     PageSize;
    ULONGLONG VirtualAddress;
    ULONGLONG PhysicalAddress;
    ULONGLONG PhysicalAddressMemoryDescriptor;
    ULONG     PageSizeMemoryDescriptor;
    ULONG     Spare1;
} TR_INFO, *PTR_INFO;

typedef struct _EFI_MEM_MAP_PARAM {
    PUCHAR    MemoryMap;
    ULONGLONG MemoryMapSize;
    ULONGLONG MapKey;
    ULONGLONG DescriptorSize;
    ULONG     DescriptorVersion;
    ULONG     InitialPlatformPropertiesEfiFlags;
} EFI_MEM_MAP_PARAM, *PEFI_MEM_MAP_PARAM;

//
// VM info structure definitions
//
typedef union _IA64_VM_SUMMARY1 {
    struct {
        ULONGLONG HwWalker : 1;
        ULONGLONG PhysAddrSize : 7;
        ULONGLONG KeySize : 8;
        ULONGLONG MaxPkr : 8;
        ULONGLONG HashTagId : 8;
        ULONGLONG MaxDtrEntry : 8;
        ULONGLONG MaxItrEntry : 8;
        ULONGLONG NumUniqueTcs : 8;
        ULONGLONG NumTcLevels : 8;
    };
    ULONGLONG Ulong64;
} IA64_VM_SUMMARY1;

typedef union _IA64_VM_SUMMARY2 {
    struct {
        ULONGLONG ImplVaMsb : 8;
        ULONGLONG RidSize : 8;
        ULONGLONG Rsvd : 48;
    };
    ULONGLONG Ulong64;
} IA64_VM_SUMMARY2;

typedef union _IA64_DEPENDENT_FEATURES {
    struct {
        ULONGLONG Rsvd : 41;
        ULONGLONG XIregResource : 1;
        ULONGLONG XRegResource : 1;
        ULONGLONG DisableDynamicPrediatePrediction : 1;
        ULONGLONG DisableProcessorPhysicalNumber : 1;
        ULONGLONG DisableDynamicDataCachePrefetch : 1;
        ULONGLONG DisableDynamicInstructionCache : 1;
        ULONGLONG DisableDynamicBranchPrediction : 1;
        ULONGLONG Rsvd2 : 8;
        ULONGLONG DisableBINIT : 1;
        ULONGLONG DisableCoherency : 1;
        ULONGLONG DisableCache : 1;
        ULONGLONG EnableCMCIPromotion : 1;
        ULONGLONG EnableMCAtoBINIT : 1;
    };
    ULONGLONG Ulong64;
} IA64_DEPENDENT_FEATURES;

typedef struct _IA64_PTCE_INFO {
    ULONGLONG PtceBase;
    union {
        struct {
            ULONG Count1;
            ULONG Count2;
        };
        ULONGLONG Ulong64;
    } PtceTcCount;
    union {
        struct {
            ULONG Strides1;
            ULONG Strides2;
        };
        ULONGLONG Ulong64;
    } PtceStrides;
} IA64_PTCE_INFO;

typedef union _IA64_CACHE_INFO1 {
    ULONGLONG Ulong64;
    struct {
        ULONGLONG Unified : 1;
        ULONGLONG Attributes : 2;
        ULONGLONG Reserved : 5;
        ULONGLONG Associativity : 8;
        ULONGLONG LineSize : 8;
        ULONGLONG Stride : 8;
        ULONGLONG StoreLatency : 8;
        ULONGLONG LoadLatency : 8;
        ULONGLONG StoreHints : 8;
        ULONGLONG LoadHints : 8;
    };
}IA64_CACHE_INFO1, *PIA64_CACHE_INFO1;


typedef union _IA64_CACHE_INFO2 {
    ULONGLONG Ulong64;
    struct {
        ULONGLONG   Size : 32;
        ULONGLONG   Alias : 8;
        ULONGLONG   TagLeastBit : 8;
        ULONGLONG   TagMostBit : 8;
        ULONGLONG   Reserved : 8;
    };
}IA64_CACHE_INFO2, *PIA64_CACHE_INFO2;

#define CONFIG_INFO_CACHE_LEVELS 3
#define CONFIG_INFO_ICACHE 0
#define CONFIG_INFO_DCACHE 1

typedef struct _IA64_DEBUG_INFO  {
    ULONGLONG   Status;                  // The following fields are only valid if Status = 0. 
    ULONGLONG   InstDebugRegisterPairs;  // Number of pairs of Instruction debug registers.
    ULONGLONG   DataDebugRegisterPairs;  // Number of pairs of Data        debug registers.
} IA64_DEBUG_INFO, *PIA64_DEBUG_INFO;

typedef struct _IA64_PERFMON_INFO {
    ULONGLONG      Status;               // The following fields are only valid if Status = 0. 
    union {
        ULONGLONG  Ulong64;
        struct {
            ULONGLONG PerfMonGenericPairs      : 8;
            ULONGLONG ImplementedCounterWidth  : 8;
            ULONGLONG ProcessorCyclesEventType : 8;
            ULONGLONG RetiredInstructionBundlesEventType : 8;
            ULONGLONG Reserved : 32;
        };
    };
    // Note: The next following 128 bytes have to be continuous.
    UCHAR PerfMonCnfgMask[32];               // which PMC registers are implemented
    UCHAR PerfMonDataMask[32];               // which PMD registers are implemented
    UCHAR ProcessorCyclesMask[32];           // which registers can count cycles
    UCHAR RetiredInstructionBundlesMask[32]; // which registers can count retired bundles
} IA64_PERFMON_INFO, *PIA64_PERFMON_INFO;

typedef struct _PROCESSOR_CONFIG_INFO {
    ULONGLONG               InsertPageSizeInfo;
    ULONGLONG               PurgePageSizeInfo;
    IA64_VM_SUMMARY1        VmSummaryInfo1;
    IA64_VM_SUMMARY2        VmSummaryInfo2;
    ULONGLONG               NumOfPhysStackedRegs;
    ULONGLONG               RseHints;
    IA64_PTCE_INFO          PtceInfo;
    IA64_DEPENDENT_FEATURES FeaturesImplemented;
    IA64_DEPENDENT_FEATURES FeaturesCurSetting;
    IA64_DEPENDENT_FEATURES FeaturesSoftControl;
    ULONGLONG               ImplRegisterInfo1;
    ULONGLONG               ImplRegisterInfo2;
    ULONG                   CacheFlushStride;
    ULONG                   LargestCacheLine;
    ULONG                   NumberOfCacheLevels;
    IA64_CACHE_INFO1        CacheInfo1[2][CONFIG_INFO_CACHE_LEVELS]; // Pass several levels of cache information
    IA64_CACHE_INFO2        CacheInfo2[2][CONFIG_INFO_CACHE_LEVELS]; // One each for instruction and data.
    ULONGLONG               CpuId3;
    IA64_DEBUG_INFO         DebugInfo;
    IA64_PERFMON_INFO       PerfMonInfo;
} PROCESSOR_CONFIG_INFO, *PPROCESSOR_CONFIG_INFO;

#endif

typedef struct _IA64_LOADER_BLOCK {

#if defined(_IA64_)

    ULONG MachineType;
    ULONG WakeupVector;
    ULONG_PTR KernelPhysicalBase;
    ULONG_PTR KernelVirtualBase;
    ULONG_PTR InterruptStack;
    ULONG_PTR PanicStack;
    ULONG_PTR PcrPage;
    ULONG_PTR PdrPage;
    ULONG_PTR PcrPage2;
    ULONG_PTR FpswaInterface;
    ULONG_PTR EfiSystemTable;
    ULONG_PTR AcpiRsdt;
    TR_INFO Pal;
    //
    // K.B.  We don't really use a TR to map these, but the TR_INFO structure
    // is useful to comminicate info about these entries to the system.
    //
    TR_INFO Sal;
    TR_INFO SalGP;
    TR_INFO ItrInfo[8];
    TR_INFO DtrInfo[8];
    EFI_MEM_MAP_PARAM EfiMemMapParam;
    ULONG_PTR Reserved[10];
    PROCESSOR_CONFIG_INFO ProcessorConfigInfo;
#else

    ULONG PlaceHolder;

#endif

} IA64_LOADER_BLOCK, *PIA64_LOADER_BLOCK;

typedef struct _LOADER_PARAMETER_EXTENSION {
    ULONG   Size; // set to sizeof (struct _LOADER_PARAMETER_EXTENSION)
    PROFILE_PARAMETER_BLOCK Profile;
    ULONG   MajorVersion;
    ULONG   MinorVersion;
    PVOID   InfFileImage;   // Inf used to identify "broken" machines.
    ULONG   InfFileSize;

    //
    // Pointer to the triage block, if present.
    //

    PVOID TriageDumpBlock;

    ULONG LoaderPagesSpanned;   // Virtual Memory spanned by the loader
                                // that MM cannot recover the VA for.
    struct _HEADLESS_LOADER_BLOCK *HeadlessLoaderBlock;

    struct _SMBIOS_TABLE_HEADER *SMBiosEPSHeader;

    PVOID   DrvDBImage;   // Database used to identify "broken" drivers.
    ULONG   DrvDBSize;

    // If booting from the Network (PXE) then we will
    // save the Network boot params in this loader block
    struct _NETWORK_LOADER_BLOCK *NetworkLoaderBlock;

#if defined(_X86_)

    //
    // Pointers to IRQL translation tables that reside in the HAL
    // and are exposed to the kernel for use in the "inlined IRQL"
    // build
    //

    PUCHAR HalpIRQLToTPR;
    PUCHAR HalpVectorToIRQL;

#endif

    //
    // Firmware Location
    //
    LIST_ENTRY  FirmwareDescriptorListHead;
} LOADER_PARAMETER_EXTENSION, *PLOADER_PARAMETER_EXTENSION;

struct _SETUP_LOADER_BLOCK;
struct _HEADLESS_LOADER_BLOCK;
struct _SMBIOS_TABLE_HEADER;

typedef struct _NETWORK_LOADER_BLOCK {

    // Binary contents of the entire DHCP Acknowledgment
    // packet received by PXE.
    PUCHAR DHCPServerACK;
    ULONG DHCPServerACKLength;

    // Binary contents of the entire BINL Reply
    // packet received by PXE.
    PUCHAR BootServerReplyPacket;
    ULONG BootServerReplyPacketLength;

} NETWORK_LOADER_BLOCK, * PNETWORK_LOADER_BLOCK;


typedef struct _LOADER_PARAMETER_BLOCK {
    LIST_ENTRY LoadOrderListHead;
    LIST_ENTRY MemoryDescriptorListHead;
    LIST_ENTRY BootDriverListHead;
    ULONG_PTR KernelStack;
    ULONG_PTR Prcb;
    ULONG_PTR Process;
    ULONG_PTR Thread;
    ULONG RegistryLength;
    PVOID RegistryBase;
    PCONFIGURATION_COMPONENT_DATA ConfigurationRoot;
    PCHAR ArcBootDeviceName;
    PCHAR ArcHalDeviceName;
    PCHAR NtBootPathName;
    PCHAR NtHalPathName;
    PCHAR LoadOptions;
    PNLS_DATA_BLOCK NlsData;
    PARC_DISK_INFORMATION ArcDiskInformation;
    PVOID OemFontFile;
    struct _SETUP_LOADER_BLOCK *SetupLoaderBlock;
    PLOADER_PARAMETER_EXTENSION Extension;

    union {
        I386_LOADER_BLOCK I386;
        ALPHA_LOADER_BLOCK Alpha;
        IA64_LOADER_BLOCK Ia64;
    } u;


} LOADER_PARAMETER_BLOCK, *PLOADER_PARAMETER_BLOCK;

#endif // _ARC_