/*++ 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_