MdeModulePkg/Core/PiSmmCore/PiSmmCore.h

   1 /** @file
   2   The internal header file includes the common header files, defines
   3   internal structure and functions used by SmmCore module.
   4
   5   Copyright (c) 2009 - 2012, Intel Corporation. All rights reserved.<BR>
   6   This program and the accompanying materials are licensed and made available
   7   under the terms and conditions of the BSD License which accompanies this
   8   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_CORE_H_
  17 #define _SMM_CORE_H_
  18
  19 #include <PiSmm.h>
  20
  21 #include <Protocol/DxeSmmReadyToLock.h>
  22 #include <Protocol/SmmReadyToLock.h>
  23 #include <Protocol/CpuIo2.h>
  24 #include <Protocol/SmmCommunication.h>
  25 #include <Protocol/SmmAccess2.h>
  26 #include <Protocol/FirmwareVolume2.h>
  27 #include <Protocol/LoadedImage.h>
  28 #include <Protocol/DevicePath.h>
  29 #include <Protocol/Security.h>
  30
  31 #include <Guid/Apriori.h>
  32 #include <Guid/EventGroup.h>
  33 #include <Guid/EventLegacyBios.h>
  34
  35 #include <Library/BaseLib.h>
  36 #include <Library/BaseMemoryLib.h>
  37 #include <Library/PeCoffLib.h>
  38 #include <Library/CacheMaintenanceLib.h>
  39 #include <Library/DebugLib.h>
  40 #include <Library/ReportStatusCodeLib.h>
  41 #include <Library/MemoryAllocationLib.h>
  42 #include <Library/DevicePathLib.h>
  43 #include <Library/UefiLib.h>
  44 #include <Library/UefiBootServicesTableLib.h>
  45 #include <Library/PcdLib.h>
  46 #include <Library/SmmCorePlatformHookLib.h>
  47 #include <Library/PerformanceLib.h>
  48 #include <Library/TimerLib.h>
  49
  50 #include "PiSmmCorePrivateData.h"
  51
  52 //
  53 // Used to build a table of SMI Handlers that the SMM Core registers
  54 //
  55 typedef struct {
  56   EFI_SMM_HANDLER_ENTRY_POINT2  Handler;
  57   EFI_GUID                      *HandlerType;
  58   EFI_HANDLE                    DispatchHandle;
  59   BOOLEAN                       UnRegister;
  60 } SMM_CORE_SMI_HANDLERS;
  61
  62 //
  63 // Structure for recording the state of an SMM Driver
  64 //
  65 #define EFI_SMM_DRIVER_ENTRY_SIGNATURE SIGNATURE_32('s', 'd','r','v')
  66
  67 typedef struct {
  68   UINTN                           Signature;
  69   LIST_ENTRY                      Link;             // mDriverList
  70
  71   LIST_ENTRY                      ScheduledLink;    // mScheduledQueue
  72
  73   EFI_HANDLE                      FvHandle;
  74   EFI_GUID                        FileName;
  75   EFI_DEVICE_PATH_PROTOCOL        *FvFileDevicePath;
  76   EFI_FIRMWARE_VOLUME2_PROTOCOL   *Fv;
  77
  78   VOID                            *Depex;
  79   UINTN                           DepexSize;
  80
  81   BOOLEAN                         Before;
  82   BOOLEAN                         After;
  83   EFI_GUID                        BeforeAfterGuid;
  84
  85   BOOLEAN                         Dependent;
  86   BOOLEAN                         Scheduled;
  87   BOOLEAN                         Initialized;
  88   BOOLEAN                         DepexProtocolError;
  89
  90   EFI_HANDLE                      ImageHandle;
  91   EFI_LOADED_IMAGE_PROTOCOL       *LoadedImage;
  92   //
  93   // Image EntryPoint in SMRAM
  94   //
  95   PHYSICAL_ADDRESS                ImageEntryPoint;
  96   //
  97   // Image Buffer in SMRAM
  98   //
  99   PHYSICAL_ADDRESS                ImageBuffer;
 100   //
 101   // Image Page Number
 102   //
 103   UINTN                           NumberOfPage;
 104 } EFI_SMM_DRIVER_ENTRY;
 105
 106 #define EFI_HANDLE_SIGNATURE            SIGNATURE_32('h','n','d','l')
 107
 108 ///
 109 /// IHANDLE - contains a list of protocol handles
 110 ///
 111 typedef struct {
 112   UINTN               Signature;
 113   /// All handles list of IHANDLE
 114   LIST_ENTRY          AllHandles;
 115   /// List of PROTOCOL_INTERFACE's for this handle
 116   LIST_ENTRY          Protocols;
 117   UINTN               LocateRequest;
 118 } IHANDLE;
 119
 120 #define ASSERT_IS_HANDLE(a)  ASSERT((a)->Signature == EFI_HANDLE_SIGNATURE)
 121
 122 #define PROTOCOL_ENTRY_SIGNATURE        SIGNATURE_32('p','r','t','e')
 123
 124 ///
 125 /// PROTOCOL_ENTRY - each different protocol has 1 entry in the protocol
 126 /// database.  Each handler that supports this protocol is listed, along
 127 /// with a list of registered notifies.
 128 ///
 129 typedef struct {
 130   UINTN               Signature;
 131   /// Link Entry inserted to mProtocolDatabase
 132   LIST_ENTRY          AllEntries;
 133   /// ID of the protocol
 134   EFI_GUID            ProtocolID;
 135   /// All protocol interfaces
 136   LIST_ENTRY          Protocols;
 137   /// Registerd notification handlers
 138   LIST_ENTRY          Notify;
 139 } PROTOCOL_ENTRY;
 140
 141 #define PROTOCOL_INTERFACE_SIGNATURE  SIGNATURE_32('p','i','f','c')
 142
 143 ///
 144 /// PROTOCOL_INTERFACE - each protocol installed on a handle is tracked
 145 /// with a protocol interface structure
 146 ///
 147 typedef struct {
 148   UINTN                       Signature;
 149   /// Link on IHANDLE.Protocols
 150   LIST_ENTRY                  Link;
 151   /// Back pointer
 152   IHANDLE                     *Handle;
 153   /// Link on PROTOCOL_ENTRY.Protocols
 154   LIST_ENTRY                  ByProtocol;
 155   /// The protocol ID
 156   PROTOCOL_ENTRY              *Protocol;
 157   /// The interface value
 158   VOID                        *Interface;
 159 } PROTOCOL_INTERFACE;
 160
 161 #define PROTOCOL_NOTIFY_SIGNATURE       SIGNATURE_32('p','r','t','n')
 162
 163 ///
 164 /// PROTOCOL_NOTIFY - used for each register notification for a protocol
 165 ///
 166 typedef struct {
 167   UINTN               Signature;
 168   PROTOCOL_ENTRY      *Protocol;
 169   /// All notifications for this protocol
 170   LIST_ENTRY          Link;
 171   /// Notification function
 172   EFI_SMM_NOTIFY_FN   Function;
 173   /// Last position notified
 174   LIST_ENTRY          *Position;
 175 } PROTOCOL_NOTIFY;
 176
 177 //
 178 // SMM Core Global Variables
 179 //
 180 extern SMM_CORE_PRIVATE_DATA  *gSmmCorePrivate;
 181 extern EFI_SMM_SYSTEM_TABLE2  gSmmCoreSmst;
 182 extern LIST_ENTRY             gHandleList;
 183 extern EFI_PHYSICAL_ADDRESS   gLoadModuleAtFixAddressSmramBase;
 184
 185 /**
 186   Called to initialize the memory service.
 187
 188   @param   SmramRangeCount       Number of SMRAM Regions
 189   @param   SmramRanges           Pointer to SMRAM Descriptors
 190
 191 **/
 192 VOID
 193 SmmInitializeMemoryServices (
 194   IN UINTN                 SmramRangeCount,
 195   IN EFI_SMRAM_DESCRIPTOR  *SmramRanges
 196   );
 197
 198 /**
 199   The SmmInstallConfigurationTable() function is used to maintain the list
 200   of configuration tables that are stored in the System Management System
 201   Table.  The list is stored as an array of (GUID, Pointer) pairs.  The list
 202   must be allocated from pool memory with PoolType set to EfiRuntimeServicesData.
 203
 204   @param  SystemTable      A pointer to the SMM System Table (SMST).
 205   @param  Guid             A pointer to the GUID for the entry to add, update, or remove.
 206   @param  Table            A pointer to the buffer of the table to add.
 207   @param  TableSize        The size of the table to install.
 208
 209   @retval EFI_SUCCESS           The (Guid, Table) pair was added, updated, or removed.
 210   @retval EFI_INVALID_PARAMETER Guid is not valid.
 211   @retval EFI_NOT_FOUND         An attempt was made to delete a non-existent entry.
 212   @retval EFI_OUT_OF_RESOURCES  There is not enough memory available to complete the operation.
 213
 214 **/
 215 EFI_STATUS
 216 EFIAPI
 217 SmmInstallConfigurationTable (
 218   IN  CONST EFI_SMM_SYSTEM_TABLE2  *SystemTable,
 219   IN  CONST EFI_GUID              *Guid,
 220   IN  VOID                        *Table,
 221   IN  UINTN                       TableSize
 222   );
 223
 224 /**
 225   Wrapper function to SmmInstallProtocolInterfaceNotify.  This is the public API which
 226   Calls the private one which contains a BOOLEAN parameter for notifications
 227
 228   @param  UserHandle             The handle to install the protocol handler on,
 229                                  or NULL if a new handle is to be allocated
 230   @param  Protocol               The protocol to add to the handle
 231   @param  InterfaceType          Indicates whether Interface is supplied in
 232                                  native form.
 233   @param  Interface              The interface for the protocol being added
 234
 235   @return Status code
 236
 237 **/
 238 EFI_STATUS
 239 EFIAPI
 240 SmmInstallProtocolInterface (
 241   IN OUT EFI_HANDLE     *UserHandle,
 242   IN EFI_GUID           *Protocol,
 243   IN EFI_INTERFACE_TYPE InterfaceType,
 244   IN VOID               *Interface
 245   );
 246
 247 /**
 248   Allocates pages from the memory map.
 249
 250   @param  Type                   The type of allocation to perform
 251   @param  MemoryType             The type of memory to turn the allocated pages
 252                                  into
 253   @param  NumberOfPages          The number of pages to allocate
 254   @param  Memory                 A pointer to receive the base allocated memory
 255                                  address
 256
 257   @retval EFI_INVALID_PARAMETER  Parameters violate checking rules defined in spec.
 258   @retval EFI_NOT_FOUND          Could not allocate pages match the requirement.
 259   @retval EFI_OUT_OF_RESOURCES   No enough pages to allocate.
 260   @retval EFI_SUCCESS            Pages successfully allocated.
 261
 262 **/
 263 EFI_STATUS
 264 EFIAPI
 265 SmmAllocatePages (
 266   IN      EFI_ALLOCATE_TYPE         Type,
 267   IN      EFI_MEMORY_TYPE           MemoryType,
 268   IN      UINTN                     NumberOfPages,
 269   OUT     EFI_PHYSICAL_ADDRESS      *Memory
 270   );
 271
 272 /**
 273   Frees previous allocated pages.
 274
 275   @param  Memory                 Base address of memory being freed
 276   @param  NumberOfPages          The number of pages to free
 277
 278   @retval EFI_NOT_FOUND          Could not find the entry that covers the range
 279   @retval EFI_INVALID_PARAMETER  Address not aligned
 280   @return EFI_SUCCESS            Pages successfully freed.
 281
 282 **/
 283 EFI_STATUS
 284 EFIAPI
 285 SmmFreePages (
 286   IN      EFI_PHYSICAL_ADDRESS      Memory,
 287   IN      UINTN                     NumberOfPages
 288   );
 289
 290 /**
 291   Allocate pool of a particular type.
 292
 293   @param  PoolType               Type of pool to allocate
 294   @param  Size                   The amount of pool to allocate
 295   @param  Buffer                 The address to return a pointer to the allocated
 296                                  pool
 297
 298   @retval EFI_INVALID_PARAMETER  PoolType not valid
 299   @retval EFI_OUT_OF_RESOURCES   Size exceeds max pool size or allocation failed.
 300   @retval EFI_SUCCESS            Pool successfully allocated.
 301
 302 **/
 303 EFI_STATUS
 304 EFIAPI
 305 SmmAllocatePool (
 306   IN      EFI_MEMORY_TYPE           PoolType,
 307   IN      UINTN                     Size,
 308   OUT     VOID                      **Buffer
 309   );
 310
 311 /**
 312   Frees pool.
 313
 314   @param  Buffer                 The allocated pool entry to free
 315
 316   @retval EFI_INVALID_PARAMETER  Buffer is not a valid value.
 317   @retval EFI_SUCCESS            Pool successfully freed.
 318
 319 **/
 320 EFI_STATUS
 321 EFIAPI
 322 SmmFreePool (
 323   IN      VOID                      *Buffer
 324   );
 325
 326 /**
 327   Installs a protocol interface into the boot services environment.
 328
 329   @param  UserHandle             The handle to install the protocol handler on,
 330                                  or NULL if a new handle is to be allocated
 331   @param  Protocol               The protocol to add to the handle
 332   @param  InterfaceType          Indicates whether Interface is supplied in
 333                                  native form.
 334   @param  Interface              The interface for the protocol being added
 335   @param  Notify                 indicates whether notify the notification list
 336                                  for this protocol
 337
 338   @retval EFI_INVALID_PARAMETER  Invalid parameter
 339   @retval EFI_OUT_OF_RESOURCES   No enough buffer to allocate
 340   @retval EFI_SUCCESS            Protocol interface successfully installed
 341
 342 **/
 343 EFI_STATUS
 344 SmmInstallProtocolInterfaceNotify (
 345   IN OUT EFI_HANDLE     *UserHandle,
 346   IN EFI_GUID           *Protocol,
 347   IN EFI_INTERFACE_TYPE InterfaceType,
 348   IN VOID               *Interface,
 349   IN BOOLEAN            Notify
 350   );
 351
 352 /**
 353   Uninstalls all instances of a protocol:interfacer from a handle.
 354   If the last protocol interface is remove from the handle, the
 355   handle is freed.
 356
 357   @param  UserHandle             The handle to remove the protocol handler from
 358   @param  Protocol               The protocol, of protocol:interface, to remove
 359   @param  Interface              The interface, of protocol:interface, to remove
 360
 361   @retval EFI_INVALID_PARAMETER  Protocol is NULL.
 362   @retval EFI_SUCCESS            Protocol interface successfully uninstalled.
 363
 364 **/
 365 EFI_STATUS
 366 EFIAPI
 367 SmmUninstallProtocolInterface (
 368   IN EFI_HANDLE       UserHandle,
 369   IN EFI_GUID         *Protocol,
 370   IN VOID             *Interface
 371   );
 372
 373 /**
 374   Queries a handle to determine if it supports a specified protocol.
 375
 376   @param  UserHandle             The handle being queried.
 377   @param  Protocol               The published unique identifier of the protocol.
 378   @param  Interface              Supplies the address where a pointer to the
 379                                  corresponding Protocol Interface is returned.
 380
 381   @return The requested protocol interface for the handle
 382
 383 **/
 384 EFI_STATUS
 385 EFIAPI
 386 SmmHandleProtocol (
 387   IN EFI_HANDLE       UserHandle,
 388   IN EFI_GUID         *Protocol,
 389   OUT VOID            **Interface
 390   );
 391
 392 /**
 393   Add a new protocol notification record for the request protocol.
 394
 395   @param  Protocol               The requested protocol to add the notify
 396                                  registration
 397   @param  Function               Points to the notification function
 398   @param  Registration           Returns the registration record
 399
 400   @retval EFI_INVALID_PARAMETER  Invalid parameter
 401   @retval EFI_SUCCESS            Successfully returned the registration record
 402                                  that has been added
 403
 404 **/
 405 EFI_STATUS
 406 EFIAPI
 407 SmmRegisterProtocolNotify (
 408   IN  CONST EFI_GUID              *Protocol,
 409   IN  EFI_SMM_NOTIFY_FN           Function,
 410   OUT VOID                        **Registration
 411   );
 412
 413 /**
 414   Locates the requested handle(s) and returns them in Buffer.
 415
 416   @param  SearchType             The type of search to perform to locate the
 417                                  handles
 418   @param  Protocol               The protocol to search for
 419   @param  SearchKey              Dependant on SearchType
 420   @param  BufferSize             On input the size of Buffer.  On output the
 421                                  size of data returned.
 422   @param  Buffer                 The buffer to return the results in
 423
 424   @retval EFI_BUFFER_TOO_SMALL   Buffer too small, required buffer size is
 425                                  returned in BufferSize.
 426   @retval EFI_INVALID_PARAMETER  Invalid parameter
 427   @retval EFI_SUCCESS            Successfully found the requested handle(s) and
 428                                  returns them in Buffer.
 429
 430 **/
 431 EFI_STATUS
 432 EFIAPI
 433 SmmLocateHandle (
 434   IN EFI_LOCATE_SEARCH_TYPE   SearchType,
 435   IN EFI_GUID                 *Protocol   OPTIONAL,
 436   IN VOID                     *SearchKey  OPTIONAL,
 437   IN OUT UINTN                *BufferSize,
 438   OUT EFI_HANDLE              *Buffer
 439   );
 440
 441 /**
 442   Return the first Protocol Interface that matches the Protocol GUID. If
 443   Registration is pasased in return a Protocol Instance that was just add
 444   to the system. If Retistration is NULL return the first Protocol Interface
 445   you find.
 446
 447   @param  Protocol               The protocol to search for
 448   @param  Registration           Optional Registration Key returned from
 449                                  RegisterProtocolNotify()
 450   @param  Interface              Return the Protocol interface (instance).
 451
 452   @retval EFI_SUCCESS            If a valid Interface is returned
 453   @retval EFI_INVALID_PARAMETER  Invalid parameter
 454   @retval EFI_NOT_FOUND          Protocol interface not found
 455
 456 **/
 457 EFI_STATUS
 458 EFIAPI
 459 SmmLocateProtocol (
 460   IN  EFI_GUID  *Protocol,
 461   IN  VOID      *Registration OPTIONAL,
 462   OUT VOID      **Interface
 463   );
 464
 465 /**
 466   Manage SMI of a particular type.
 467
 468   @param  HandlerType    Points to the handler type or NULL for root SMI handlers.
 469   @param  Context        Points to an optional context buffer.
 470   @param  CommBuffer     Points to the optional communication buffer.
 471   @param  CommBufferSize Points to the size of the optional communication buffer.
 472
 473   @retval EFI_SUCCESS                        Interrupt source was processed successfully but not quiesced.
 474   @retval EFI_INTERRUPT_PENDING              One or more SMI sources could not be quiesced.
 475   @retval EFI_WARN_INTERRUPT_SOURCE_PENDING  Interrupt source was not handled or quiesced.
 476   @retval EFI_WARN_INTERRUPT_SOURCE_QUIESCED Interrupt source was handled and quiesced.
 477
 478 **/
 479 EFI_STATUS
 480 EFIAPI
 481 SmiManage (
 482   IN     CONST EFI_GUID           *HandlerType,
 483   IN     CONST VOID               *Context         OPTIONAL,
 484   IN OUT VOID                     *CommBuffer      OPTIONAL,
 485   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 486   );
 487
 488 /**
 489   Registers a handler to execute within SMM.
 490
 491   @param  Handler        Handler service funtion pointer.
 492   @param  HandlerType    Points to the handler type or NULL for root SMI handlers.
 493   @param  DispatchHandle On return, contains a unique handle which can be used to later unregister the handler function.
 494
 495   @retval EFI_SUCCESS           Handler register success.
 496   @retval EFI_INVALID_PARAMETER Handler or DispatchHandle is NULL.
 497
 498 **/
 499 EFI_STATUS
 500 EFIAPI
 501 SmiHandlerRegister (
 502   IN   EFI_SMM_HANDLER_ENTRY_POINT2   Handler,
 503   IN   CONST EFI_GUID                 *HandlerType  OPTIONAL,
 504   OUT  EFI_HANDLE                     *DispatchHandle
 505   );
 506
 507 /**
 508   Unregister a handler in SMM.
 509
 510   @param  DispatchHandle  The handle that was specified when the handler was registered.
 511
 512   @retval EFI_SUCCESS           Handler function was successfully unregistered.
 513   @retval EFI_INVALID_PARAMETER DispatchHandle does not refer to a valid handle.
 514
 515 **/
 516 EFI_STATUS
 517 EFIAPI
 518 SmiHandlerUnRegister (
 519   IN  EFI_HANDLE                      DispatchHandle
 520   );
 521
 522 /**
 523   This function is the main entry point for an SMM handler dispatch
 524   or communicate-based callback.
 525
 526   @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 527   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 528   @param  CommBuffer      A pointer to a collection of data in memory that will
 529                           be conveyed from a non-SMM environment into an SMM environment.
 530   @param  CommBufferSize  The size of the CommBuffer.
 531
 532   @return Status Code
 533
 534 **/
 535 EFI_STATUS
 536 EFIAPI
 537 SmmDriverDispatchHandler (
 538   IN     EFI_HANDLE               DispatchHandle,
 539   IN     CONST VOID               *Context,        OPTIONAL
 540   IN OUT VOID                     *CommBuffer,     OPTIONAL
 541   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 542   );
 543
 544 /**
 545   This function is the main entry point for an SMM handler dispatch
 546   or communicate-based callback.
 547
 548   @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 549   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 550   @param  CommBuffer      A pointer to a collection of data in memory that will
 551                           be conveyed from a non-SMM environment into an SMM environment.
 552   @param  CommBufferSize  The size of the CommBuffer.
 553
 554   @return Status Code
 555
 556 **/
 557 EFI_STATUS
 558 EFIAPI
 559 SmmLegacyBootHandler (
 560   IN     EFI_HANDLE               DispatchHandle,
 561   IN     CONST VOID               *Context,        OPTIONAL
 562   IN OUT VOID                     *CommBuffer,     OPTIONAL
 563   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 564   );
 565
 566 /**
 567   This function is the main entry point for an SMM handler dispatch
 568   or communicate-based callback.
 569
 570   @param  DispatchHandle  The unique handle assigned to this handler by SmiHandlerRegister().
 571   @param  Context         Points to an optional handler context which was specified when the handler was registered.
 572   @param  CommBuffer      A pointer to a collection of data in memory that will
 573                           be conveyed from a non-SMM environment into an SMM environment.
 574   @param  CommBufferSize  The size of the CommBuffer.
 575
 576   @return Status Code
 577
 578 **/
 579 EFI_STATUS
 580 EFIAPI
 581 SmmReadyToLockHandler (
 582   IN     EFI_HANDLE               DispatchHandle,
 583   IN     CONST VOID               *Context,        OPTIONAL
 584   IN OUT VOID                     *CommBuffer,     OPTIONAL
 585   IN OUT UINTN                    *CommBufferSize  OPTIONAL
 586   );
 587
 588 /**
 589   Place holder function until all the SMM System Table Service are available.
 590
 591   @param  Arg1                   Undefined
 592   @param  Arg2                   Undefined
 593   @param  Arg3                   Undefined
 594   @param  Arg4                   Undefined
 595   @param  Arg5                   Undefined
 596
 597   @return EFI_NOT_AVAILABLE_YET
 598
 599 **/
 600 EFI_STATUS
 601 EFIAPI
 602 SmmEfiNotAvailableYetArg5 (
 603   UINTN Arg1,
 604   UINTN Arg2,
 605   UINTN Arg3,
 606   UINTN Arg4,
 607   UINTN Arg5
 608   );
 609
 610 //
 611 //Functions used during debug buils
 612 //
 613
 614 /**
 615   Traverse the discovered list for any drivers that were discovered but not loaded
 616   because the dependency experessions evaluated to false.
 617
 618 **/
 619 VOID
 620 SmmDisplayDiscoveredNotDispatched (
 621   VOID
 622   );
 623
 624 /**
 625   Add free SMRAM region for use by memory service.
 626
 627   @param  MemBase                Base address of memory region.
 628   @param  MemLength              Length of the memory region.
 629   @param  Type                   Memory type.
 630   @param  Attributes             Memory region state.
 631
 632 **/
 633 VOID
 634 SmmAddMemoryRegion (
 635   IN      EFI_PHYSICAL_ADDRESS      MemBase,
 636   IN      UINT64                    MemLength,
 637   IN      EFI_MEMORY_TYPE           Type,
 638   IN      UINT64                    Attributes
 639   );
 640
 641 /**
 642   Finds the protocol entry for the requested protocol.
 643
 644   @param  Protocol               The ID of the protocol
 645   @param  Create                 Create a new entry if not found
 646
 647   @return Protocol entry
 648
 649 **/
 650 PROTOCOL_ENTRY  *
 651 SmmFindProtocolEntry (
 652   IN EFI_GUID   *Protocol,
 653   IN BOOLEAN    Create
 654   );
 655
 656 /**
 657   Signal event for every protocol in protocol entry.
 658
 659   @param  Prot                   Protocol interface
 660
 661 **/
 662 VOID
 663 SmmNotifyProtocol (
 664   IN PROTOCOL_INTERFACE   *Prot
 665   );
 666
 667 /**
 668   Finds the protocol instance for the requested handle and protocol.
 669   Note: This function doesn't do parameters checking, it's caller's responsibility
 670   to pass in valid parameters.
 671
 672   @param  Handle                 The handle to search the protocol on
 673   @param  Protocol               GUID of the protocol
 674   @param  Interface              The interface for the protocol being searched
 675
 676   @return Protocol instance (NULL: Not found)
 677
 678 **/
 679 PROTOCOL_INTERFACE *
 680 SmmFindProtocolInterface (
 681   IN IHANDLE        *Handle,
 682   IN EFI_GUID       *Protocol,
 683   IN VOID           *Interface
 684   );
 685
 686 /**
 687   Removes Protocol from the protocol list (but not the handle list).
 688
 689   @param  Handle                 The handle to remove protocol on.
 690   @param  Protocol               GUID of the protocol to be moved
 691   @param  Interface              The interface of the protocol
 692
 693   @return Protocol Entry
 694
 695 **/
 696 PROTOCOL_INTERFACE *
 697 SmmRemoveInterfaceFromProtocol (
 698   IN IHANDLE        *Handle,
 699   IN EFI_GUID       *Protocol,
 700   IN VOID           *Interface
 701   );
 702
 703 /**
 704   This is the POSTFIX version of the dependency evaluator.  This code does
 705   not need to handle Before or After, as it is not valid to call this
 706   routine in this case. POSTFIX means all the math is done on top of the stack.
 707
 708   @param  DriverEntry           DriverEntry element to update.
 709
 710   @retval TRUE                  If driver is ready to run.
 711   @retval FALSE                 If driver is not ready to run or some fatal error
 712                                 was found.
 713
 714 **/
 715 BOOLEAN
 716 SmmIsSchedulable (
 717   IN  EFI_SMM_DRIVER_ENTRY   *DriverEntry
 718   );
 719
 720 #endif