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