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 _FRAMEWORK_SMM_CIS_H_
  17 #define _FRAMEWORK_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.
  55                            For write operations, the source buffer from which to write data.
  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 Framework Spec, This definition is naming EFI_SMM_FREE_POOL However,
 127          To avoid the naming conflict, the definition 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 Framework Spec, This definition is naming EFI_SMM_ALLOCATE_PAGES However,
 152          To avoid the naming conflict, the definition 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 Framework Spec, This definition is naming EFI_SMM_FREE_PAGES However,
 175          To avoid the naming conflict, the definition 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   Frees memory pages for the system.
 185
 186   @param  Procedure         A pointer to the code stream to be run on the designated AP of the system.
 187   @param  CpuNumber         The zero-based index of the processor number of the AP on which the code stream is
 188                             supposed to run. If the processor number points to the current processor or a disabled
 189                             processor, then it will not run the supplied code.
 190   @param  ProcArguments     Allows the caller to pass a list of parameters to the code that is run by
 191                             the AP. It is an optional common mailbox between APs and the BSP to share information.
 192
 193   @retval EFI_SUCCESS           The call was successful and the return parameters are valid.
 194   @retval EFI_INVALID_PARAMETER The input arguments are out of range.
 195   @retval EFI_INVALID_PARAMETER The CPU requested is not available on this SMI invocation.
 196   @retval EFI_INVALID_PARAMETER The CPU cannot support an additional service invocation.
 197
 198   @note: Inconsistent with specification here:
 199          In Framework Spec, No this definition. This method is introduced in PI1.0 spec for
 200          implementation needed.
 201
 202 **/
 203 typedef
 204 EFI_STATUS
 205 (EFIAPI *EFI_SMM_STARTUP_THIS_AP)(
 206   IN  EFI_AP_PROCEDURE                    Procedure,
 207   IN  UINTN                               CpuNumber,
 208   IN  OUT VOID                            *ProcArguments OPTIONAL
 209   );
 210
 211 ///
 212 /// The processor save-state information for IA-32 processors. This information is important in that the
 213 /// SMM drivers may need to ascertain the state of the processor before invoking the SMI.
 214 ///
 215 typedef struct {
 216   ///
 217   /// Reserved for future processors. As such, software should not attempt to interpret or
 218   /// write to this region.
 219   ///
 220   UINT8                 Reserved1[248];
 221   ///
 222   /// The location of the processor SMBASE, which is the location where the processor
 223   /// will pass control upon receipt of an SMI.
 224   ///
 225   UINT32                SMBASE;
 226   ///
 227   /// The revision of the SMM save state. This value is set by the processor.
 228   ///
 229   UINT32                SMMRevId;
 230   ///
 231   /// The value of the I/O restart field. Allows for restarting an in-process I/O instruction.
 232   ///
 233   UINT16                IORestart;
 234   ///
 235   /// Describes behavior that should be commenced in response to a halt instruction.
 236   ///
 237   UINT16                AutoHALTRestart;
 238   ///
 239   /// Reserved for future processors. As such, software should not attempt to interpret or
 240   /// write to this region.
 241   ///
 242   UINT8                 Reserved2[164];
 243
 244   //
 245   // Registers in IA-32 processors.
 246   //
 247   UINT32                ES;
 248   UINT32                CS;
 249   UINT32                SS;
 250   UINT32                DS;
 251   UINT32                FS;
 252   UINT32                GS;
 253   UINT32                LDTBase;
 254   UINT32                TR;
 255   UINT32                DR7;
 256   UINT32                DR6;
 257   UINT32                EAX;
 258   UINT32                ECX;
 259   UINT32                EDX;
 260   UINT32                EBX;
 261   UINT32                ESP;
 262   UINT32                EBP;
 263   UINT32                ESI;
 264   UINT32                EDI;
 265   UINT32                EIP;
 266   UINT32                EFLAGS;
 267   UINT32                CR3;
 268   UINT32                CR0;
 269 } EFI_SMI_CPU_SAVE_STATE;
 270
 271 ///
 272 /// The processor save-state information for the Itanium processor family. This information is
 273 /// important in that the SMM drivers may need to ascertain the state of the processor before invoking
 274 /// the PMI. This structure is mandatory and must be 512 byte aligned.
 275 ///
 276 typedef struct {
 277   UINT64   reserved;
 278   UINT64   r1;
 279   UINT64   r2;
 280   UINT64   r3;
 281   UINT64   r4;
 282   UINT64   r5;
 283   UINT64   r6;
 284   UINT64   r7;
 285   UINT64   r8;
 286   UINT64   r9;
 287   UINT64   r10;
 288   UINT64   r11;
 289   UINT64   r12;
 290   UINT64   r13;
 291   UINT64   r14;
 292   UINT64   r15;
 293   UINT64   r16;
 294   UINT64   r17;
 295   UINT64   r18;
 296   UINT64   r19;
 297   UINT64   r20;
 298   UINT64   r21;
 299   UINT64   r22;
 300   UINT64   r23;
 301   UINT64   r24;
 302   UINT64   r25;
 303   UINT64   r26;
 304   UINT64   r27;
 305   UINT64   r28;
 306   UINT64   r29;
 307   UINT64   r30;
 308   UINT64   r31;
 309
 310   UINT64   pr;
 311
 312   UINT64   b0;
 313   UINT64   b1;
 314   UINT64   b2;
 315   UINT64   b3;
 316   UINT64   b4;
 317   UINT64   b5;
 318   UINT64   b6;
 319   UINT64   b7;
 320
 321   // application registers
 322   UINT64   ar_rsc;
 323   UINT64   ar_bsp;
 324   UINT64   ar_bspstore;
 325   UINT64   ar_rnat;
 326
 327   UINT64   ar_fcr;
 328
 329   UINT64   ar_eflag;
 330   UINT64   ar_csd;
 331   UINT64   ar_ssd;
 332   UINT64   ar_cflg;
 333   UINT64   ar_fsr;
 334   UINT64   ar_fir;
 335   UINT64   ar_fdr;
 336
 337   UINT64   ar_ccv;
 338
 339   UINT64   ar_unat;
 340
 341   UINT64   ar_fpsr;
 342
 343   UINT64   ar_pfs;
 344   UINT64   ar_lc;
 345   UINT64   ar_ec;
 346
 347   // control registers
 348   UINT64   cr_dcr;
 349   UINT64   cr_itm;
 350   UINT64   cr_iva;
 351   UINT64   cr_pta;
 352   UINT64   cr_ipsr;
 353   UINT64   cr_isr;
 354   UINT64   cr_iip;
 355   UINT64   cr_ifa;
 356   UINT64   cr_itir;
 357   UINT64   cr_iipa;
 358   UINT64   cr_ifs;
 359   UINT64   cr_iim;
 360   UINT64   cr_iha;
 361
 362   // debug registers
 363   UINT64   dbr0;
 364   UINT64   dbr1;
 365   UINT64   dbr2;
 366   UINT64   dbr3;
 367   UINT64   dbr4;
 368   UINT64   dbr5;
 369   UINT64   dbr6;
 370   UINT64   dbr7;
 371
 372   UINT64   ibr0;
 373   UINT64   ibr1;
 374   UINT64   ibr2;
 375   UINT64   ibr3;
 376   UINT64   ibr4;
 377   UINT64   ibr5;
 378   UINT64   ibr6;
 379   UINT64   ibr7;
 380
 381   // virtual registers
 382   UINT64   int_nat;         // nat bits for R1-R31
 383
 384 } EFI_PMI_SYSTEM_CONTEXT;
 385
 386 ///
 387 /// The processor save-state information for IA-32 and Itanium processors. This information is
 388 /// important in that the SMM drivers may need to ascertain the state of the processor before invoking
 389 /// the SMI or PMI.
 390 ///
 391 typedef union {
 392   ///
 393   /// The processor save-state information for IA-32 processors.
 394   ///
 395   EFI_SMI_CPU_SAVE_STATE     Ia32SaveState;
 396   ///
 397   /// The processor save-state information for Itanium processors.
 398   ///
 399   EFI_PMI_SYSTEM_CONTEXT     ItaniumSaveState;
 400 } EFI_SMM_CPU_SAVE_STATE;
 401
 402 ///
 403 /// The optional floating point save-state information for IA-32 processors. If the optional floating
 404 /// point save is indicated for any handler, the following data structure must be preserved.
 405 ///
 406 typedef struct {
 407   UINT16                Fcw;
 408   UINT16                Fsw;
 409   UINT16                Ftw;
 410   UINT16                Opcode;
 411   UINT32                Eip;
 412   UINT16                Cs;
 413   UINT16                Rsvd1;
 414   UINT32                DataOffset;
 415   UINT16                Ds;
 416   UINT8                 Rsvd2[10];
 417   UINT8                 St0Mm0[10], Rsvd3[6];
 418   UINT8                 St0Mm1[10], Rsvd4[6];
 419   UINT8                 St0Mm2[10], Rsvd5[6];
 420   UINT8                 St0Mm3[10], Rsvd6[6];
 421   UINT8                 St0Mm4[10], Rsvd7[6];
 422   UINT8                 St0Mm5[10], Rsvd8[6];
 423   UINT8                 St0Mm6[10], Rsvd9[6];
 424   UINT8                 St0Mm7[10], Rsvd10[6];
 425   UINT8                 Rsvd11[22*16];
 426 } EFI_SMI_OPTIONAL_FPSAVE_STATE;
 427
 428 ///
 429 /// The optional floating point save-state information for the Itanium processor family. If the optional
 430 /// floating point save is indicated for any handler, then this data structure must be preserved.
 431 ///
 432 typedef struct {
 433   UINT64   f2[2];
 434   UINT64   f3[2];
 435   UINT64   f4[2];
 436   UINT64   f5[2];
 437   UINT64   f6[2];
 438   UINT64   f7[2];
 439   UINT64   f8[2];
 440   UINT64   f9[2];
 441   UINT64   f10[2];
 442   UINT64   f11[2];
 443   UINT64   f12[2];
 444   UINT64   f13[2];
 445   UINT64   f14[2];
 446   UINT64   f15[2];
 447   UINT64   f16[2];
 448   UINT64   f17[2];
 449   UINT64   f18[2];
 450   UINT64   f19[2];
 451   UINT64   f20[2];
 452   UINT64   f21[2];
 453   UINT64   f22[2];
 454   UINT64   f23[2];
 455   UINT64   f24[2];
 456   UINT64   f25[2];
 457   UINT64   f26[2];
 458   UINT64   f27[2];
 459   UINT64   f28[2];
 460   UINT64   f29[2];
 461   UINT64   f30[2];
 462   UINT64   f31[2];
 463 } EFI_PMI_OPTIONAL_FLOATING_POINT_CONTEXT;
 464
 465 ///
 466 /// The processor save-state information for IA-32 and Itanium processors. If the optional floating
 467 /// point save is indicated for any handler, then this data structure must be preserved.
 468 ///
 469 typedef union {
 470   ///
 471   /// The optional floating point save-state information for IA-32 processors.
 472   ///
 473   EFI_SMI_OPTIONAL_FPSAVE_STATE             Ia32FpSave;
 474   ///
 475   /// The optional floating point save-state information for Itanium processors.
 476   ///
 477   EFI_PMI_OPTIONAL_FLOATING_POINT_CONTEXT   ItaniumFpSave;
 478 } EFI_SMM_FLOATING_POINT_SAVE_STATE;
 479
 480 /**
 481   This function is the main entry point for an SMM handler dispatch
 482   or communicate-based callback.
 483
 484   @param  SmmImageHandle   A unique value returned by the SMM infrastructure
 485                            in response to registration for a communicate-based callback or dispatch.
 486   @param  CommunicationBuffer
 487                            An optional buffer that will be populated
 488                            by the SMM infrastructure in response to a non-SMM agent (preboot or runtime)
 489                            invoking the EFI_SMM_BASE_PROTOCOL.Communicate() service.
 490   @param  SourceSize       If CommunicationBuffer is non-NULL, this field
 491                            indicates the size of the data payload in this buffer.
 492
 493   @return Status Code
 494
 495 **/
 496 typedef
 497 EFI_STATUS
 498 (EFIAPI *EFI_SMM_HANDLER_ENTRY_POINT)(
 499   IN EFI_HANDLE             SmmImageHandle,
 500   IN OUT VOID               *CommunicationBuffer OPTIONAL,
 501   IN OUT UINTN              *SourceSize OPTIONAL
 502   );
 503
 504 /**
 505   The SmmInstallConfigurationTable() function is used to maintain the list
 506   of configuration tables that are stored in the System Management System
 507   Table.  The list is stored as an array of (GUID, Pointer) pairs.  The list
 508   must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
 509
 510   @param  SystemTable      A pointer to the SMM System Table.
 511   @param  Guid             A pointer to the GUID for the entry to add, update, or remove.
 512   @param  Table            A pointer to the buffer of the table to add.
 513   @param  TableSize        The size of the table to install.
 514
 515   @retval EFI_SUCCESS           The (Guid, Table) pair was added, updated, or removed.
 516   @retval EFI_INVALID_PARAMETER Guid is not valid.
 517   @retval EFI_NOT_FOUND         An attempt was made to delete a non-existent entry.
 518   @retval EFI_OUT_OF_RESOURCES  There is not enough memory available to complete the operation.
 519
 520 **/
 521 typedef
 522 EFI_STATUS
 523 (EFIAPI *EFI_SMM_INSTALL_CONFIGURATION_TABLE)(
 524   IN EFI_SMM_SYSTEM_TABLE         *SystemTable,
 525   IN EFI_GUID                     *Guid,
 526   IN VOID                         *Table,
 527   IN UINTN                        TableSize
 528   );
 529
 530 //
 531 // System Management System Table (SMST)
 532 //
 533 struct _EFI_SMM_SYSTEM_TABLE {
 534   ///
 535   /// The table header for the System Management System Table (SMST).
 536   ///
 537   EFI_TABLE_HEADER                    Hdr;
 538
 539   ///
 540   /// A pointer to a NULL-terminated Unicode string containing the vendor name. It is
 541   /// permissible for this pointer to be NULL.
 542   ///
 543   CHAR16                              *SmmFirmwareVendor;
 544   ///
 545   /// The particular revision of the firmware.
 546   ///
 547   UINT32                              SmmFirmwareRevision;
 548
 549   ///
 550   /// Adds, updates, or removes a configuration table entry from the SMST.
 551   ///
 552   EFI_SMM_INSTALL_CONFIGURATION_TABLE SmmInstallConfigurationTable;
 553
 554   //
 555   // I/O Services
 556   //
 557   ///
 558   /// A GUID that designates the particular CPU I/O services.
 559   ///
 560   EFI_GUID                            EfiSmmCpuIoGuid;
 561   ///
 562   /// Provides the basic memory and I/O interfaces that are used to abstract accesses to
 563   /// devices.
 564   ///
 565   EFI_SMM_CPU_IO_INTERFACE            SmmIo;
 566
 567   //
 568   // Runtime memory service
 569   //
 570   ///
 571   ///
 572   /// Allocates pool memory from SMRAM for IA-32 or runtime memory for the
 573   /// Itanium processor family.
 574   ///
 575   EFI_SMMCORE_ALLOCATE_POOL           SmmAllocatePool;
 576   ///
 577   /// Returns pool memory to the system.
 578   ///
 579   EFI_SMMCORE_FREE_POOL               SmmFreePool;
 580   ///
 581   /// Allocates memory pages from the system.
 582   ///
 583   EFI_SMMCORE_ALLOCATE_PAGES          SmmAllocatePages;
 584   ///
 585   /// Frees memory pages for the system.
 586   ///
 587   EFI_SMMCORE_FREE_PAGES              SmmFreePages;
 588
 589   //
 590   // MP service
 591   //
 592
 593   ///Inconsistent with specification here:
 594   ///  In Framework Spec, No this definition. This method is introduced in PI1.0 spec for
 595   ///  implementation needed.
 596   EFI_SMM_STARTUP_THIS_AP             SmmStartupThisAp;
 597
 598   //
 599   // CPU information records
 600   //
 601   ///
 602   /// A 1-relative number between 1 and the NumberOfCpus field. This field designates
 603   /// which processor is executing the SMM infrastructure. This number also serves as an
 604   /// index into the CpuSaveState and CpuOptionalFloatingPointState
 605   /// fields.
 606   ///
 607   UINTN                               CurrentlyExecutingCpu;
 608   ///
 609   /// The number of EFI Configuration Tables in the buffer
 610   /// SmmConfigurationTable.
 611   ///
 612   UINTN                               NumberOfCpus;
 613   ///
 614   /// A pointer to the EFI Configuration Tables. The number of entries in the table is
 615   /// NumberOfTableEntries.
 616   ///
 617   EFI_SMM_CPU_SAVE_STATE              *CpuSaveState;
 618   ///
 619   /// A pointer to a catenation of the EFI_SMM_FLOATING_POINT_SAVE_STATE.
 620   /// The size of this entire table is NumberOfCpus* size of the
 621   /// EFI_SMM_FLOATING_POINT_SAVE_STATE. These fields are populated only if
 622   /// there is at least one SMM driver that has registered for a callback with the
 623   /// FloatingPointSave field in EFI_SMM_BASE_PROTOCOL.RegisterCallback() set to TRUE.
 624   ///
 625   EFI_SMM_FLOATING_POINT_SAVE_STATE   *CpuOptionalFloatingPointState;
 626
 627   //
 628   // Extensibility table
 629   //
 630   ///
 631   /// The number of EFI Configuration Tables in the buffer
 632   /// SmmConfigurationTable.
 633   ///
 634   UINTN                               NumberOfTableEntries;
 635   ///
 636   /// A pointer to the EFI Configuration Tables. The number of entries in the table is
 637   /// NumberOfTableEntries.
 638   ///
 639   EFI_CONFIGURATION_TABLE             *SmmConfigurationTable;
 640 };
 641
 642 #endif