IntelFrameworkPkg/Include/Guid/StatusCodeDataTypeId.h

   1 /** @file
   2   GUID used to identify id for the caller who is initiating the Status Code.
   3
   4   Copyright (c) 2006, Intel Corporation
   5   All rights reserved. This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13   Module Name:  StatusCodeDataTypeId.h
  14
  15   @par Revision Reference:
  16   GUIDs defined in Status Codes Specification 0.92
  17
  18 **/
  19
  20 #ifndef __STATUS_CODE_DATA_TYPE_ID_GUID_H__
  21 #define __STATUS_CODE_DATA_TYPE_ID_GUID_H__
  22
  23 #include <PiPei.h>
  24 #include <Framework/StatusCode.h>
  25 #include <Framework/DataHubRecords.h>
  26 #include <Protocol/DebugSupport.h>
  27 #include <Protocol/FrameworkHii.h>
  28
  29 //////////////////////////////////////////////////////////////////////////////////////////
  30 // String Data Type defintion. This is part of Status Code Specification
  31 //////////////////////////////////////////////////////////////////////////////////////////
  32 #define EFI_STATUS_CODE_DATA_TYPE_STRING_GUID \
  33   { 0x92D11080, 0x496F, 0x4D95, { 0xBE, 0x7E, 0x03, 0x74, 0x88, 0x38, 0x2B, 0x0A } }
  34
  35 #pragma pack(1)
  36
  37 typedef enum {
  38   EfiStringAscii,    ///< A NULL-terminated ASCII string.
  39   EfiStringUnicode,  ///< A double NULL-terminated Unicode string.
  40   EfiStringToken     ///< An EFI_STATUS_CODE_STRING_TOKEN representing the string.
  41                      ///< The actual string can be obtained by querying the HII Database.
  42 } EFI_STRING_TYPE;
  43
  44 typedef struct {
  45   FRAMEWORK_EFI_HII_HANDLE  Handle;  ///< The HII handle of the string pack, which can be
  46                                      ///< used to retrieve the string. It is a dynamic value
  47                                      ///< that may not be the same for different boots.
  48   STRING_REF      Token;             ///< When combined with the HII handle, the string
  49                                      ///< token can be used to retrieve the string.
  50
  51 } EFI_STATUS_CODE_STRING_TOKEN;
  52
  53 typedef union {
  54   CHAR8                         *Ascii;   ///< ASCII formatted string.
  55   CHAR16                        *Unicode; ///< Unicode formatted string.
  56   EFI_STATUS_CODE_STRING_TOKEN  Hii;      ///< HII handle/token pair.
  57 } EFI_STATUS_CODE_STRING;
  58
  59 typedef struct {
  60   EFI_STATUS_CODE_DATA           DataHeader; ///< The data header identifying the data.
  61   EFI_STRING_TYPE                StringType; ///< Specifies if the string is ASCII or Unicode.
  62   EFI_STATUS_CODE_STRING         String;     ///< A pointer to a null-terminated ASCII or Unicode string.
  63 } EFI_STATUS_CODE_STRING_DATA;
  64 #pragma pack()
  65
  66 extern EFI_GUID gEfiStatusCodeDataTypeStringGuid;
  67
  68
  69 //////////////////////////////////////////////////////////////////////////////////////////
  70 // Special Data Type defintion. This is part of Status Code Specification
  71 //////////////////////////////////////////////////////////////////////////////////////////
  72 #define EFI_STATUS_CODE_SPECIFIC_DATA_GUID \
  73   { 0x335984bd, 0xe805, 0x409a, { 0xb8, 0xf8, 0xd2, 0x7e, 0xce, 0x5f, 0xf7, 0xa6 } }
  74
  75 #pragma pack(1)
  76
  77 ///
  78 /// Device handle Extended Data. Used for many
  79 /// errors and progress codes to point to the device.
  80 ///
  81 typedef struct {
  82   EFI_STATUS_CODE_DATA  DataHeader;
  83   EFI_HANDLE            Handle;
  84 } EFI_DEVICE_HANDLE_EXTENDED_DATA;
  85
  86 ///
  87 /// Extended data about the device path, which is used for many errors and
  88 /// progress codes to point to the device.
  89 ///
  90 typedef struct {
  91   EFI_STATUS_CODE_DATA                 DataHeader;
  92   UINT8                                *DevicePath;
  93 } EFI_DEVICE_PATH_EXTENDED_DATA;
  94
  95 ///
  96 /// This structure defines extended data describing a PCI resource allocation error.
  97 ///
  98 typedef struct {
  99   EFI_STATUS_CODE_DATA               DataHeader;
 100   UINT32                             Bar;
 101   UINT16                             DevicePathSize;
 102   UINT16                             ReqResSize;
 103   UINT16                             AllocResSize;
 104   UINT8                              *DevicePath;
 105   UINT8                              *ReqRes;
 106   UINT8                              *AllocRes;
 107 } EFI_RESOURCE_ALLOC_FAILURE_ERROR_DATA;
 108
 109 ///
 110 /// This structure provides the voltage at the time of error. It also provides
 111 /// the threshold value indicating the minimum or maximum voltage that is considered
 112 /// an error. If the voltage is less then the threshold, the error indicates that the
 113 /// voltage fell below the minimum acceptable value. If the voltage is greater then the threshold,
 114 /// the error indicates that the voltage rose above the maximum acceptable value.
 115 ///
 116 typedef struct {
 117   ///
 118   /// The data header identifying the data.
 119   ///
 120   EFI_STATUS_CODE_DATA  DataHeader;
 121   ///
 122   /// The voltage value at the time of the error.
 123   ///
 124   EFI_EXP_BASE10_DATA   Voltage;
 125   ///
 126   /// The voltage threshold.
 127   ///
 128   EFI_EXP_BASE10_DATA   Threshold;
 129 } EFI_COMPUTING_UNIT_VOLTAGE_ERROR_DATA;
 130
 131 ///
 132 /// Microcode Update Extended Error Data
 133 ///
 134 typedef struct {
 135   ///
 136   /// The data header identifying the data.
 137   ///
 138   EFI_STATUS_CODE_DATA  DataHeader;
 139   ///
 140   /// The version of the microcode update from the header.
 141   ///
 142   UINT32                Version;
 143 } EFI_COMPUTING_UNIT_MICROCODE_UPDATE_ERROR_DATA;
 144
 145 ///
 146 /// Asynchronous Timer Extended Error Data
 147 /// The timer limit provides the timeout value of the timer prior to expiration.
 148 ///
 149 typedef struct {
 150   ///
 151   /// The data header identifying the data.
 152   ///
 153   EFI_STATUS_CODE_DATA  DataHeader;
 154   ///
 155   /// The number of seconds that the computing unit timer was configured to expire.
 156   ///
 157   EFI_EXP_BASE10_DATA   TimerLimit;
 158 } EFI_COMPUTING_UNIT_TIMER_EXPIRED_ERROR_DATA;
 159
 160 ///
 161 /// Host Processor Mismatch Extended Error Data
 162 /// This provides information to indicate which processors mismatch, and how they mismatch. The
 163 /// status code contains the instance number of the processor that is in error. This structure's
 164 /// Instance indicates the second processor that does not match. This differentiation allows the
 165 /// consumer to determine which two processors do not match. The Attributes indicate what
 166 /// mismatch is being reported. Because Attributes is a bit field, more than one mismatch can be
 167 /// reported with one error code.
 168 ///
 169 typedef struct {
 170   ///
 171   /// The data header identifying the data.
 172   ///
 173   EFI_STATUS_CODE_DATA  DataHeader;
 174   ///
 175   /// The unit number of the computing unit that does not match.
 176   ///
 177   UINT32                Instance;
 178   ///
 179   /// The attributes describing the failure.
 180   ///
 181   UINT16                Attributes;
 182 } EFI_HOST_PROCESSOR_MISMATCH_ERROR_DATA;
 183
 184 ///
 185 /// Thermal Extended Error Data
 186 /// This structure provides the temperature at the time of error. It also provides the threshold value
 187 /// indicating the minimum temperature that is considered an error.
 188 ///
 189 typedef struct {
 190   ///
 191   /// The data header identifying the data.
 192   ///
 193   EFI_STATUS_CODE_DATA  DataHeader;
 194   ///
 195   /// The thermal value at the time of the error.
 196   ///
 197   EFI_EXP_BASE10_DATA   Temperature;
 198   ///
 199   /// The thermal threshold.
 200   ///
 201   EFI_EXP_BASE10_DATA   Threshold;
 202 } EFI_COMPUTING_UNIT_THERMAL_ERROR_DATA;
 203
 204 //
 205 // Valid cache types
 206 //
 207 typedef enum {
 208   EfiInitCacheDataOnly,
 209   EfiInitCacheInstrOnly,
 210   EfiInitCacheBoth,
 211   EfiInitCacheUnspecified
 212 } EFI_INIT_CACHE_TYPE;
 213
 214 ///
 215 /// Embedded cache init extended data
 216 ///
 217 typedef struct {
 218   EFI_STATUS_CODE_DATA  DataHeader;
 219   UINT32                Level;
 220   EFI_INIT_CACHE_TYPE   Type;
 221 } EFI_CACHE_INIT_DATA;
 222
 223 ///
 224 /// Processor Disabled Extended Error Data
 225 /// This structure provides details as to why and how the computing unit was disabled. The causes
 226 /// should cover the typical reasons a processor would be disabled. How the processor was disabled is
 227 /// important because there are distinct differences between hardware and software disabling.
 228 ///
 229 typedef struct {
 230   ///
 231   /// The data header identifying the data.
 232   ///
 233   EFI_STATUS_CODE_DATA  DataHeader;
 234   ///
 235   /// The reason for disabling the processor.
 236   ///
 237   UINT32                Cause;
 238   ///
 239   /// TRUE if the processor is disabled via software means such as not listing it in the ACPI tables.
 240   /// Such a processor will respond to Interprocessor Interrupts (IPIs). FALSE if the processor is hardware
 241   /// disabled, which means it is invisible to software and will not respond to IPIs.
 242   ///
 243   BOOLEAN               SoftwareDisabled;
 244 } EFI_COMPUTING_UNIT_CPU_DISABLED_ERROR_DATA;
 245
 246 ///
 247 /// Memory Error Operation Definition
 248 ///
 249 typedef UINT8 EFI_MEMORY_ERROR_OPERATION;
 250
 251 ///
 252 /// Memory Error Granularity Definition
 253 ///
 254 typedef UINT8 EFI_MEMORY_ERROR_GRANULARITY;
 255
 256 ///
 257 /// This structure provides specific details about the memory error that was detected. It provides
 258 /// enough information so that consumers can identify the exact failure and provides enough
 259 /// information to enable corrective action if necessary.
 260 ///
 261 typedef struct {
 262   ///
 263   /// The data header identifying the data.
 264   ///
 265   EFI_STATUS_CODE_DATA          DataHeader;
 266   ///
 267   /// The error granularity type.
 268   ///
 269   EFI_MEMORY_ERROR_GRANULARITY  Granularity;
 270   ///
 271   /// The operation that resulted in the error being detected.
 272   ///
 273   EFI_MEMORY_ERROR_OPERATION    Operation;
 274   ///
 275   /// The error syndrome, vendor-specific ECC syndrome, or CRC data associated with
 276   /// the error.  If unknown, should be initialized to 0.
 277   ///
 278   UINTN                         Syndrome;
 279   ///
 280   /// The physical address of the error.
 281   ///
 282   EFI_PHYSICAL_ADDRESS          Address;
 283   ///
 284   /// The range, in bytes, within which the error address can be determined.
 285   ///
 286   UINTN                         Resolution;
 287 } EFI_MEMORY_EXTENDED_ERROR_DATA;
 288
 289 ///
 290 /// This extended data provides some context that consumers can use to locate a DIMM within the
 291 /// overall memory scheme.
 292 ///
 293 typedef struct {
 294   ///
 295   /// The data header identifying the data.
 296   ///
 297   EFI_STATUS_CODE_DATA  DataHeader;
 298   ///
 299   /// The memory array number.
 300   ///
 301   UINT16                Array;
 302   ///
 303   /// The device number within that Array.
 304   ///
 305   UINT16                Device;
 306 } EFI_STATUS_CODE_DIMM_NUMBER;
 307
 308 ///
 309 /// Memory Module Mismatch Extended Error Data
 310 ///
 311 typedef struct {
 312   ///
 313   /// The data header identifying the data.
 314   ///
 315   EFI_STATUS_CODE_DATA        DataHeader;
 316   ///
 317   /// The instance number of the memory module that does not match.
 318   ///
 319   EFI_STATUS_CODE_DIMM_NUMBER Instance;
 320 } EFI_MEMORY_MODULE_MISMATCH_ERROR_DATA;
 321
 322 ///
 323 /// Memory Range Extended Data
 324 /// This extended data may be used to convey the specifics of a memory range.  Ranges are specified
 325 /// with a start address and a length.
 326 ///
 327 typedef struct {
 328   ///
 329   /// The data header identifying the data.
 330   ///
 331   EFI_STATUS_CODE_DATA  DataHeader;
 332   ///
 333   /// The starting address of the memory range.
 334   ///
 335   EFI_PHYSICAL_ADDRESS  Start;
 336   ///
 337   /// The length in bytes of the memory range.
 338   ///
 339   EFI_PHYSICAL_ADDRESS  Length;
 340 } EFI_MEMORY_RANGE_EXTENDED_DATA;
 341
 342 ///
 343 /// Extended Error Data for Assert
 344 /// The data indicates the location of the assertion that failed in the source code.  This information
 345 /// includes the file name and line number that are necessary to find the failing assertion in source code.
 346 ///
 347 typedef struct {
 348   ///
 349   /// The data header identifying the data.
 350   ///
 351   EFI_STATUS_CODE_DATA        DataHeader;
 352   ///
 353   /// The line number of the source file where the fault was generated.
 354   ///
 355   UINT32                      LineNumber;
 356   ///
 357   /// The size in bytes of FileName.
 358   ///
 359   UINT32                      FileNameSize;
 360   ///
 361   /// A pointer to a NULL-terminated ASCII or Unicode string that represents the file
 362   /// name of the source file where the fault was generated.
 363   ///
 364   EFI_STATUS_CODE_STRING_DATA *FileName;
 365 } EFI_DEBUG_ASSERT_DATA;
 366
 367 ///
 368 /// System Context Data EBC/IA32/IPF
 369 ///
 370 typedef union {
 371   EFI_SYSTEM_CONTEXT_EBC  SystemContextEbc;
 372   EFI_SYSTEM_CONTEXT_IA32 SystemContextIa32;
 373   EFI_SYSTEM_CONTEXT_IPF  SystemContextIpf;
 374 } EFI_STATUS_CODE_EXCEP_SYSTEM_CONTEXT;
 375
 376 ///
 377 /// This extended data allows the processor context that is present at the time of the exception to be
 378 /// reported with the exception. The format and contents of the context data varies depending on the
 379 /// processor architecture.
 380 ///
 381 typedef struct {
 382   ///
 383   /// The data header identifying the data.
 384   ///
 385   EFI_STATUS_CODE_DATA                  DataHeader;
 386   ///
 387   /// The system context.
 388   ///
 389   EFI_STATUS_CODE_EXCEP_SYSTEM_CONTEXT  Context;
 390 } EFI_STATUS_CODE_EXCEP_EXTENDED_DATA;
 391
 392 ///
 393 /// This extended data records information about a Start() function call. Start() is a member of
 394 /// the EFI 1.10 Driver Binding Protocol.
 395 ///
 396 typedef struct {
 397   ///
 398   /// The data header identifying the data.
 399   ///
 400   EFI_STATUS_CODE_DATA           DataHeader;
 401   ///
 402   /// The controller handle.
 403   ///
 404   EFI_HANDLE                     ControllerHandle;
 405   ///
 406   /// The driver binding handle.
 407   ///
 408   EFI_HANDLE                     DriverBindingHandle;
 409   ///
 410   /// The size of the RemainingDevicePath. It is zero if the Start() function is
 411   /// called with RemainingDevicePath = NULL.
 412   ///
 413   UINT16                         DevicePathSize;
 414   ///
 415   /// Matches the RemainingDevicePath parameter being passed to the Start()
 416   /// function. Note that this parameter is the variable-length device path and not a pointer
 417   /// to the device path.
 418   ///
 419   UINT8                          *RemainingDevicePath;
 420 } EFI_STATUS_CODE_START_EXTENDED_DATA;
 421
 422 ///
 423 /// Legacy Oprom extended data
 424 /// The device handle and ROM image base can be used by consumers to determine which option
 425 /// ROM failed. Due to the black-box nature of legacy option ROMs, the amount of information that
 426 /// can be obtained may be limited.
 427 ///
 428 typedef struct {
 429   ///
 430   /// The data header identifying the data.
 431   ///
 432   EFI_STATUS_CODE_DATA  DataHeader;
 433   ///
 434   /// The handle corresponding to the device that this legacy option ROM is being invoked.
 435   ///
 436   EFI_HANDLE            DeviceHandle;
 437   ///
 438   /// The base address of the shadowed legacy ROM image.
 439   /// May or may not point to the shadow RAM area.
 440   ///
 441   EFI_PHYSICAL_ADDRESS  RomImageBase;
 442 } EFI_LEGACY_OPROM_EXTENDED_DATA;
 443
 444 #pragma pack()
 445
 446 extern EFI_GUID gEfiStatusCodeSpecificDataGuid;
 447
 448 //
 449 // EFI_COMPUTING_UNIT_MISMATCH_ATTRIBUTES
 450 // All other attributes are reserved for future use and
 451 // must be initialized to 0.
 452 //
 453 #define EFI_COMPUTING_UNIT_MISMATCH_SPEED       0x0001
 454 #define EFI_COMPUTING_UNIT_MISMATCH_FSB_SPEED   0x0002
 455 #define EFI_COMPUTING_UNIT_MISMATCH_FAMILY      0x0004
 456 #define EFI_COMPUTING_UNIT_MISMATCH_MODEL       0x0008
 457 #define EFI_COMPUTING_UNIT_MISMATCH_STEPPING    0x0010
 458 #define EFI_COMPUTING_UNIT_MISMATCH_CACHE_SIZE  0x0020
 459 #define EFI_COMPUTING_UNIT_MISMATCH_OEM1        0x1000
 460 #define EFI_COMPUTING_UNIT_MISMATCH_OEM2        0x2000
 461 #define EFI_COMPUTING_UNIT_MISMATCH_OEM3        0x4000
 462 #define EFI_COMPUTING_UNIT_MISMATCH_OEM4        0x8000
 463
 464
 465
 466 //
 467 // Memory Error Granularities
 468 //
 469 #define EFI_MEMORY_ERROR_OTHER      0x01
 470 #define EFI_MEMORY_ERROR_UNKNOWN    0x02
 471 #define EFI_MEMORY_ERROR_DEVICE     0x03
 472 #define EFI_MEMORY_ERROR_PARTITION  0x04
 473
 474 //
 475 // Memory Error Operations
 476 //
 477 #define EFI_MEMORY_OPERATION_OTHER          0x01
 478 #define EFI_MEMORY_OPERATION_UNKNOWN        0x02
 479 #define EFI_MEMORY_OPERATION_READ           0x03
 480 #define EFI_MEMORY_OPERATION_WRITE          0x04
 481 #define EFI_MEMORY_OPERATION_PARTIAL_WRITE  0x05
 482
 483 //
 484 // Define shorthands to describe Group Operations
 485 // Many memory init operations are essentially group
 486 // operations.
 487
 488 /// A shorthand to describe that the operation is performed
 489 /// on multiple devices within the array
 490 ///
 491 #define EFI_MULTIPLE_MEMORY_DEVICE_OPERATION  0xfffe
 492 ///
 493 /// A shorthand to describe that the operation is performed on all devices within the array
 494 ///
 495 #define EFI_ALL_MEMORY_DEVICE_OPERATION 0xffff
 496 ///
 497 /// A shorthand to describe that the operation is performed on multiple arrays
 498 ///
 499 #define EFI_MULTIPLE_MEMORY_ARRAY_OPERATION 0xfffe
 500 ///
 501 /// A shorthand to describe that the operation is performed on all the arrays
 502 ///
 503 #define EFI_ALL_MEMORY_ARRAY_OPERATION  0xffff
 504
 505 #endif