IntelFrameworkPkg/Include/Framework/SmmCis.h

   1 /** @file
   2   Include file for definitions in the Intel Platform Innovation Framework for EFI
   3   System Management Mode Core Interface Specification (SMM CIS) version 0.90.
   4
   5   Copyright (c) 2007 - 2009, Intel Corporation
   6   All rights reserved. This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #ifndef _SMM_CIS_H_
  17 #define _SMM_CIS_H_
  18
  19 #define EFI_SMM_CPU_IO_GUID \
  20   { \
  21     0x5f439a0b, 0x45d8, 0x4682, {0xa4, 0xf4, 0xf0, 0x57, 0x6b, 0x51, 0x34, 0x41 } \
  22   }
  23
  24 typedef struct _EFI_SMM_SYSTEM_TABLE      EFI_SMM_SYSTEM_TABLE;
  25 typedef struct _EFI_SMM_CPU_IO_INTERFACE  EFI_SMM_CPU_IO_INTERFACE;
  26
  27
  28 //
  29 // SMM Base specification constant and types
  30 //
  31 #define SMM_SMST_SIGNATURE            SIGNATURE_32 ('S', 'M', 'S', 'T')
  32 #define EFI_SMM_SYSTEM_TABLE_REVISION (0 << 16) | (0x09)
  33
  34 //
  35 // *******************************************************
  36 // EFI_SMM_IO_WIDTH
  37 // *******************************************************
  38 //
  39 typedef enum {
  40   SMM_IO_UINT8  = 0,
  41   SMM_IO_UINT16 = 1,
  42   SMM_IO_UINT32 = 2,
  43   SMM_IO_UINT64 = 3
  44 } EFI_SMM_IO_WIDTH;
  45
  46 /**
  47   Provides the basic memory and I/O interfaces that are used to
  48   abstract accesses to devices.
  49
  50   @param  This             The EFI_SMM_CPU_IO_INTERFACE instance.
  51   @param  Width            Signifies the width of the I/O operations.
  52   @param  Address          The base address of the I/O operations.
  53   @param  Count            The number of I/O operations to perform.
  54   @param  Buffer           For read operations, the destination buffer to store the results (out parameter).
  55                            For write operations, the source buffer from which to write data (in parameter).
  56
  57   @retval EFI_SUCCESS           The data was read from or written to the device.
  58   @retval EFI_UNSUPPORTED       The Address is not valid for this system.
  59   @retval EFI_INVALID_PARAMETER Width or Count, or both, were invalid.
  60   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
  61
  62 **/
  63 typedef
  64 EFI_STATUS
  65 (EFIAPI *EFI_SMM_CPU_IO)(
  66   IN EFI_SMM_CPU_IO_INTERFACE         *This,
  67   IN EFI_SMM_IO_WIDTH                 Width,
  68   IN UINT64                           Address,
  69   IN UINTN                            Count,
  70   IN OUT VOID                         *Buffer
  71   );
  72
  73 typedef struct {
  74   EFI_SMM_CPU_IO  Read;  ///< This service provides the various modalities of memory and I/O read.
  75   EFI_SMM_CPU_IO  Write; ///< This service provides the various modalities of memory and I/O write.
  76 } EFI_SMM_IO_ACCESS;
  77
  78 ///
  79 /// The EFI_SMM_CPU_IO_INTERFACE service provides the basic memory, I/O, and PCI
  80 /// interfaces that are used to abstract accesses to devices.
  81 ///
  82 struct _EFI_SMM_CPU_IO_INTERFACE {
  83   ///
  84   /// Allows reads and writes to memory-mapped I/O space.
  85   ///
  86   EFI_SMM_IO_ACCESS Mem;
  87   ///
  88   /// Allows reads and writes to I/O space.
  89   ///
  90   EFI_SMM_IO_ACCESS Io;
  91 };
  92
  93 /**
  94   Allocates pool memory from SMRAM for IA-32 or runtime memory for
  95   the Itanium processor family.
  96
  97   @param  PoolType         The type of pool to allocate. The only supported type is EfiRuntimeServicesData
  98   @param  Size             The number of bytes to allocate from the pool.
  99   @param  Buffer           A pointer to a pointer to the allocated buffer if the call
 100                            succeeds; undefined otherwise.
 101
 102   @retval EFI_SUCCESS           The requested number of bytes was allocated.
 103   @retval EFI_OUT_OF_RESOURCES  The pool requested could not be allocated.
 104   @retval EFI_UNSUPPORTED       In runtime.
 105   @note: Inconsistent with specification here:
 106          In Framework Spec, This definition is naming EFI_SMM_ALLOCATE_POOL. However,
 107          To avoid the naming conflict, the definition is renamed.
 108 **/
 109 typedef
 110 EFI_STATUS
 111 (EFIAPI *EFI_SMMCORE_ALLOCATE_POOL)(
 112   IN EFI_MEMORY_TYPE                PoolType,
 113   IN UINTN                          Size,
 114   OUT VOID                          **Buffer
 115   );
 116
 117 /**
 118   Returns pool memory to the system.
 119
 120   @param  Buffer           Pointer to the buffer to free.
 121
 122   @retval EFI_SUCCESS           The memory was returned to the system.
 123   @retval EFI_INVALID_PARAMETER Buffer was invalid.
 124   @retval EFI_UNSUPPORTED       In runtime.
 125   @note: Inconsistent with specification here:
 126          In the Framework Spec, this definition is named EFI_SMM_FREE_POOL.
 127          To avoid a naming conflict, the definition here is renamed.
 128 **/
 129 typedef
 130 EFI_STATUS
 131 (EFIAPI *EFI_SMMCORE_FREE_POOL)(
 132   IN VOID                   *Buffer
 133   );
 134
 135 /**
 136   Allocates memory pages from the system.
 137
 138   @param  Type             The type of allocation to perform.
 139   @param  MemoryType       The only supported type is EfiRuntimeServicesData
 140   @param  NumberofPages    The number of contiguous 4 KB pages to allocate
 141   @param  Memory           Pointer to a physical address. On input, the way in which
 142                            the address is used depends on the value of Type. On output, the address
 143                            is set to the base of the page range that was allocated.
 144
 145   @retval EFI_SUCCESS           The requested pages were allocated.
 146   @retval EFI_OUT_OF_RESOURCES  The pages requested could not be allocated.
 147   @retval EFI_NOT_FOUND         The requested pages could not be found.
 148   @retval EFI_INVALID_PARAMETER Type is not AllocateAnyPages or AllocateMaxAddress
 149                                 or AllocateAddress. Or MemoryType is in the range EfiMaxMemoryType..0x7FFFFFFF.
 150   @note: Inconsistent with specification here:
 151          In the Framework Spec, this definition is named EFI_SMM_ALLOCATE_PAGES.
 152          To avoid a naming conflict, the definition here is renamed.
 153 **/
 154 typedef
 155 EFI_STATUS
 156 (EFIAPI *EFI_SMMCORE_ALLOCATE_PAGES)(
 157   IN EFI_ALLOCATE_TYPE      Type,
 158   IN EFI_MEMORY_TYPE        MemoryType,
 159   IN UINTN                  NumberOfPages,
 160   OUT EFI_PHYSICAL_ADDRESS  *Memory
 161   );
 162
 163 /**
 164   Frees memory pages for the system.
 165
 166   @param  Memory           The base physical address of the pages to be freed
 167   @param  NumberOfPages    The number of contiguous 4 KB pages to free.
 168
 169   @retval EFI_SUCCESS           The requested memory pages were freed.
 170   @retval EFI_INVALID_PARAMETER Memory is not a page-aligned address or NumberOfPages is invalid.
 171   @retval EFI_NOT_FOUND         The requested memory pages were not allocated with SmmAllocatePages().
 172
 173   @note: Inconsistent with specification here:
 174          In the Framework Spec, this definition is named EFI_SMM_FREE_PAGES.
 175          To avoid a naming conflict, the definition here is renamed.
 176 **/
 177 typedef
 178 EFI_STATUS
 179 (EFIAPI *EFI_SMMCORE_FREE_PAGES)(
 180   IN EFI_PHYSICAL_ADDRESS   Memory,
 181   IN UINTN                  NumberOfPages
 182   );
 183
 184 /**
 185   Frees memory pages for the system.
 186
 187   @param  Procedure         A pointer to the code stream to be run on the designated AP of the system.
 188   @param  CpuNumber         The zero-based index of the processor number of the AP on which the code stream is
 189                             supposed to run. If the processor number points to the current processor or a disabled
 190                             processor, then it will not run the supplied code.
 191   @param  ProcArguments     Allows the caller to pass a list of parameters to the code that is run by
 192                             the AP. It is an optional common mailbox between APs and the BSP to share information.
 193
 194   @retval EFI_SUCCESS           The call was successful and the return parameters are valid.
 195   @retval EFI_INVALID_PARAMETER The input arguments are out of range.
 196   @retval EFI_INVALID_PARAMETER The CPU requested is not available on this SMI invocation.
 197   @retval EFI_INVALID_PARAMETER The CPU cannot support an additional service invocation.
 198
 199   @note: Inconsistent with specification here:
 200          In Framework Spec, this definition does not exist. This method is introduced in PI1.0 spec for
 201          implementation needs.
 202
 203 **/
 204 typedef
 205 EFI_STATUS
 206 (EFIAPI *EFI_SMM_STARTUP_THIS_AP)(
 207   IN  FRAMEWORK_EFI_AP_PROCEDURE          Procedure,
 208   IN  UINTN                               CpuNumber,
 209   IN  OUT VOID                            *ProcArguments OPTIONAL
 210   );
 211
 212 ///
 213 /// The processor save-state information for IA-32 processors. This information is important in that the
 214 /// SMM drivers may need to ascertain the state of the processor before invoking the SMI.
 215 ///
 216 typedef struct {
 217   ///
 218   /// Reserved for future processors. As such, software should not attempt to interpret or
 219   /// write to this region.
 220   ///
 221   UINT8                 Reserved1[248];
 222   ///
 223   /// The location of the processor SMBASE, which is the location where the processor
 224   /// will pass control upon receipt of an SMI.
 225   ///
 226   UINT32                SMBASE;
 227   ///
 228   /// The revision of the SMM save state. This value is set by the processor.
 229   ///
 230   UINT32                SMMRevId;
 231   ///
 232   /// The value of the I/O restart field. Allows for restarting an in-process I/O instruction.
 233   ///
 234   UINT16                IORestart;
 235   ///
 236   /// Describes behavior that should be commenced in response to a halt instruction.
 237   ///
 238   UINT16                AutoHALTRestart;
 239   ///
 240   /// Reserved for future processors. As such, software should not attempt to interpret or
 241   /// write to this region.
 242   ///
 243   UINT8                 Reserved2[164];
 244
 245   //
 246   // Registers in IA-32 processors.
 247   //
 248   UINT32                ES;
 249   UINT32                CS;
 250   UINT32                SS;
 251   UINT32                DS;
 252   UINT32                FS;
 253   UINT32                GS;
 254   UINT32                LDTBase;
 255   UINT32                TR;
 256   UINT32                DR7;
 257   UINT32                DR6;
 258   UINT32                EAX;
 259   UINT32                ECX;
 260   UINT32                EDX;
 261   UINT32                EBX;
 262   UINT32                ESP;
 263   UINT32                EBP;
 264   UINT32                ESI;
 265   UINT32                EDI;
 266   UINT32                EIP;
 267   UINT32                EFLAGS;
 268   UINT32                CR3;
 269   UINT32                CR0;
 270 } EFI_SMI_CPU_SAVE_STATE;
 271
 272 ///
 273 /// The processor save-state information for the Itanium processor family. This information is
 274 /// important in that the SMM drivers may need to ascertain the state of the processor before invoking
 275 /// the PMI. This structure is mandatory and must be 512 byte aligned.
 276 ///
 277 typedef struct {
 278   UINT64   reserved;
 279   UINT64   r1;
 280   UINT64   r2;
 281   UINT64   r3;
 282   UINT64   r4;
 283   UINT64   r5;
 284   UINT64   r6;
 285   UINT64   r7;
 286   UINT64   r8;
 287   UINT64   r9;
 288   UINT64   r10;
 289   UINT64   r11;
 290   UINT64   r12;
 291   UINT64   r13;
 292   UINT64   r14;
 293   UINT64   r15;
 294   UINT64   r16;
 295   UINT64   r17;
 296   UINT64   r18;
 297   UINT64   r19;
 298   UINT64   r20;
 299   UINT64   r21;
 300   UINT64   r22;
 301   UINT64   r23;
 302   UINT64   r24;
 303   UINT64   r25;
 304   UINT64   r26;
 305   UINT64   r27;
 306   UINT64   r28;
 307   UINT64   r29;
 308   UINT64   r30;
 309   UINT64   r31;
 310
 311   UINT64   pr;
 312
 313   UINT64   b0;
 314   UINT64   b1;
 315   UINT64   b2;
 316   UINT64   b3;
 317   UINT64   b4;
 318   UINT64   b5;
 319   UINT64   b6;
 320   UINT64   b7;
 321
 322   // application registers
 323   UINT64   ar_rsc;
 324   UINT64   ar_bsp;
 325   UINT64   ar_bspstore;
 326   UINT64   ar_rnat;
 327
 328   UINT64   ar_fcr;
 329
 330   UINT64   ar_eflag;
 331   UINT64   ar_csd;
 332   UINT64   ar_ssd;
 333   UINT64   ar_cflg;
 334   UINT64   ar_fsr;
 335   UINT64   ar_fir;
 336   UINT64   ar_fdr;
 337
 338   UINT64   ar_ccv;
 339
 340   UINT64   ar_unat;
 341
 342   UINT64   ar_fpsr;
 343
 344   UINT64   ar_pfs;
 345   UINT64   ar_lc;
 346   UINT64   ar_ec;
 347
 348   // control registers
 349   UINT64   cr_dcr;
 350   UINT64   cr_itm;
 351   UINT64   cr_iva;
 352   UINT64   cr_pta;
 353   UINT64   cr_ipsr;
 354   UINT64   cr_isr;
 355   UINT64   cr_iip;
 356   UINT64   cr_ifa;
 357   UINT64   cr_itir;
 358   UINT64   cr_iipa;
 359   UINT64   cr_ifs;
 360   UINT64   cr_iim;
 361   UINT64   cr_iha;
 362
 363   // debug registers
 364   UINT64   dbr0;
 365   UINT64   dbr1;
 366   UINT64   dbr2;
 367   UINT64   dbr3;
 368   UINT64   dbr4;
 369   UINT64   dbr5;
 370   UINT64   dbr6;
 371   UINT64   dbr7;
 372
 373   UINT64   ibr0;
 374   UINT64   ibr1;
 375   UINT64   ibr2;
 376   UINT64   ibr3;
 377   UINT64   ibr4;
 378   UINT64   ibr5;
 379   UINT64   ibr6;
 380   UINT64   ibr7;
 381
 382   // virtual registers
 383   UINT64   int_nat;         // nat bits for R1-R31
 384
 385 } EFI_PMI_SYSTEM_CONTEXT;
 386
 387 ///
 388 /// The processor save-state information for IA-32 and Itanium processors. This information is
 389 /// important in that the SMM drivers may need to ascertain the state of the processor before invoking
 390 /// the SMI or PMI.
 391 ///
 392 typedef union {
 393   ///
 394   /// The processor save-state information for IA-32 processors.
 395   ///
 396   EFI_SMI_CPU_SAVE_STATE     Ia32SaveState;
 397   ///
 398   /// The processor save-state information for Itanium processors.
 399   ///
 400   EFI_PMI_SYSTEM_CONTEXT     ItaniumSaveState;
 401 } EFI_SMM_CPU_SAVE_STATE;
 402
 403 ///
 404 /// The optional floating point save-state information for IA-32 processors. If the optional floating
 405 /// point save is indicated for any handler, the following data structure must be preserved.
 406 ///
 407 typedef struct {
 408   UINT16                Fcw;
 409   UINT16                Fsw;
 410   UINT16                Ftw;
 411   UINT16                Opcode;
 412   UINT32                Eip;
 413   UINT16                Cs;
 414   UINT16                Rsvd1;
 415   UINT32                DataOffset;
 416   UINT16                Ds;
 417   UINT8                 Rsvd2[10];
 418   UINT8                 St0Mm0[10], Rsvd3[6];
 419   UINT8                 St0Mm1[10], Rsvd4[6];
 420   UINT8                 St0Mm2[10], Rsvd5[6];
 421   UINT8                 St0Mm3[10], Rsvd6[6];
 422   UINT8                 St0Mm4[10], Rsvd7[6];
 423   UINT8                 St0Mm5[10], Rsvd8[6];
 424   UINT8                 St0Mm6[10], Rsvd9[6];
 425   UINT8                 St0Mm7[10], Rsvd10[6];
 426   UINT8                 Rsvd11[22*16];
 427 } EFI_SMI_OPTIONAL_FPSAVE_STATE;
 428
 429 ///
 430 /// The optional floating point save-state information for the Itanium processor family. If the optional
 431 /// floating point save is indicated for any handler, then this data structure must be preserved.
 432 ///
 433 typedef struct {
 434   UINT64   f2[2];
 435   UINT64   f3[2];
 436   UINT64   f4[2];
 437   UINT64   f5[2];
 438   UINT64   f6[2];
 439   UINT64   f7[2];
 440   UINT64   f8[2];
 441   UINT64   f9[2];
 442   UINT64   f10[2];
 443   UINT64   f11[2];
 444   UINT64   f12[2];
 445   UINT64   f13[2];
 446   UINT64   f14[2];
 447   UINT64   f15[2];
 448   UINT64   f16[2];
 449   UINT64   f17[2];
 450   UINT64   f18[2];
 451   UINT64   f19[2];
 452   UINT64   f20[2];
 453   UINT64   f21[2];
 454   UINT64   f22[2];
 455   UINT64   f23[2];
 456   UINT64   f24[2];
 457   UINT64   f25[2];
 458   UINT64   f26[2];
 459   UINT64   f27[2];
 460   UINT64   f28[2];
 461   UINT64   f29[2];
 462   UINT64   f30[2];
 463   UINT64   f31[2];
 464 } EFI_PMI_OPTIONAL_FLOATING_POINT_CONTEXT;
 465
 466 ///
 467 /// The processor save-state information for IA-32 and Itanium processors. If the optional floating
 468 /// point save is indicated for any handler, then this data structure must be preserved.
 469 ///
 470 typedef union {
 471   ///
 472   /// The optional floating point save-state information for IA-32 processors.
 473   ///
 474   EFI_SMI_OPTIONAL_FPSAVE_STATE             Ia32FpSave;
 475   ///
 476   /// The optional floating point save-state information for Itanium processors.
 477   ///
 478   EFI_PMI_OPTIONAL_FLOATING_POINT_CONTEXT   ItaniumFpSave;
 479 } EFI_SMM_FLOATING_POINT_SAVE_STATE;
 480
 481 /**
 482   This function is the main entry point for an SMM handler dispatch
 483   or communicate-based callback.
 484
 485   @param  SmmImageHandle   A unique value returned by the SMM infrastructure
 486                            in response to registration for a communicate-based callback or dispatch.
 487   @param  CommunicationBuffer
 488                            An optional buffer that will be populated
 489                            by the SMM infrastructure in response to a non-SMM agent (preboot or runtime)
 490                            invoking the EFI_SMM_BASE_PROTOCOL.Communicate() service.
 491   @param  SourceSize       If CommunicationBuffer is non-NULL, this field
 492                            indicates the size of the data payload in this buffer.
 493
 494   @return Status Code
 495
 496 **/
 497 typedef
 498 EFI_STATUS
 499 (EFIAPI *EFI_SMM_HANDLER_ENTRY_POINT)(
 500   IN EFI_HANDLE             SmmImageHandle,
 501   IN OUT VOID               *CommunicationBuffer OPTIONAL,
 502   IN OUT UINTN              *SourceSize OPTIONAL
 503   );
 504
 505 /**
 506   The SmmInstallConfigurationTable() function is used to maintain the list
 507   of configuration tables that are stored in the System Management System
 508   Table.  The list is stored as an array of (GUID, Pointer) pairs.  The list
 509   must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
 510
 511   @param  SystemTable      A pointer to the SMM System Table.
 512   @param  Guid             A pointer to the GUID for the entry to add, update, or remove.
 513   @param  Table            A pointer to the buffer of the table to add.
 514   @param  TableSize        The size of the table to install.
 515
 516   @retval EFI_SUCCESS           The (Guid, Table) pair was added, updated, or removed.
 517   @retval EFI_INVALID_PARAMETER Guid is not valid.
 518   @retval EFI_NOT_FOUND         An attempt was made to delete a non-existent entry.
 519   @retval EFI_OUT_OF_RESOURCES  There is not enough memory available to complete the operation.
 520
 521 **/
 522 typedef
 523 EFI_STATUS
 524 (EFIAPI *EFI_SMM_INSTALL_CONFIGURATION_TABLE)(
 525   IN EFI_SMM_SYSTEM_TABLE         *SystemTable,
 526   IN EFI_GUID                     *Guid,
 527   IN VOID                         *Table,
 528   IN UINTN                        TableSize
 529   );
 530
 531 //
 532 // System Management System Table (SMST)
 533 //
 534 struct _EFI_SMM_SYSTEM_TABLE {
 535   ///
 536   /// The table header for the System Management System Table (SMST).
 537   ///
 538   EFI_TABLE_HEADER                    Hdr;
 539
 540   ///
 541   /// A pointer to a NULL-terminated Unicode string containing the vendor name. It is
 542   /// permissible for this pointer to be NULL.
 543   ///
 544   CHAR16                              *SmmFirmwareVendor;
 545   ///
 546   /// The particular revision of the firmware.
 547   ///
 548   UINT32                              SmmFirmwareRevision;
 549
 550   ///
 551   /// Adds, updates, or removes a configuration table entry from the SMST.
 552   ///
 553   EFI_SMM_INSTALL_CONFIGURATION_TABLE SmmInstallConfigurationTable;
 554
 555   //
 556   // I/O Services
 557   //
 558   ///
 559   /// A GUID that designates the particular CPU I/O services.
 560   ///
 561   EFI_GUID                            EfiSmmCpuIoGuid;
 562   ///
 563   /// Provides the basic memory and I/O interfaces that are used to abstract accesses to
 564   /// devices.
 565   ///
 566   EFI_SMM_CPU_IO_INTERFACE            SmmIo;
 567
 568   //
 569   // Runtime memory service
 570   //
 571   ///
 572   ///
 573   /// Allocates pool memory from SMRAM for IA-32 or runtime memory for the
 574   /// Itanium processor family.
 575   ///
 576   EFI_SMMCORE_ALLOCATE_POOL           SmmAllocatePool;
 577   ///
 578   /// Returns pool memory to the system.
 579   ///
 580   EFI_SMMCORE_FREE_POOL               SmmFreePool;
 581   ///
 582   /// Allocates memory pages from the system.
 583   ///
 584   EFI_SMMCORE_ALLOCATE_PAGES          SmmAllocatePages;
 585   ///
 586   /// Frees memory pages for the system.
 587   ///
 588   EFI_SMMCORE_FREE_PAGES              SmmFreePages;
 589
 590   //
 591   // MP service
 592   //
 593
 594   ///Inconsistent with specification here:
 595   ///  In Framework Spec, this definition does not exist. This method is introduced in PI1.0 spec for
 596   ///  implementation needed.
 597   EFI_SMM_STARTUP_THIS_AP             SmmStartupThisAp;
 598
 599   //
 600   // CPU information records
 601   //
 602   ///
 603   /// A 1-relative number between 1 and the NumberOfCpus field. This field designates
 604   /// which processor is executing the SMM infrastructure. This number also serves as an
 605   /// index into the CpuSaveState and CpuOptionalFloatingPointState
 606   /// fields.
 607   ///
 608   UINTN                               CurrentlyExecutingCpu;
 609   ///
 610   /// The number of EFI Configuration Tables in the buffer
 611   /// SmmConfigurationTable.
 612   ///
 613   UINTN                               NumberOfCpus;
 614   ///
 615   /// A pointer to the EFI Configuration Tables. The number of entries in the table is
 616   /// NumberOfTableEntries.
 617   ///
 618   EFI_SMM_CPU_SAVE_STATE              *CpuSaveState;
 619   ///
 620   /// A pointer to a catenation of the EFI_SMM_FLOATING_POINT_SAVE_STATE.
 621   /// The size of this entire table is NumberOfCpus* size of the
 622   /// EFI_SMM_FLOATING_POINT_SAVE_STATE. These fields are populated only if
 623   /// there is at least one SMM driver that has registered for a callback with the
 624   /// FloatingPointSave field in EFI_SMM_BASE_PROTOCOL.RegisterCallback() set to TRUE.
 625   ///
 626   EFI_SMM_FLOATING_POINT_SAVE_STATE   *CpuOptionalFloatingPointState;
 627
 628   //
 629   // Extensibility table
 630   //
 631   ///
 632   /// The number of EFI Configuration Tables in the buffer
 633   /// SmmConfigurationTable.
 634   ///
 635   UINTN                               NumberOfTableEntries;
 636   ///
 637   /// A pointer to the EFI Configuration Tables. The number of entries in the table is
 638   /// NumberOfTableEntries.
 639   ///
 640   EFI_CONFIGURATION_TABLE             *SmmConfigurationTable;
 641 };
 642
 643 #endif